DesignCraft: An open-source page and layout design editor written by scratch in pure Rust
PERF-MEM: release retired layouts and trim edit-history capacity
skylar taylor-barrick4e4eaad1c820
diff --git a/crates/engine/src/cmd/text.rs b/crates/engine/src/cmd/text.rsindex a75d6d473..7f9bf9df0 100644--- a/crates/engine/src/cmd/text.rs+++ b/crates/engine/src/cmd/text.rs@@ -355,6 +355,13 @@ fn release(s: &mut Session, p: &Value) -> Result<Value> {})}+// Each command edits a copy-on-write Story snapshot. Reserving its known final text growth+// avoids retaining geometric String spare capacity in every independent undo snapshot.+// General Story insertion keeps its existing amortized-growth policy for mutable builders.+fn reserve_command_text(st: &mut designcraft_doc::Story, additional: usize) -> Result<()> {+ st.text.try_reserve_exact(additional).map_err(|e| crate::EngineError::Other(format!("could not reserve text insertion: {e}")))+}+fn insert(s: &mut Session, p: &Value) -> Result<Value> {let text = super::text_param(p, "text");// Tab in a table cell moves to the next cell (Shift-Tab: `table.prevCell`).@@ -411,6 +418,7 @@ fn insert(s: &mut Session, p: &Value) -> Result<Value> {if tracking && t.cell.is_none() {// Track Changes: the replaced text is marked deleted, the typing inserted after it.let at = super::changes::mark_deleted(st, r.clone());+ reserve_command_text(st, text.len())?;let mut fmt = st.char_format_at(at).clone();fmt.over.change = Some(designcraft_doc::ChangeMark::Inserted);st.insert_with(at, &text, fmt);@@ -418,6 +426,9 @@ fn insert(s: &mut Session, p: &Value) -> Result<Value> {sel.text = Some(TextSel { anchor: pos, focus: pos, ..t });return Ok(json!({"pos": pos}));}+ let a = floor_char_boundary(&st.text, r.start.min(st.len()));+ let b = floor_char_boundary(&st.text, r.end.min(st.len())).max(a);+ reserve_command_text(st, text.len().saturating_sub(b - a))?;st.replace(r.clone(), &text);let pos = r.start + text.len() - trail;sel.text = Some(TextSel { anchor: pos, focus: pos, ..t });@@ -1638,3 +1649,41 @@ mod vertical_caret_tests {assert_eq!(mv(&mut s, "up", false, false), 3 * c);}}++#[cfg(test)]+mod reserve_tests {+ use super::*;++ #[test]+ fn failed_reservation_rolls_back_the_edit_even_after_local_text_was_removed() {+ let mut s = Session::new();+ s.execute("file.new", &json!({})).unwrap();+ let result = s.execute("frame.create", &json!({"rect":[36,36,300,300],"content":"text","text":"Keep this text."})).unwrap();+ let sid = StoryId(result["story"].as_u64().unwrap());+ s.execute("text.select", &json!({"story":sid.0,"anchor":1,"focus":4})).unwrap();+ let before = s.doc().unwrap().clone();+ assert!(before.selection.text.is_some_and(|t| !t.range().is_empty()));+ let journal = s.journal.clone();+ let error = s+ .edit(|d, sel| {+ let st = d.story_mut(sid).unwrap();+ st.format_chars(5..9, |f| f.over.change = Some(designcraft_doc::ChangeMark::Inserted));+ let at = super::super::changes::mark_deleted(st, 0..9);+ assert_eq!(at, 5);+ assert_eq!(st.text, "Keep text.");+ assert_eq!(st.format_after(0).over.change, Some(designcraft_doc::ChangeMark::Deleted));+ sel.text = None;+ reserve_command_text(st, usize::MAX)?;+ ok()+ })+ .unwrap_err();+ assert!(error.to_string().contains("could not reserve text insertion"));+ let after = s.doc().unwrap();+ assert!(std::sync::Arc::ptr_eq(&after.doc, &before.doc));+ assert_eq!(after.selection, before.selection);+ assert_eq!(after.revision, before.revision);+ assert_eq!(after.history.undo.len(), before.history.undo.len());+ assert_eq!(after.history.redo.len(), before.history.redo.len());+ assert_eq!(s.journal, journal);+ }+}diff --git a/crates/engine/src/lib.rs b/crates/engine/src/lib.rsindex 771c89b13..dc500fcb9 100644--- a/crates/engine/src/lib.rs+++ b/crates/engine/src/lib.rs@@ -380,6 +380,11 @@ impl Session {if i < self.docs.len() {self.docs.remove(i);self.active = if self.docs.is_empty() { None } else { Some(i.min(self.docs.len() - 1)) };+ if self.docs.is_empty() {+ // Retire this document generation's cache. In-flight render jobs may still+ // own it, but must not repopulate the idle session's cache after closing.+ self.cache = Arc::new(Cache::new());+ }}}diff --git a/crates/engine/tests/close_retention.rs b/crates/engine/tests/close_retention.rsnew file mode 100644index 000000000..188fc9f9b--- /dev/null+++ b/crates/engine/tests/close_retention.rs@@ -0,0 +1,132 @@+//! Engine-only ownership regression: no allocator/RSS assumptions and no cache-budget changes.++use std::sync::Arc;++use designcraft_doc::StoryId;+use designcraft_engine::Session;+use serde_json::json;++fn text_document(s: &mut Session, title: &str) -> StoryId {+ s.execute("file.new", &json!({"title":title})).unwrap();+ let result = s.execute("frame.create", &json!({"rect":[36,36,300,300],"content":"text","text":"A retained story."})).unwrap();+ StoryId(result["story"].as_u64().unwrap())+}++#[test]+fn closing_last_document_releases_current_and_previous_composition_payloads() {+ let mut s = Session::new();+ let sid = text_document(&mut s, "A");+ let original_story = Arc::downgrade(&s.doc().unwrap().doc.stories[&sid]);+ let original_layout = Arc::downgrade(&s.cache.get(&s.doc().unwrap().doc, sid, None));+ s.execute("text.select", &json!({"story":sid.0,"anchor":0,"focus":0})).unwrap();+ s.execute("text.insert", &json!({"text":"é","raw":true})).unwrap();+ let edited_story = Arc::downgrade(&s.doc().unwrap().doc.stories[&sid]);+ let edited_layout = Arc::downgrade(&s.cache.get(&s.doc().unwrap().doc, sid, None));+ assert!(original_layout.upgrade().is_some(), "previous composition is useful before close");+ assert!(edited_layout.upgrade().is_some(), "current composition is cached");+ s.execute("file.close", &json!({})).unwrap();+ assert!(s.documents().is_empty());+ assert!(original_story.upgrade().is_none(), "closed original story payload was released");+ assert!(edited_story.upgrade().is_none(), "closed edited story payload was released");+ assert!(original_layout.upgrade().is_none(), "closed previous composition was released");+ assert!(edited_layout.upgrade().is_none(), "closed current composition was released");+}++#[test]+fn last_close_detaches_in_flight_cache_without_invalidating_its_snapshot() {+ let mut s = Session::new();+ let sid = text_document(&mut s, "A");+ let in_flight_state = s.doc().unwrap().clone();+ let in_flight_cache = s.cache.clone();+ let old_cache = Arc::downgrade(&in_flight_cache);+ s.execute("file.close", &json!({})).unwrap();+ assert!(!Arc::ptr_eq(&s.cache, &in_flight_cache), "late work must not repopulate the idle session cache");+ let late_result = in_flight_cache.get(&in_flight_state.doc, sid, None);+ assert_eq!(late_result.text_len, "A retained story.".len());+ let late_weak = Arc::downgrade(&late_result);+ drop(late_result);+ drop(in_flight_cache);+ drop(in_flight_state);+ assert!(old_cache.upgrade().is_none());+ assert!(late_weak.upgrade().is_none());+}++#[test]+fn closing_another_document_keeps_open_history_and_cache() {+ let mut s = Session::new();+ let sid = text_document(&mut s, "A");+ let before = s.doc().unwrap().doc.clone();+ s.execute("text.select", &json!({"story":sid.0,"anchor":0,"focus":0})).unwrap();+ s.execute("text.insert", &json!({"text":"é","raw":true})).unwrap();+ let edited = s.doc().unwrap().doc.clone();+ let cache = s.cache.clone();+ let cached_a = Arc::downgrade(&s.cache.get(&edited, sid, None));+ text_document(&mut s, "B");+ s.execute("file.close", &json!({})).unwrap();+ assert_eq!(s.documents().len(), 1);+ assert!(Arc::ptr_eq(&s.cache, &cache));+ assert_eq!(s.doc().unwrap().doc, edited);+ assert!(cached_a.upgrade().is_some(), "closing B must not clear A’s populated cache");+ assert!(std::sync::Weak::ptr_eq(&cached_a, &Arc::downgrade(&s.cache.get(&edited, sid, None))));+ s.execute("edit.undo", &json!({})).unwrap();+ assert_eq!(s.doc().unwrap().doc, before);+ s.execute("edit.redo", &json!({})).unwrap();+ assert_eq!(s.doc().unwrap().doc, edited);+ s.close_document(usize::MAX);+ assert!(Arc::ptr_eq(&s.cache, &cache), "invalid close is a no-op");+ assert!(cached_a.upgrade().is_some(), "invalid close must not clear a populated cache");+ assert_eq!(s.doc().unwrap().doc, edited);+}++#[test]+fn closing_last_document_preserves_explicit_clipboard_ownership() {+ let mut s = Session::new();+ let sid = text_document(&mut s, "A");+ s.clipboard = Some(s.doc().unwrap().doc.clone());+ let story = Arc::downgrade(&s.doc().unwrap().doc.stories[&sid]);+ s.execute("file.close", &json!({})).unwrap();+ assert_eq!(s.clipboard.as_ref().unwrap().story(sid).unwrap().text, "A retained story.");+ assert!(story.upgrade().is_some(), "clipboard payload remains intentionally live");+ s.clipboard = None;+ assert!(story.upgrade().is_none());+}++#[test]+fn invalid_close_on_empty_session_keeps_cache_identity() {+ let mut s = Session::new();+ let cache = s.cache.clone();+ s.close_document(0);+ assert!(Arc::ptr_eq(&s.cache, &cache));+ s.close_document(usize::MAX);+ assert!(Arc::ptr_eq(&s.cache, &cache));+}++#[test]+fn closing_an_inactive_document_preserves_the_active_preview_and_cache() {+ let mut s = Session::new();+ text_document(&mut s, "Inactive");+ let sid = text_document(&mut s, "Preview");+ s.execute("data.source.select", &json!({"bytes":"TmFtZQpBZGEK","name":"people.csv"})).unwrap();+ s.execute("text.select", &json!({"story":sid.0,"anchor":0,"focus":17})).unwrap();+ s.execute("text.insert", &json!({"text":"","raw":true})).unwrap();+ s.execute("data.placeholder.add", &json!({"field":"Name"})).unwrap();+ let template = s.doc().unwrap().doc.clone();+ assert_eq!(template.story(sid).unwrap().text, "<<Name>>");+ s.execute("data.preview", &json!({"record":1})).unwrap();+ let preview = s.doc().unwrap().doc.clone();+ assert_eq!(preview.story(sid).unwrap().text, "Ada");+ let cache = s.cache.clone();+ let preview_layout = Arc::downgrade(&cache.get(&preview, sid, None));+ s.close_document(0);+ assert!(Arc::ptr_eq(&s.cache, &cache));+ assert!(Arc::ptr_eq(&s.doc().unwrap().doc, &preview));+ assert_eq!(s.doc().unwrap().preview_record, Some(1));+ assert!(Arc::ptr_eq(s.doc().unwrap().preview_stash.as_ref().unwrap(), &template));+ assert!(preview_layout.upgrade().is_some());+ drop(cache);+ drop(template);+ drop(preview);+ s.execute("file.close", &json!({})).unwrap();+ assert!(s.documents().is_empty());+ assert!(preview_layout.upgrade().is_none());+}diff --git a/crates/engine/tests/combined_close_glyph.rs b/crates/engine/tests/combined_close_glyph.rsnew file mode 100644index 000000000..73db40a14--- /dev/null+++ b/crates/engine/tests/combined_close_glyph.rs@@ -0,0 +1,188 @@+//! Combined Session-cache retirement and glyph-identity ownership regressions.++use std::sync::Arc;++use designcraft_compose::Cache;+use designcraft_doc::{Document, StoryId};+use designcraft_engine::Session;+use designcraft_render::Renderer;+use serde_json::json;++fn serial_renderer() -> Renderer {+ let mut renderer = Renderer::new();+ renderer.threads = 0;+ renderer+}++fn text_document(s: &mut Session, text: &str) -> StoryId {+ s.execute("file.new", &json!({})).unwrap();+ let value = s.execute("frame.create", &json!({"rect":[36,36,500,700],"content":"text","text":text})).unwrap();+ StoryId(value["story"].as_u64().unwrap())+}++fn checked_pixels(doc: &Document, cache: &Cache, renderer: &mut Renderer) -> Vec<u8> {+ let warm = renderer.render_page(doc, cache, 0, 1.0, false, &Default::default()).unwrap().pixels;+ let fresh = serial_renderer().render_page(doc, &Cache::new(), 0, 1.0, false, &Default::default()).unwrap().pixels;+ assert_eq!(warm, fresh);+ warm+}++#[test]+fn edited_history_closes_without_retaining_source_or_layout_but_keeps_glyph_paths() {+ let mut s = Session::new();+ let sid = text_document(&mut s, "Original visible text.");+ let mut renderer = serial_renderer();+ let before = s.doc().unwrap().doc.clone();+ let source_before = Arc::downgrade(&before.stories[&sid]);+ let layout_before = Arc::downgrade(&s.cache.get(&before, sid, None));+ let before_pixels = checked_pixels(&before, &s.cache, &mut renderer);+ s.execute("text.select", &json!({"story":sid.0,"anchor":0,"focus":0})).unwrap();+ s.execute("text.insert", &json!({"text":"é changed ","raw":true})).unwrap();+ let edited = s.doc().unwrap().doc.clone();+ assert_eq!(edited.story(sid).unwrap().text, "é changed Original visible text.");+ let source_edited = Arc::downgrade(&edited.stories[&sid]);+ let layout_edited = Arc::downgrade(&s.cache.get(&edited, sid, None));+ let edited_pixels = checked_pixels(&edited, &s.cache, &mut renderer);+ assert_ne!(before_pixels, edited_pixels);+ s.execute("edit.undo", &json!({})).unwrap();+ assert_eq!(s.doc().unwrap().doc, before);+ assert_eq!(checked_pixels(&s.doc().unwrap().doc, &s.cache, &mut renderer), before_pixels);+ let layout_undo = Arc::downgrade(&s.cache.get(&s.doc().unwrap().doc, sid, None));+ s.execute("edit.redo", &json!({})).unwrap();+ assert_eq!(s.doc().unwrap().doc, edited);+ assert_eq!(checked_pixels(&s.doc().unwrap().doc, &s.cache, &mut renderer), edited_pixels);+ let layout_redo = Arc::downgrade(&s.cache.get(&s.doc().unwrap().doc, sid, None));+ let cached_frames = renderer.cached_frames();+ assert!(cached_frames > 0);+ drop(before);+ drop(edited);+ s.execute("file.close", &json!({})).unwrap();+ assert!(s.documents().is_empty());+ assert!(source_before.upgrade().is_none());+ assert!(source_edited.upgrade().is_none());+ for layout in [layout_before, layout_edited, layout_undo, layout_redo] {+ assert!(layout.upgrade().is_none(), "neither Session nor glyph identity should own a closed layout");+ }+ assert_eq!(renderer.cached_frames(), cached_frames, "release must not evict the retained glyph paths");+}++#[test]+fn in_flight_old_document_remains_valid_while_reopened_story_uses_a_new_cache() {+ let mut s = Session::new();+ let sid = text_document(&mut s, "Old in-flight text.");+ let mut renderer = serial_renderer();+ let job_state = s.doc().unwrap().clone();+ let job_doc = job_state.doc.clone();+ let job_cache = s.cache.clone();+ let job_layout = job_cache.get(&job_doc, sid, None);+ let old_source = Arc::downgrade(&job_doc.stories[&sid]);+ let old_layout = Arc::downgrade(&job_layout);+ let old_cache = Arc::downgrade(&job_cache);+ let old_pixels = checked_pixels(&job_doc, &job_cache, &mut renderer);+ s.execute("file.close", &json!({})).unwrap();+ assert!(!Arc::ptr_eq(&s.cache, &job_cache));+ assert!(old_source.upgrade().is_some());+ assert!(old_layout.upgrade().is_some());++ let reopened_sid = text_document(&mut s, "New document, different visible text.");+ assert_eq!(reopened_sid, sid, "exercise the same per-document StoryId in a new cache generation");+ let new_source = Arc::downgrade(&s.doc().unwrap().doc.stories[&reopened_sid]);+ let new_layout = Arc::downgrade(&s.cache.get(&s.doc().unwrap().doc, reopened_sid, None));+ let new_pixels = checked_pixels(&s.doc().unwrap().doc, &s.cache, &mut renderer);+ assert_ne!(new_pixels, old_pixels);+ let cached_frames = renderer.cached_frames();+ assert_eq!(checked_pixels(&job_doc, &job_cache, &mut renderer), old_pixels);+ assert_eq!(renderer.cached_frames(), cached_frames, "old live snapshot still hits its own glyph entries");+ drop(job_state);+ drop(job_doc);+ drop(job_cache);+ assert!(old_cache.upgrade().is_none());+ assert!(old_source.upgrade().is_none());+ assert!(old_layout.upgrade().is_some(), "the explicit in-flight layout owner is still alive");+ drop(job_layout);+ assert!(old_layout.upgrade().is_none(), "the last real owner can release old layout buffers");+ assert_eq!(checked_pixels(&s.doc().unwrap().doc, &s.cache, &mut renderer), new_pixels);+ assert_eq!(renderer.cached_frames(), cached_frames);+ s.execute("file.close", &json!({})).unwrap();+ assert!(new_source.upgrade().is_none());+ assert!(new_layout.upgrade().is_none());+ assert_eq!(renderer.cached_frames(), cached_frames);+}++#[cfg(not(target_arch = "wasm32"))]+#[test]+fn scoped_font_jobs_and_owned_layouts_survive_close_and_same_story_reopen() {+ use designcraft_engine::FontScope;+ use designcraft_fonts::{FontDb, testing::font_with_glyph};++ const FAMILY: &str = "Memory Scoped Font";+ let root = std::env::temp_dir().join(format!("dc-memory-scoped-fonts-{}", std::process::id()));+ let old_folder = root.join("old");+ let new_folder = root.join("new");+ std::fs::create_dir_all(&old_folder).unwrap();+ std::fs::create_dir_all(&new_folder).unwrap();+ std::fs::write(old_folder.join("font.ttf"), font_with_glyph(FAMILY, &['x'], 'X').unwrap()).unwrap();+ std::fs::write(new_folder.join("font.ttf"), font_with_glyph(FAMILY, &['x'], 'O').unwrap()).unwrap();+ let db = FontDb::global();+ let old_fonts = db.load_document_fonts(&old_folder);+ let new_fonts = db.load_document_fonts(&new_folder);+ assert_eq!((old_fonts.faces, new_fonts.faces), (1, 1));+ assert_ne!(old_fonts.scope, new_fonts.scope);++ let mut s = Session::new();+ let sid = text_document(&mut s, "xxx");+ let state = s.doc_mut().unwrap();+ state.fonts = Some(Arc::new(FontScope(old_fonts.scope)));+ let doc = Arc::make_mut(&mut state.doc);+ doc.font_scope = old_fonts.scope;+ for style in &mut doc.styles_mut().paragraph {+ style.chars.font_family = Some(FAMILY.into());+ }+ // A job that can still compose must own DocState/FontScope, not only Arc<Document>.+ let job_state = s.doc().unwrap().clone();+ let old_doc = job_state.doc.clone();+ let old_source = Arc::downgrade(&old_doc.stories[&sid]);+ let job_cache = s.cache.clone();+ let job_layout = job_cache.get(&old_doc, sid, None);+ let layout_lifetime = Arc::downgrade(&job_layout);+ let mut renderer = serial_renderer();+ let old_pixels = checked_pixels(&old_doc, &job_cache, &mut renderer);+ s.execute("file.close", &json!({})).unwrap();+ assert!(db.scoped(old_fonts.scope).has_family(FAMILY));+ assert_eq!(checked_pixels(&job_state.doc, &job_cache, &mut renderer), old_pixels);++ let reopened_sid = text_document(&mut s, "xxx");+ assert_eq!(reopened_sid, sid);+ let state = s.doc_mut().unwrap();+ state.fonts = Some(Arc::new(FontScope(new_fonts.scope)));+ let doc = Arc::make_mut(&mut state.doc);+ doc.font_scope = new_fonts.scope;+ for style in &mut doc.styles_mut().paragraph {+ style.chars.font_family = Some(FAMILY.into());+ }+ let new_pixels = checked_pixels(&s.doc().unwrap().doc, &s.cache, &mut renderer);+ assert_ne!(old_pixels, new_pixels, "the new scope must use its own glyphs for the same family and StoryId");+ let cached_frames = renderer.cached_frames();+ drop(job_state);+ assert!(!db.scoped(old_fonts.scope).has_family(FAMILY), "Arc<Document> alone must not keep a font scope open");+ assert!(db.scoped(new_fonts.scope).has_family(FAMILY));+ assert!(Arc::ptr_eq(&job_layout, &job_cache.get(&old_doc, sid, None)));+ // Already composed layouts own their FontFaces, so even a cold glyph-path renderer works+ // after scope closure. Recomposition from a fresh Cache would require the old FontScope.+ let draw = |renderer: &mut Renderer| renderer.render_page(&old_doc, &job_cache, 0, 1.0, false, &Default::default()).unwrap().pixels;+ assert_eq!(draw(&mut renderer), old_pixels);+ assert_eq!(draw(&mut serial_renderer()), old_pixels);+ assert_eq!(renderer.cached_frames(), cached_frames);+ drop(old_doc);+ drop(job_cache);+ assert!(old_source.upgrade().is_none());+ assert!(layout_lifetime.upgrade().is_some());+ drop(job_layout);+ assert!(layout_lifetime.upgrade().is_none(), "cached glyph paths cannot own old layout buffers");+ assert_eq!(checked_pixels(&s.doc().unwrap().doc, &s.cache, &mut renderer), new_pixels);+ assert_eq!(renderer.cached_frames(), cached_frames);+ s.execute("file.close", &json!({})).unwrap();+ assert!(!db.scoped(new_fonts.scope).has_family(FAMILY));+ // FontDb's file/face caches have their own lifetime; this test claims Story/layout release.+ std::fs::remove_dir_all(root).unwrap();+}diff --git a/crates/engine/tests/text_insert_memory.rs b/crates/engine/tests/text_insert_memory.rsnew file mode 100644index 000000000..2548ef8b0--- /dev/null+++ b/crates/engine/tests/text_insert_memory.rs@@ -0,0 +1,211 @@+//! Text-command fidelity across transformed strings and editor targets.++use designcraft_doc::{ChangeMark, Document, StoryId};+use designcraft_engine::Session;+use designcraft_render::Renderer;+use serde_json::{Value, json};++fn fixture(text: &str) -> (Session, StoryId) {+ let mut s = Session::new();+ s.execute("file.new", &json!({})).unwrap();+ let r = s.execute("frame.create", &json!({"rect":[36,36,500,700],"content":"text","text":text})).unwrap();+ let sid = StoryId(r["story"].as_u64().unwrap());+ s.execute("text.select", &json!({"story":sid.0,"anchor":text.len(),"focus":text.len()})).unwrap();+ (s, sid)+}++fn fresh_pixels(s: &Session, r: &mut Renderer) -> Vec<u8> {+ let warm = r.render_page(&s.doc().unwrap().doc, &s.cache, 0, 1.0, false, &Default::default()).unwrap().pixels;+ let fresh =+ Renderer::new().render_page(&s.doc().unwrap().doc, &designcraft_compose::Cache::new(), 0, 1.0, false, &Default::default()).unwrap().pixels;+ assert_eq!(warm, fresh);+ warm+}++fn check_edit(s: &mut Session, params: Value, check: impl Fn(&Document)) {+ let before = s.doc().unwrap().doc.clone();+ let undo_len = s.doc().unwrap().history.undo.len();+ let mut renderer = Renderer::new();+ let before_pixels = fresh_pixels(s, &mut renderer);+ s.execute("text.insert", ¶ms).unwrap();+ s.doc().unwrap().doc.check().unwrap();+ check(&s.doc().unwrap().doc);+ assert_eq!(s.doc().unwrap().history.undo.len(), undo_len + 1);+ let edited = s.doc().unwrap().doc.clone();+ let edited_pixels = fresh_pixels(s, &mut renderer);+ s.execute("edit.undo", &json!({})).unwrap();+ assert_eq!(s.doc().unwrap().doc, before);+ assert_eq!(fresh_pixels(s, &mut renderer), before_pixels);+ s.execute("edit.redo", &json!({})).unwrap();+ assert_eq!(s.doc().unwrap().doc, edited);+ assert_eq!(fresh_pixels(s, &mut renderer), edited_pixels);+}++#[test]+fn unicode_replacement_keeps_expected_text_and_character_format() {+ let (mut s, sid) = fixture("Aé🦀e\u{301}Z");+ s.execute("text.select", &json!({"story":sid.0,"anchor":1,"focus":7})).unwrap();+ s.execute("type.char", &json!({"fontStyle":"Bold"})).unwrap();+ check_edit(&mut s, json!({"text":"中","raw":true}), |d| {+ let st = d.story(sid).unwrap();+ assert_eq!(st.text, "A中e\u{301}Z");+ assert_eq!(st.format_after(1).over.font_style.as_deref(), Some("Bold"));+ assert!(st.chars.iter().map(|r| r.len).sum::<usize>() == st.text.len());+ });+}++#[test]+fn smart_quotes_and_expanding_autocorrect_use_final_text() {+ let (mut s, sid) = fixture("");+ check_edit(&mut s, json!({"text":"\"a\""}), |d| assert_eq!(d.story(sid).unwrap().text, "“a”"));+ let (mut s, sid) = fixture("omw");+ s.prefs.autocorrect = true;+ s.prefs.autocorrect_list = vec![("omw".into(), "on my way".into())];+ check_edit(&mut s, json!({"text":" "}), |d| assert_eq!(d.story(sid).unwrap().text, "on my way "));+}++#[test]+fn typing_on_each_side_of_table_anchor_preserves_automatic_newlines() {+ for before in [true, false] {+ let (mut s, sid) = fixture("");+ s.execute("table.insert", &json!({"rows":1,"cols":1})).unwrap();+ let anchor = designcraft_doc::TABLE_ANCHOR;+ assert_eq!(s.doc().unwrap().doc.story(sid).unwrap().text, format!("{anchor}\n"));+ let at = if before { 0 } else { anchor.len_utf8() };+ s.execute("text.select", &json!({"story":sid.0,"anchor":at,"focus":at})).unwrap();+ check_edit(&mut s, json!({"text":"Heading","raw":true}), |d| {+ let expected = if before { format!("Heading\n{anchor}\n") } else { format!("{anchor}\nHeading\n") };+ assert_eq!(d.story(sid).unwrap().text, expected);+ assert_eq!(d.story(sid).unwrap().tables.len(), 1);+ });+ }+}++#[test]+fn tracked_replacement_retains_old_text_and_marks_new_text() {+ let (mut s, sid) = fixture("Keep this.");+ s.execute("changes.track", &json!({"on":true})).unwrap();+ s.execute("text.select", &json!({"story":sid.0,"anchor":5,"focus":9})).unwrap();+ check_edit(&mut s, json!({"text":"that","raw":true}), |d| {+ let st = d.story(sid).unwrap();+ assert_eq!(st.text, "Keep thisthat.");+ assert_eq!(st.format_after(5).over.change, Some(ChangeMark::Deleted));+ assert_eq!(st.format_after(9).over.change, Some(ChangeMark::Inserted));+ });+}++#[test]+fn replacing_already_inserted_text_does_not_retain_a_deleted_copy() {+ let (mut s, sid) = fixture("");+ s.execute("changes.track", &json!({"on":true})).unwrap();+ s.execute("text.insert", &json!({"text":"a".repeat(100_000),"raw":true})).unwrap();+ s.execute("text.select", &json!({"story":sid.0,"anchor":0,"focus":100_000})).unwrap();+ let before_capacity = s.doc().unwrap().doc.story(sid).unwrap().text.capacity();+ check_edit(&mut s, json!({"text":"b".repeat(100_000),"raw":true}), |d| {+ let st = d.story(sid).unwrap();+ assert_eq!(st.text, "b".repeat(100_000));+ assert_eq!(st.format_after(0).over.change, Some(ChangeMark::Inserted));+ assert!(st.chars.iter().all(|r| r.format.over.change != Some(ChangeMark::Deleted)));+ assert_eq!(st.text.capacity(), before_capacity, "replacing all Inserted text must reuse the cloned buffer after mark_deleted");+ println!("text_capacity_control {}", json!({"before":before_capacity,"after":st.text.capacity(),"len":st.text.len()}));+ });+}++#[test]+fn cell_and_footnote_insertions_preserve_separate_text_targets() {+ let (mut s, sid) = fixture("Body");+ let table = s.execute("table.insert", &json!({"rows":1,"cols":1})).unwrap()["table"].as_u64().unwrap();+ let root = s.doc().unwrap().doc.story(sid).unwrap().text.clone();+ check_edit(&mut s, json!({"text":"é👩💻","raw":true}), |d| {+ let st = d.story(sid).unwrap();+ assert_eq!(st.text, root);+ assert_eq!(st.tables[&table].cells[0].text.text, "é👩💻");+ });+ let (mut s, sid) = fixture("Body");+ s.execute("footnote.insert", &json!({"text":"Note"})).unwrap();+ let root = s.doc().unwrap().doc.story(sid).unwrap().text.clone();+ check_edit(&mut s, json!({"text":"é","raw":true}), |d| {+ let st = d.story(sid).unwrap();+ assert_eq!(st.text, root);+ assert_eq!(st.notes[0].text.text, "Noteé");+ });+}++#[test]+fn small_insertions_keep_history_text_capacity_at_the_exact_copy_control() {+ for tracking in [false, true] {+ let text = "a".repeat(16_384);+ let (mut s, sid) = fixture(&text);+ s.execute("changes.track", &json!({"on":tracking})).unwrap();+ let before = s.doc().unwrap().doc.clone();+ let mut expected = text;+ for addition in ["é", "🦀", "x"] {+ s.execute("text.insert", &json!({"text":addition,"raw":true})).unwrap();+ expected.push_str(addition);+ let snapshot = &s.doc().unwrap().doc;+ snapshot.check().unwrap();+ let actual = &snapshot.story(sid).unwrap().text;+ assert_eq!(actual, &expected);+ // Compare with an independent final-text copy on this allocator/toolchain. The+ // regression is geometric String growth retained in every undo snapshot, not RSS.+ assert_eq!(actual.capacity(), expected.as_str().to_owned().capacity());+ }+ for _ in 0..3 {+ s.execute("edit.undo", &json!({})).unwrap();+ }+ assert_eq!(s.doc().unwrap().doc, before);+ for _ in 0..3 {+ s.execute("edit.redo", &json!({})).unwrap();+ let actual = &s.doc().unwrap().doc.story(sid).unwrap().text;+ assert_eq!(actual.capacity(), actual.as_str().to_owned().capacity());+ }+ assert_eq!(s.doc().unwrap().doc.story(sid).unwrap().text, expected);+ }+}++#[test]+fn replacement_reserves_only_net_growth_and_shrinking_text_keeps_existing_room() {+ let original = "a".repeat(16_384);+ for inserted in ["é".repeat(4_097), "é".repeat(4_096), "é".repeat(2_000)] {+ let (mut s, sid) = fixture(&original);+ s.execute("text.select", &json!({"story":sid.0,"anchor":4_096,"focus":12_288})).unwrap();+ let before = s.doc().unwrap().doc.clone();+ s.execute("text.insert", &json!({"text":inserted,"raw":true})).unwrap();+ let expected = ["a".repeat(4_096), inserted, "a".repeat(4_096)].concat();+ let actual = &s.doc().unwrap().doc.story(sid).unwrap().text;+ assert_eq!(actual, &expected);+ let capacity_control = original.capacity().max(expected.as_str().to_owned().capacity());+ assert_eq!(actual.capacity(), capacity_control, "reserve only the replacement's positive net byte growth");+ let after = s.doc().unwrap().doc.clone();+ s.execute("edit.undo", &json!({})).unwrap();+ assert_eq!(s.doc().unwrap().doc, before);+ s.execute("edit.redo", &json!({})).unwrap();+ assert_eq!(s.doc().unwrap().doc, after);+ }+}++#[test]+fn text_insert_relocates_and_removes_current_data_merge_placeholders() {+ use designcraft_doc::PlaceholderAnchor;++ let (mut s, sid) = fixture("");+ s.execute("data.source.select", &json!({"bytes":"TmFtZQpBZGEK","name":"people.csv"})).unwrap();+ let placeholder = s.execute("data.placeholder.add", &json!({"field":"Name"})).unwrap()["id"].as_u64().unwrap();+ assert_eq!(s.doc().unwrap().doc.story(sid).unwrap().text, "<<Name>>");+ s.execute("text.select", &json!({"story":sid.0,"anchor":0,"focus":0})).unwrap();+ check_edit(&mut s, json!({"text":"é","raw":true}), |d| {+ assert_eq!(d.story(sid).unwrap().text, "é<<Name>>");+ assert_eq!(d.data_merge.placeholders.len(), 1);+ assert_eq!(d.data_merge.placeholders[0].id, placeholder);+ assert_eq!(d.data_merge.placeholders[0].anchor, PlaceholderAnchor::Text { story: sid, start: 2, end: 10 });+ });+ s.execute("data.preview", &json!({"record":1})).unwrap();+ assert_eq!(s.doc().unwrap().doc.story(sid).unwrap().text, "éAda");+ s.execute("data.preview.stop", &json!({})).unwrap();+ assert_eq!(s.doc().unwrap().doc.story(sid).unwrap().text, "é<<Name>>");+ s.execute("text.select", &json!({"story":sid.0,"anchor":2,"focus":10})).unwrap();+ check_edit(&mut s, json!({"text":"world","raw":true}), |d| {+ assert_eq!(d.story(sid).unwrap().text, "éworld");+ assert!(d.data_merge.placeholders.is_empty());+ });+}diff --git a/crates/render/src/text.rs b/crates/render/src/text.rsindex 165366eb7..2484a191b 100644--- a/crates/render/src/text.rs+++ b/crates/render/src/text.rs@@ -7,7 +7,7 @@//! the greeking threshold become grey bars without touching any outline.use std::collections::HashMap;-use std::sync::Arc;+use std::sync::{Arc, Weak};use designcraft_compose::{ComposedStory, FrameText, Line};use designcraft_doc::ItemId;@@ -37,8 +37,10 @@ pub(crate) struct FrameGlyphs {}struct Entry {- /// Keeps the composed story alive so its address can't be reused while cached.- _story: Arc<ComposedStory>,+ /// Pins only the allocation identity used by the key. The cached paths own their data;+ /// old story layout buffers can drop once composition/render users release them. A Weak+ /// still prevents this allocation address from being reused by another story.+ _story: Weak<ComposedStory>,glyphs: Arc<FrameGlyphs>,stamp: u64,}@@ -68,7 +70,7 @@ impl GlyphCache {}let g = Arc::new(build(cs, ft));self.elements += g.elements;- self.map.insert(key, Entry { _story: cs.clone(), glyphs: g.clone(), stamp });+ self.map.insert(key, Entry { _story: Arc::downgrade(cs), glyphs: g.clone(), stamp });if self.elements > MAX_ELEMENTS {self.evict();}@@ -486,3 +488,99 @@ impl Renderer {}}}++#[cfg(test)]+mod cache_identity_tests {+ use super::*;++ fn composition() -> Arc<ComposedStory> {+ Arc::new(ComposedStory { frames: vec![FrameText { frame: ItemId(1), ..Default::default() }], ..Default::default() })+ }++ fn rich_composition() -> (crate::Cache, Arc<ComposedStory>) {+ let mut doc = designcraft_doc::Document::new(&Default::default());+ for style in &mut doc.styles_mut().paragraph {+ style.chars.underline = Some(true);+ }+ let layer = doc.default_layer();+ let (_, sid) = doc+ .add_text_frame(+ designcraft_doc::SpreadRef::Doc(0),+ Rect::new(36.0, 36.0, 300.0, 300.0),+ layer,+ "Visible decorated glyphs.",+ designcraft_doc::ParaFormat::default(),+ )+ .unwrap();+ let owner = crate::Cache::new();+ let cs = owner.get(&doc, sid, None);+ (owner, cs)+ }++ #[test]+ fn cache_owns_weak_identity_and_reuses_live_glyphs() {+ let cs = composition();+ let mut cache = GlyphCache::default();+ cache.tick();+ let first = cache.get(&cs, &cs.frames[0]);+ assert_eq!(Arc::strong_count(&cs), 1, "the glyph cache must not own the whole layout");+ assert_eq!(Arc::weak_count(&cs), 1, "the glyph cache must still pin the allocation identity");+ assert!(Arc::ptr_eq(&first, &cache.get(&cs, &cs.frames[0])));+ assert_eq!(cache.len(), 1);+ }++ #[test]+ fn make_mut_moves_to_a_new_cache_identity_without_reusing_old_paths() {+ let mut cs = composition();+ let old_address = Arc::as_ptr(&cs) as usize;+ let mut cache = GlyphCache::default();+ cache.tick();+ let original_paths = cache.get(&cs, &cs.frames[0]);+ Arc::make_mut(&mut cs).text_len = 5;+ assert_ne!(Arc::as_ptr(&cs) as usize, old_address);+ let new_paths = cache.get(&cs, &cs.frames[0]);+ assert!(!Arc::ptr_eq(&original_paths, &new_paths));+ assert_eq!(cache.len(), 2);+ }++ #[test]+ fn in_flight_owner_keeps_layout_valid_then_releases_it_without_losing_outlines() {+ let (origin, cs) = rich_composition();+ let in_flight = cs.clone();+ let lifetime = Arc::downgrade(&cs);+ let mut cache = GlyphCache::default();+ cache.tick();+ let glyphs = cache.get(&cs, &cs.frames[0]);+ assert!(glyphs.elements > 0);+ let runs = glyphs.lines[0].runs.clone();+ let decorations = glyphs.lines[0].decos.clone();+ assert!(!decorations.is_empty());+ drop(cs);+ origin.clear();+ assert!(lifetime.upgrade().is_some());+ assert!(!in_flight.styles.is_empty());+ assert!(Arc::ptr_eq(&glyphs, &cache.get(&in_flight, &in_flight.frames[0])));+ drop(in_flight);+ assert!(lifetime.upgrade().is_none(), "only the real in-flight owner should keep the layout alive");+ assert_eq!(glyphs.lines[0].runs, runs);+ assert_eq!(glyphs.lines[0].decos, decorations);+ assert_eq!(cache.len(), 1, "no path eviction was needed");+ }++ #[test]+ fn clearing_cache_releases_weak_identity_but_not_independently_owned_paths() {+ let (origin, cs) = rich_composition();+ let mut cache = GlyphCache::default();+ cache.tick();+ let glyphs = cache.get(&cs, &cs.frames[0]);+ let runs = glyphs.lines[0].runs.clone();+ assert!(glyphs.elements > 0);+ assert_eq!(Arc::weak_count(&cs), 1);+ cache.clear();+ assert_eq!(Arc::weak_count(&cs), 0);+ assert_eq!(cache.len(), 0);+ origin.clear();+ drop(cs);+ assert_eq!(glyphs.lines[0].runs, runs);+ }+}diff --git a/crates/render/tests/glyph_retention.rs b/crates/render/tests/glyph_retention.rsnew file mode 100644index 000000000..6adb8412e--- /dev/null+++ b/crates/render/tests/glyph_retention.rs@@ -0,0 +1,104 @@+//! Rendering cache identity and ownership regressions without allocator/RSS assumptions.++use std::sync::Arc;++use designcraft_compose::Cache;+use designcraft_doc::{Document, ParaFormat, SpreadRef};+use designcraft_geom::Rect;+use designcraft_render::{RenderOptions, Renderer};++fn serial_renderer() -> Renderer {+ let mut renderer = Renderer::new();+ renderer.threads = 0;+ renderer+}++fn document() -> (Document, designcraft_doc::StoryId) {+ let mut doc = Document::new(&Default::default());+ let layer = doc.default_layer();+ let (_, story) = doc+ .add_text_frame(+ SpreadRef::Doc(0),+ Rect::new(36.0, 36.0, 500.0, 700.0),+ layer,+ &"A cached glyph path owns its outline. ".repeat(80),+ ParaFormat::default(),+ )+ .unwrap();+ (doc, story)+}++#[test]+fn glyph_paths_do_not_own_expired_composed_story_buffers() {+ let (doc, sid) = document();+ let cache = Cache::new();+ let mut renderer = serial_renderer();+ renderer.threads = 0;+ let layout = cache.get(&doc, sid, None);+ let lifetime = Arc::downgrade(&layout);+ let initial = renderer.render_page(&doc, &cache, 0, 1.0, false, &RenderOptions::default()).unwrap();+ let frames = renderer.cached_frames();+ assert!(frames > 0, "the regression requires actual cached glyph paths");+ drop(layout);+ assert!(lifetime.upgrade().is_some(), "the composition cache still owns this layout");+ cache.clear();+ assert!(lifetime.upgrade().is_none(), "glyph-path identity must not keep all story layout buffers alive");+ assert_eq!(renderer.cached_frames(), frames, "do not achieve release by evicting cached paths");+ let fresh = serial_renderer().render_page(&doc, &Cache::new(), 0, 1.0, false, &RenderOptions::default()).unwrap();+ let rebuilt = renderer.render_page(&doc, &cache, 0, 1.0, false, &RenderOptions::default()).unwrap();+ assert_eq!(rebuilt.pixels, initial.pixels);+ assert_eq!(rebuilt.pixels, fresh.pixels);+}++#[test]+fn repeated_cache_generations_preserve_pixels_and_do_not_pin_old_layouts() {+ let (doc, sid) = document();+ let cache = Cache::new();+ let mut renderer = serial_renderer();+ renderer.threads = 0;+ let reference = serial_renderer().render_page(&doc, &Cache::new(), 0, 1.0, false, &RenderOptions::default()).unwrap();+ for _ in 0..16 {+ let layout = cache.get(&doc, sid, None);+ let lifetime = Arc::downgrade(&layout);+ let cold = renderer.render_page(&doc, &cache, 0, 1.0, false, &RenderOptions::default()).unwrap();+ let frames = renderer.cached_frames();+ let warm = renderer.render_page(&doc, &cache, 0, 1.0, false, &RenderOptions::default()).unwrap();+ assert_eq!(cold.pixels, reference.pixels);+ assert_eq!(warm.pixels, reference.pixels);+ assert_eq!(renderer.cached_frames(), frames, "warm render must reuse existing glyph entries");+ drop(layout);+ cache.clear();+ assert!(lifetime.upgrade().is_none());+ }+}++#[test]+fn edit_style_decoration_and_snapshot_restoration_match_fresh_pixels() {+ let (original, sid) = document();+ let mut edited = original.clone();+ edited.story_mut(sid).unwrap().insert(0, "é changed text. ");+ assert!(edited.story(sid).unwrap().text.starts_with("é changed text. "));+ let mut styled = edited.clone();+ for style in &mut styled.styles_mut().paragraph {+ style.chars.font_family = Some("Source Sans 3".into());+ style.chars.underline = Some(true);+ style.chars.strikethrough = Some(true);+ }+ let cache = Cache::new();+ let mut renderer = serial_renderer();+ renderer.threads = 0;+ let mut states = Vec::new();+ for doc in [&original, &edited, &styled, &edited, &original, &edited, &styled] {+ doc.check().unwrap();+ let warm = renderer.render_page(doc, &cache, 0, 1.0, false, &RenderOptions::default()).unwrap();+ let fresh = serial_renderer().render_page(doc, &Cache::new(), 0, 1.0, false, &RenderOptions::default()).unwrap();+ assert_eq!(warm.pixels, fresh.pixels);+ states.push(warm.pixels);+ }+ assert_ne!(states[0], states[1], "text edit must affect the viewport");+ assert_ne!(states[1], states[2], "font and decorations must affect the viewport");+ assert_eq!(states[0], states[4], "original snapshot restored exactly");+ assert_eq!(states[1], states[3]);+ assert_eq!(states[1], states[5]);+ assert_eq!(states[2], states[6], "styled snapshot restored exactly");+}diff --git a/crates/ui-egui/tests/native_job_lifetime_control.rs b/crates/ui-egui/tests/native_job_lifetime_control.rsnew file mode 100644index 000000000..2cf82e5bd--- /dev/null+++ b/crates/ui-egui/tests/native_job_lifetime_control.rs@@ -0,0 +1,46 @@+//! Own a real native Job across last close. This does not run the asynchronous worker.+#![cfg(not(target_arch = "wasm32"))]++use std::sync::Arc;++use designcraft_doc::StoryId;+use designcraft_engine::Session;+use designcraft_geom::Affine;+use designcraft_render::RenderOptions;+use designcraft_ui_egui::render_worker::Job;+use serde_json::json;++#[test]+fn real_job_keeps_retired_cache_until_its_last_owner_drops() {+ let mut session = Session::new();+ session.execute("file.new", &json!({"pages": 1})).unwrap();+ let frame = session.execute("frame.create", &json!({"rect": [36, 36, 220, 320], "content": "text", "text": "Job source A."})).unwrap();+ let sid = StoryId(frame["story"].as_u64().unwrap());+ let initial = session.cache.get(&session.doc().unwrap().doc, sid, None);+ drop(initial);+ let end = session.doc().unwrap().doc.story(sid).unwrap().text.len();+ session.execute("text.select", &json!({"story": sid.0, "anchor": end, "focus": end})).unwrap();+ session.execute("text.insert", &json!({"text": " Edited B."})).unwrap();+ let current = session.cache.get(&session.doc().unwrap().doc, sid, None);+ drop(current);++ let doc = session.doc().unwrap().doc.clone();+ let source = Arc::downgrade(doc.stories.get(&sid).unwrap());+ let document = Arc::downgrade(&doc);+ let styles = Arc::downgrade(&doc.styles);+ let old_cache = Arc::downgrade(&session.cache);+ let job = Job { token: 1, doc, cache: session.cache.clone(), placed: vec![], w: 1, h: 1, view: Affine::IDENTITY, opts: RenderOptions::default() };+ session.execute("file.close", &json!({})).unwrap();+ assert!(session.documents().is_empty());+ assert!(!Arc::ptr_eq(&session.cache, &job.cache), "memory prerequisite: idle session must retire the old cache");+ assert!(source.upgrade().is_some() && document.upgrade().is_some() && old_cache.upgrade().is_some());++ // A late job may continue to write its retired cache. It cannot refill the idle one.+ job.cache.clear();+ let late = job.cache.get(&job.doc, sid, None);+ assert!(session.cache.composed_for(&job.doc, sid).is_none());+ drop(late);+ drop(job);+ assert!(old_cache.upgrade().is_none(), "no other owner was manufactured by this control");+ assert!(source.upgrade().is_none() && document.upgrade().is_none() && styles.upgrade().is_none());+}