Skip to content

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.rs
index 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.rs
index 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.rs
new file mode 100644
index 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.rs
new file mode 100644
index 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.rs
new file mode 100644
index 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", &params).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.rs
index 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.rs
new file mode 100644
index 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.rs
new file mode 100644
index 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());
+}