Merge storytold/main into PR #2052

2026-11-11 16:30:16 -06:00 · 2026-10-31 01:02:00 -04:00
parent 400e96c200 c1561bdffb
commit 99f90cbe2b
22 changed files with 443 additions and 41 deletions
@@ -389,6 +389,7 @@ list) · [roadmap.md](docs/roadmap.md) (milestones, plan) · [parity-checklist.m
 Newest first.

 - **2026-10-30** · Import warnings about a story have a Show button: it closes the warnings (the status line keeps them) and selects the story's first frame, fitted in the window. `file.open` returns `warningItems`, the frame each IDML or InDesign warning is about (or null), matching the converter's INDD story numbers (`story 30892`, written to IDML as `u78ac`) and IDML `Self` names to the imported stories. No readiness percentage change.
+- **2026-10-30** · Parent pages: a running-header variable shows its name in angle brackets on the parent itself (it was blank), as InDesign shows it; on the document pages, and in text with no page, it shows its text as before. No readiness percentage change.
 - **2026-10-30** · Without facing pages, a page of a multi-page spread shows the parent page in its place, as in InDesign: the second page of a two-page spread shows the parent's second page. Every single-sided page showed the parent's first page, so an InDesign book set up without facing pages but laid out in two-page spreads repeated the left parent page's items (a black heading bar) on its right pages and lost the right parent page's. No readiness percentage change.
 - **2026-10-30** · File > Package opens a dialog, as the reference app's: a Summary of fonts, links and images and inks, pages for each, a Printing Instructions step, and a PDF made with the options of a preset (#1514, #1515).
 - **2026-10-30** · IDML import reads TOC separators and entry styles written with the `$ID/` prefix or as `Properties` children, and the TOC separator notation (`^t`, `^y`, `^m`, `^>`) is shared by the dialog and IDML, with a special-character menu on the separator field (#1249, #1255).
@@ -524,6 +525,8 @@ Newest first.
 - **2026-10-18** · Table of Contents reserves the title field's width so Contents is readable next to its style picker; the grid previously squeezed it to a few characters. No readiness percentage change.
 - **2026-10-17** · Inline and anchored objects paint under their frame's text, on screen and in PDF, as InDesign draws them: a picture whose frame reaches into the next line (a negative Y offset) no longer hides the top of that line. No readiness percentage change.
 - **2026-10-17** · Running headers: *first/last on page* read a page in text order (story order, then column by column), not by height — a multi-column page's right header showed the lowest entry of column 1 instead of the page's last entry. No readiness percentage change.
+- **2026-10-17** · Cross-references keep text typed over their generated text (IDML import and export), with the page number still live, as InDesign shows them until updated; a cross-reference whose destination is gone shows its saved text and page instead of "??"; and a cross-reference's text breaks at its spaces instead of inside words. No readiness percentage change.
+- **2026-10-17** · Parent pages: while parents are edited, the document pages' hidden characters, spelling squiggles and other overlays no longer pile onto the right parent page. No readiness percentage change.
 - **2026-10-16** · A Direct Selection click on an image whose frame is already selected selects the image, so Delete removes only the image and leaves the empty frame, as in InDesign. No readiness percentage change.
 - **2026-10-16** · Type › Reload Fonts (`font.reload`): fonts installed, edited or removed while DesignCraft runs are read again without a restart, and the open documents recompose with them (#328, #547). An edited font file is noticed by its length and modification time; bundled, added and document fonts stay as they are. InDesign does this by itself, so noticing changes automatically is still open (gap 6). No readiness percentage change.
 - **2026-10-16** · Parents can be deleted from their Pages-panel context menu or `layout.parents.delete {id}`. Applied-page and based-on references are cleared, local override copies survive, and Undo restores the parent. Addresses the deletion portion of #956; no readiness percentage change.
@@ -581,8 +581,10 @@ pub struct FrameSpec {
    pub page_name: Option<String>,
    /// Marker text of the section the frame's page is in (None on parent pages).
    pub section_marker: Option<String>,
-    /// Absolute document page the frame is on (None on parent pages).
+    /// Absolute document page the frame is on (None on parent pages and the pasteboard).
    pub page: Option<usize>,
+    /// The frame is on a parent spread.
+    pub parent: bool,
    /// Baseline grid in inner space: (first grid line y, increment).
    pub grid: Option<(f64, f64)>,
    /// The frame is on a left page (for towards/away-from-spine alignment).
@@ -817,6 +819,7 @@ pub(crate) fn frame_specs_placed(doc: &Document, sid: StoryId, placed: &[(ItemId
            page_name,
            section_marker,
            page,
+            parent: matches!(spread_ref, Some(designcraft_doc::SpreadRef::Parent(_))),
            grid,
            left_page,
            right_page,
@@ -862,7 +865,7 @@ struct SubstitutionInput<'a> {
    frame: Option<&'a FrameSpec>,
    opts: &'a ComposeOptions,
    var_story: bool,
-    var_cache: &'a mut HashMap<Option<usize>, Arc<Vec<String>>>,
+    var_cache: &'a mut HashMap<(Option<usize>, bool), Arc<Vec<String>>>,
    notes: &'a mut Notes,
 }

@@ -870,7 +873,9 @@ fn paragraph_substitution(input: SubstitutionInput<'_>) -> SubstCtx {
    let SubstitutionInput { doc, story, range: prange, props: pp, frame: cur_frame, opts, var_story, var_cache, notes } = input;
    let var_values = if var_story {
        let page = opts.page.or_else(|| cur_frame.and_then(|f| f.page));
-        var_cache.entry(page).or_insert_with(|| std::sync::Arc::new(vars::values(doc, page, opts.running.as_deref()))).clone()
+        // A parent page itself (not composed for one of the pages it applies to).
+        let parent = page.is_none() && cur_frame.is_some_and(|f| f.parent);
+        var_cache.entry((page, parent)).or_insert_with(|| std::sync::Arc::new(vars::values_shown(doc, page, parent, opts.running.as_deref()))).clone()
    } else {
        Default::default()
    };
@@ -2681,7 +2686,7 @@ fn compose_with_db(doc: &Document, story: &Story, frames: &[FrameSpec], opts: &C
    let var_story = vars::has_vars(story);
    let mut notes = Notes::new(doc, story);
    let mut note_snaps: Vec<(u32, Option<usize>, usize)> = Vec::with_capacity(np);
-    let mut var_cache: std::collections::HashMap<Option<usize>, std::sync::Arc<Vec<String>>> = Default::default();
+    let mut var_cache: std::collections::HashMap<(Option<usize>, bool), std::sync::Arc<Vec<String>>> = Default::default();
    // Column balancing above spanning paragraphs: settled and trial bottoms by band, the search
    // in progress, and a budget for the re-lays.
    let mut limits: Rc<Vec<(BandKey, f64)>> = Rc::default();
@@ -5977,6 +5982,7 @@ mod column_allocation_safety_tests {
            page_name: None,
            section_marker: None,
            page: None,
+            parent: false,
            grid: None,
            left_page: false,
            right_page: false,
@@ -176,6 +176,7 @@ impl Notes {
            page_name: f.page_name.clone(),
            section_marker: f.section_marker.clone(),
            page: f.page,
+            parent: f.parent,
            grid: None,
            left_page: f.left_page,
            right_page: f.right_page,
@@ -1201,7 +1201,12 @@ fn shape_segment(
    for (gi, sg) in shaped.iter().enumerate() {
        let up = upright.get(gi).copied().unwrap_or(false);
        let (byte, len, ch) = if replacement.is_some() {
-            (range.start, if gi == 0 { range.len() } else { 0 }, text[range.start..].chars().next().unwrap_or(' '))
+            let marker = text[range.start..].chars().next().unwrap_or(' ');
+            // A cross-reference's text is real text in InDesign: its spaces are word spaces the
+            // line may break at (text variables and page numbers stay whole). The first glyph
+            // keeps the marker, as it owns the marker's bytes.
+            let space = gi > 0 && marker == designcraft_doc::XREF_MARK && src.get(sg.cluster..).is_some_and(|t| t.starts_with(' '));
+            (range.start, if gi == 0 { range.len() } else { 0 }, if space { ' ' } else { marker })
        } else {
            let cl = range.start + sg.cluster;
            let end = shaped[gi + 1..].iter().map(|r| range.start + r.cluster).find(|&c| c > cl).unwrap_or(range.end);
@@ -132,6 +132,7 @@ fn compose_cell(doc: &Document, cell: &Cell, w: f64, opts: &ComposeOptions, (lef
        page_name: opts.page_name.clone(),
        section_marker: opts.section_marker.clone(),
        page: opts.page,
+        parent: false,
        grid: None,
        left_page,
        right_page,
@@ -8409,3 +8409,34 @@ fn anchored_text_frames_compose_against_the_grid_where_they_are_placed() {
    Arc::make_mut(&mut d.spreads[1]).pages[1].side = designcraft_doc::PageSide::Left;
    assert!(!Arc::ptr_eq(&before, &cache.get(&d, nsid, None)));
 }
+
+/// A cross-reference's text breaks at its spaces like ordinary text (it is real text in
+/// InDesign), not inside words; edited text whose destination is gone shows its saved page.
+#[test]
+fn cross_reference_text_breaks_at_its_spaces() {
+    let (mut d, sid, _) = doc_with("See X.", Rect::new(36.0, 36.0, 110.0, 400.0), ParaAttrs::default());
+    let at = d.story(sid).unwrap().text.find('X').unwrap();
+    let st = d.story_mut(sid).unwrap();
+    st.delete(at..at + 1);
+    st.insert_xref(
+        at,
+        designcraft_doc::CrossRef {
+            text: Some("Page <pageNum />: Bove, Vinny. \"Advent Horizon.\" 1996. Volume 6, issue 5.".into()),
+            page: Some("7".into()),
+            ..Default::default()
+        },
+    );
+    let x = d.story(sid).unwrap().xrefs[0].clone();
+    let shown = crate::xref::xref_text(&d, &x, None);
+    assert_eq!(shown, "Page 7: Bove, Vinny. \"Advent Horizon.\" 1996. Volume 6, issue 5.");
+    let cs = compose_story(&d, sid, &ComposeOptions::default());
+    let lines: Vec<String> =
+        cs.frames[0].lines.iter().map(|l| l.glyphs.iter().filter(|g| g.visible).map(|g| g.rendered_char).collect::<String>()).collect();
+    assert!(lines.len() > 3, "{lines:?}");
+    let words: Vec<&str> = format!("See {shown}.").leak().split(' ').collect();
+    for l in &lines {
+        for w in l.split(' ').filter(|w| !w.is_empty()) {
+            assert!(words.contains(&w), "a line breaks inside a word: {w:?} in {lines:?}");
+        }
+    }
+}
@@ -160,10 +160,18 @@ impl RunningIndex {

 /// Values of every variable on `page`.
 pub fn values(doc: &Document, page: Option<usize>, running: Option<&RunningIndex>) -> Vec<String> {
+    values_shown(doc, page, false, running)
+}
+
+/// [`values`] as text shows them: on a parent page itself (`parent`, with no `page`), a running
+/// header has no entries of its own and shows which variable sits there, `<Name>`, as InDesign
+/// does. Elsewhere without a page (the pasteboard), it is its text before and after.
+pub fn values_shown(doc: &Document, page: Option<usize>, parent: bool, running: Option<&RunningIndex>) -> Vec<String> {
    doc.text_variables
        .iter()
        .enumerate()
        .map(|(i, v)| match &v.kind {
+            VarKind::RunningHeader { .. } if parent && page.is_none() => format!("<{}>", v.name),
            VarKind::RunningHeader { style, use_, character } => {
                let body = match (running, page) {
                    (Some(r), Some(p)) => r.value(style, *character, *use_, p),
@@ -52,8 +52,14 @@ impl XrefIndex {
 }

 /// The text a cross-reference shows ("??" when its destination is gone, like an unresolved
-/// reference in typesetting).
+/// reference in typesetting, unless the text was edited).
 pub fn xref_text(doc: &Document, x: &xref::CrossRef, index: Option<&XrefIndex>) -> String {
+    // Edited text stays as typed; its page numbers still follow the destination, or show the
+    // page last shown when the destination is gone (as in InDesign).
+    if let Some(t) = &x.text {
+        let live = index.filter(|_| doc.xref_values(x.target).is_some()).and_then(|i| i.page(x.target));
+        return xref::expand_edited(t, live.or(x.page.as_deref()).unwrap_or("?"));
+    }
    let Some(mut v) = doc.xref_values(x.target) else { return "??".into() };
    v.page = index.and_then(|i| i.page(x.target)).unwrap_or("?").to_string();
    let def = doc.xref_format(&x.format).map_or("<fullPara />", |f| f.definition.as_str());
@@ -29,13 +29,28 @@ pub struct TextAnchor {
    pub name: String,
 }

-#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+#[derive(Clone, Debug, Default, PartialEq, Serialize, Deserialize)]
 #[serde(rename_all = "camelCase")]
 pub struct CrossRef {
    /// The destination anchor (0 = unresolved, e.g. pasted without its destination).
    pub target: u64,
    /// Name of the format in [`Document::xref_formats`].
    pub format: String,
+    /// Text typed over the generated text (InDesign keeps a cross-reference's edited text until
+    /// it is updated): shown as is, except that each `<pageNum />` shows the destination's page.
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub text: Option<String>,
+    /// The page last shown (for edited text whose destination is gone).
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub page: Option<String>,
+}
+
+/// The `<pageNum />` building block, as it appears in [`CrossRef::text`].
+pub const PAGE_NUM_BLOCK: &str = "<pageNum />";
+
+/// Edited cross-reference text with its page numbers filled in (quotes kept as typed).
+pub fn expand_edited(text: &str, page: &str) -> String {
+    text.replace(PAGE_NUM_BLOCK, page)
 }

 /// A cross-reference format: building blocks between literal text.
@@ -212,7 +227,7 @@ impl Story {
        if n > 0 {
            let k = self.marks_before(XREF_MARK, pos);
            for i in 0..n {
-                self.xrefs.insert(k + i, Arc::new(CrossRef { target: 0, format: String::new() }));
+                self.xrefs.insert(k + i, Arc::new(CrossRef::default()));
            }
        }
        let n = text.matches(crate::index::INDEX_MARK).count();
@@ -282,7 +297,7 @@ impl Story {
        let n = self.text.matches(XREF_MARK).count();
        self.xrefs.truncate(n);
        while self.xrefs.len() < n {
-            self.xrefs.push(Arc::new(CrossRef { target: 0, format: String::new() }));
+            self.xrefs.push(Arc::new(CrossRef::default()));
        }
        let n = self.text.matches(crate::index::INDEX_MARK).count();
        self.index_refs.truncate(n);
@@ -324,6 +339,35 @@ impl Story {
 }

 impl Document {
+    /// The text a cross-reference to `target` in `format` generates, with each page number as
+    /// [`PAGE_NUM_BLOCK`] (the form saved text takes); `None` when the destination is gone.
+    pub fn generated_xref_text(&self, target: u64, format: &str) -> Option<String> {
+        let mut v = self.xref_values(target)?;
+        v.page = PAGE_NUM_BLOCK.into();
+        Some(expand(self.xref_format(format).map_or("<fullPara />", |f| f.definition.as_str()), &v))
+    }
+
+    /// Forget saved cross-reference text that is exactly what its format generates for its
+    /// destination, so it is generated again (and follows edits to the destination). Any other
+    /// saved text was typed over the generated text, or its destination is gone: it is kept as
+    /// shown.
+    pub fn drop_generated_xref_text(&mut self) {
+        let generated: Vec<(StoryId, usize)> = self
+            .stories
+            .iter()
+            .flat_map(|(sid, st)| st.xrefs.iter().enumerate().map(move |(k, x)| (*sid, k, x)))
+            .filter(|(_, _, x)| x.text.as_ref().is_some_and(|t| self.generated_xref_text(x.target, &x.format).as_ref() == Some(t)))
+            .map(|(sid, k, _)| (sid, k))
+            .collect();
+        for (sid, k) in generated {
+            if let Some(x) = self.story_mut(sid).and_then(|st| st.xrefs.get_mut(k)) {
+                let x = Arc::make_mut(x);
+                x.text = None;
+                x.page = None;
+            }
+        }
+    }
+
    /// (story, byte) of anchor `id`.
    pub fn find_anchor(&self, id: u64) -> Option<(StoryId, usize)> {
        if id == 0 {
@@ -415,6 +459,11 @@ mod tests {
        assert!(out.contains("Intro > the start"), "{out}");
    }

+    #[test]
+    fn edited_text_fills_in_its_page_numbers() {
+        assert_eq!(expand_edited("p. <pageNum /> and <pageNum />", "4"), "p. 4 and 4");
+    }
+
    #[test]
    fn formats_expand() {
        let v =
@@ -434,7 +483,7 @@ mod tests {
        let mut s = Story::with_text(StoryId(3), "Heading\nBody text.", Default::default());
        let a = s.insert_anchor(0, "Heading");
        assert_eq!(a >> 24, 3);
-        s.insert_xref(13, CrossRef { target: a, format: "Page Number".into() });
+        s.insert_xref(13, CrossRef { target: a, format: "Page Number".into(), ..Default::default() });
        s.check().unwrap();
        assert_eq!(s.anchor_pos(a), Some(0));
        s.insert(0, "New ");
@@ -1,5 +1,10 @@
 use super::*;

+fn shown_on_parent(s: &Session, d: &designcraft_doc::Document, sid: designcraft_doc::StoryId) -> usize {
+    let cs = s.cache.get(d, sid, None);
+    cs.frames.iter().flat_map(|f| f.lines.iter()).map(|l| l.glyphs.iter().filter(|g| g.visible && g.adv > 0.0).count()).sum()
+}
+
 /// A parent-page page-number marker follows Numbering & Section Options: changing a section's
 /// start number renames its pages without changing their index or the number of sections, and
 /// the marker composed for a page shows the new name.
@@ -350,6 +355,14 @@ fn running_header_on_parent_page_follows_headings() {
    assert_eq!(idx.value("Heading", false, Default::default(), 2), "Epsilon");
    let list = s.execute("variables.list", &json!({})).unwrap();
    assert!(list.as_array().unwrap().iter().any(|v| v["name"] == "Last Page Number" && v["value"] == "3"));
+    // On the parent page itself the header shows which variable it holds, not a blank. Text with
+    // no page that isn't on a parent shows the variable's text before and after, as before.
+    let head = d.variable("Chapter Head").unwrap();
+    assert_eq!(crate::compose::vars::values_shown(&d, None, true, Some(&idx))[head], "<Chapter Head>");
+    assert_eq!(crate::compose::vars::values_shown(&d, None, false, Some(&idx))[head], "");
+    assert_eq!(crate::compose::vars::values(&d, None, Some(&idx))[head], "", "values() is the no-parent case");
+    assert_eq!(crate::compose::vars::values_shown(&d, Some(2), true, Some(&idx))[head], "Epsilon", "composed for a page: its entry");
+    assert!(shown_on_parent(&s, &d, sid) > p1, "the parent shows <Chapter Head>, longer than Alpha");
    // Deleting a variable flattens its instances to text.
    s.execute("variables.delete", &json!({"name": "Last Page Number"})).unwrap();
    assert!(s.doc().unwrap().doc.story(sid).unwrap().text.ends_with(" · 3"));
@@ -94,7 +94,7 @@ fn insert(s: &mut Session, p: &Value) -> Result<Value> {
        let r = t2.range();
        let r = r.start.min(st.len())..r.end.min(st.len());
        st.delete(r.clone());
-        st.insert_xref(r.start, CrossRef { target, format });
+        st.insert_xref(r.start, CrossRef { target, format, ..Default::default() });
        let pos = r.start + designcraft_doc::XREF_MARK.len_utf8();
        sel.text = Some(TextSel { anchor: pos, focus: pos, ..t2 });
        Ok(json!({"target": target, "pos": r.start}))
@@ -169,7 +169,10 @@ fn set_format(s: &mut Session, p: &Value) -> Result<Value> {
        }
        let st = d.story_mut(sid).ok_or(designcraft_doc::DocError::NoStory(sid))?;
        let x = st.xrefs.get_mut(k).ok_or_else(|| bad("xref.setFormat", "no such cross-reference"))?;
-        std::sync::Arc::make_mut(x).format = format;
+        let x = std::sync::Arc::make_mut(x);
+        x.format = format;
+        // A new format generates the text again, replacing any edits (InDesign does the same).
+        x.text = None;
        st.rev = st.rev.wrapping_add(1);
        Ok(Value::Null)
    })
@@ -327,6 +327,33 @@ impl<'a> Ex<'a> {
        segs
    }

+    /// A cross-reference source's text: what its format generates, or the text typed over it, its
+    /// page numbers as InDesign's live cross-reference page number (as InDesign writes them, so
+    /// generated text reads back as generated).
+    fn xref_content(&mut self, c: &mut El, x: &designcraft_doc::CrossRef) {
+        let t = match &x.text {
+            Some(t) => t.clone(),
+            None => self.d.generated_xref_text(x.target, &x.format).unwrap_or_else(|| "??".into()),
+        };
+        let page = x.page.clone().unwrap_or_else(|| "?".into());
+        for (n, part) in t.split(designcraft_doc::xref::PAGE_NUM_BLOCK).enumerate() {
+            if n > 0 {
+                c.push(
+                    El::new("TextVariableInstance")
+                        .attr("Self", self.fresh())
+                        .attr("Name", "<?AID 001b?>TV XRefPageNumber")
+                        .attr("ResultText", &page)
+                        .attr("AssociatedTextVariable", "dTextVariablen<?AID 001b?>TV XRefPageNumber"),
+                );
+            }
+            if !part.is_empty() {
+                let mut content = El::new("Content");
+                content.children.push(Node::Text(part.to_string()));
+                c.push(content);
+            }
+        }
+    }
+
    fn story_para(&mut self, s: &Story, pi: usize, r: std::ops::Range<usize>, last: bool) -> El {
        let pf = s.paras.get(pi).cloned().unwrap_or_default();
        let mut psr = self.psr_el(&pf);
@@ -419,14 +446,8 @@ impl<'a> Ex<'a> {
                    if let Some(x) = s.xrefs.get(k) {
                        let me = self.fresh();
                        let fmt = self.d.xref_formats.iter().position(|ff| ff.name == x.format).map_or("n".to_string(), xref_format_self);
-                        let text = self.d.xref_values(x.target).map_or("??".into(), |mut v| {
-                            v.page = "?".into();
-                            designcraft_doc::xref::expand(self.d.xref_format(&x.format).map_or("<fullPara />", |ff| ff.definition.as_str()), &v)
-                        });
                        let mut c = self.csr_el(&f);
-                        let mut content = El::new("Content");
-                        content.children.push(Node::Text(text));
-                        c.push(content);
+                        self.xref_content(&mut c, x);
                        let mut src = El::new("CrossReferenceSource")
                            .attr("Self", &me)
                            .attr("AppliedFormat", fmt)
@@ -214,6 +214,8 @@ struct Importer<'r> {
    /// The file's text variables (`None`: it defines none) and their Self → index.
    text_vars: Option<Vec<designcraft_doc::vars::TextVariable>>,
    text_var_ids: HashMap<String, usize>,
+    /// The Self of each cross-reference page number variable (`XrefPageNumberType`).
+    xref_page_vars: HashSet<String>,
    /// Creation and modification times (Unix seconds) from the package metadata.
    created: Option<i64>,
    modified: Option<i64>,
@@ -287,6 +289,7 @@ impl<'r> Importer<'r> {
            index_xrefs: Vec::new(),
            text_vars: None,
            text_var_ids: HashMap::new(),
+            xref_page_vars: HashSet::new(),
            created: None,
            modified: None,
            repaired_tab_lists: 0,
@@ -614,6 +617,9 @@ impl<'r> Importer<'r> {
        {
            d.settings.zero_point = zp;
        }
+        // Cross-reference text the format generates exactly is generated again; any other was
+        // typed over it and is kept (needs the destinations, resolved above).
+        d.drop_generated_xref_text();
        Ok(d)
    }
 }
@@ -133,7 +133,13 @@ impl<'r> Importer<'r> {
    pub(super) fn text_variable(&mut self, e: &El) {
        use designcraft_doc::vars::{TextVariable, Use, VAR_MAX, VarKind};
        let ty = e.get("VariableType").unwrap_or("");
-        // Cross-reference internals; export writes its own.
+        // Cross-reference internals; export writes its own. Their page numbers are recognised
+        // inside cross-reference text.
+        if ty == "XrefPageNumberType"
+            && let Some(id) = e.get("Self")
+        {
+            self.xref_page_vars.insert(id.to_string());
+        }
        if ty.is_empty() || ty.starts_with("Xref") {
            return;
        }
@@ -47,10 +47,14 @@ impl<'r> Importer<'r> {
            anchor_list.push(Arc::new(designcraft_doc::TextAnchor { id: aid, name }));
        }
        let mut xref_list = Vec::new();
-        for (k, (me, fmt)) in xrefs.into_iter().enumerate() {
-            self.xref_srcs.insert(me, (id, k));
-            let format = self.xref_format_names.get(&fmt).cloned().unwrap_or_else(|| "Full Paragraph & Page Number".into());
-            xref_list.push(Arc::new(designcraft_doc::CrossRef { target: 0, format }));
+        for (k, x) in xrefs.into_iter().enumerate() {
+            self.xref_srcs.insert(x.me, (id, k));
+            let format = self.xref_format_names.get(&x.format).cloned().unwrap_or_else(|| "Full Paragraph & Page Number".into());
+            // The text as saved: once the destinations are known, text the format generates
+            // exactly is dropped to be generated again (`drop_generated_xref_text`), and text
+            // typed over it is kept, as InDesign shows it until the cross-reference is updated.
+            let saved = !x.text.is_empty();
+            xref_list.push(Arc::new(designcraft_doc::CrossRef { target: 0, format, text: saved.then_some(x.text), page: x.page.filter(|_| saved) }));
        }
        let pref = e.find("StoryPreference");
        let optical_margin = designcraft_doc::OpticalMargin {
@@ -195,7 +199,14 @@ impl<'r> Importer<'r> {
                    }
                    "CrossReferenceSource" => {
                        // The generated text is regenerated from the format.
-                        b.xrefs.push((c.get("Self").unwrap_or("").to_string(), c.get("AppliedFormat").unwrap_or("").to_string()));
+                        let (mut text, mut page) = (String::new(), None);
+                        xref_saved_text(c, &self.xref_page_vars, &mut text, &mut page, 0);
+                        b.xrefs.push(XrefSource {
+                            me: c.get("Self").unwrap_or("").to_string(),
+                            format: c.get("AppliedFormat").unwrap_or("").to_string(),
+                            text,
+                            page,
+                        });
                        // A source at paragraph level wraps a range; inside a range it holds the
                        // text directly and takes that range's format.
                        let f = c.find("CharacterStyleRange").map_or_else(|| cf.clone(), |r| self.range_format(r, pchars, cf));
@@ -402,10 +413,50 @@ struct StoryBuilder {
    /// Text destinations (Self, name) and cross-reference sources (Self, format Self) in order.
    anchors: Vec<(String, String)>,
    index_refs: Vec<designcraft_doc::IndexRef>,
-    xrefs: Vec<(String, String)>,
+    xrefs: Vec<XrefSource>,
    objects: Vec<designcraft_doc::AnchoredObject>,
 }

+/// A cross-reference source as saved: its id, its format's id, and its text with each page number
+/// as `<pageNum />` (and the page it last showed).
+struct XrefSource {
+    me: String,
+    format: String,
+    text: String,
+    page: Option<String>,
+}
+
+/// Whether a `TextVariableInstance` shows a cross-reference page number: its
+/// `AssociatedTextVariable` is a variable of that type (`page_vars`), or, in a file that doesn't
+/// define it, has the name InDesign gives that variable.
+fn is_xref_page_number(e: &El, page_vars: &HashSet<String>) -> bool {
+    e.get("AssociatedTextVariable").is_some_and(|v| page_vars.contains(v) || (page_vars.is_empty() && v.ends_with("TV XRefPageNumber")))
+}
+
+/// The text a `CrossReferenceSource` holds as shown, with its live page numbers (InDesign's
+/// cross-reference page number variable, `page_vars`) as `<pageNum />`. Tracked insertions count;
+/// tracked deletions don't. Returns the text and the page shown.
+fn xref_saved_text(e: &El, page_vars: &HashSet<String>, text: &mut String, page: &mut Option<String>, depth: usize) {
+    if depth > 16 {
+        return;
+    }
+    for c in e.elements() {
+        match c.local() {
+            "Content" => text.push_str(&c.text_content()),
+            "TextVariableInstance" if is_xref_page_number(c, page_vars) => {
+                text.push_str(designcraft_doc::xref::PAGE_NUM_BLOCK);
+                if page.is_none() {
+                    *page = c.get("ResultText").map(str::to_string);
+                }
+            }
+            "TextVariableInstance" => text.push_str(c.get("ResultText").unwrap_or("")),
+            "Change" if c.get("ChangeType") == Some("DeletedText") => {}
+            "CharacterStyleRange" | "Change" => xref_saved_text(c, page_vars, text, page, depth + 1),
+            _ => {}
+        }
+    }
+}
+
 impl StoryBuilder {
    /// A table gets an anchor paragraph of its own.
    fn push_table(&mut self, t: Table, pf: &ParaFormat, cf: &CharFormat) {
@@ -1306,7 +1306,7 @@ fn round_trips_cross_references() {
        d.add_text_frame(SpreadRef::Doc(0), Rect::new(40.0, 40.0, 400.0, 400.0), lid, "Results: found\nSee .", ParaFormat::default()).unwrap();
    let target = d.paragraph_anchor(sid, 0).unwrap();
    let at = d.story(sid).unwrap().text.find(" .").unwrap() + 1;
-    d.story_mut(sid).unwrap().insert_xref(at, designcraft_doc::CrossRef { target, format: "Paragraph Text".into() });
+    d.story_mut(sid).unwrap().insert_xref(at, designcraft_doc::CrossRef { target, format: "Paragraph Text".into(), ..Default::default() });
    d.xref_formats.push(designcraft_doc::XrefFormat {
        name: "Mine".into(),
        definition: "(<partialPara delim=\":\" includeDelim=\"true\" />, p. <pageNum />)".into(),
@@ -1318,6 +1318,7 @@ fn round_trips_cross_references() {
    assert_eq!(s.text, d.story(sid).unwrap().text);
    assert_eq!(s.xrefs.len(), 1);
    assert_eq!(s.xrefs[0].format, "Paragraph Text");
+    assert_eq!(s.xrefs[0].text, None, "generated text reads back as generated");
    let (tsid, tpos) = back.find_anchor(s.xrefs[0].target).expect("target resolves");
    assert_eq!((tsid, tpos), (s.id, 0));
    let mine = back.xref_format("Mine").unwrap();
@@ -4924,3 +4925,55 @@ fn epub_split_document_round_trips() {
        assert_eq!(import_idml(&export_idml(&d)).unwrap().settings.epub_split, want, "{attrs}");
    }
 }
+
+/// Text typed over a cross-reference's generated text is kept as shown, its page number live
+/// (InDesign's cross-reference page number variable, found by its `AssociatedTextVariable`),
+/// tracked insertions in and deletions out. The edits survive export and import.
+#[test]
+fn keeps_edited_cross_reference_text() {
+    let story = r#"<?xml version="1.0" encoding="UTF-8"?>
+<idPkg:Story xmlns:idPkg="http://ns.adobe.com/AdobeInDesign/idml/1.0/packaging" DOMVersion="16.0">
+<Story Self="s1"><ParagraphStyleRange AppliedParagraphStyle="ParagraphStyle/$ID/NormalParagraphStyle">
+<CrossReferenceSource Self="x1" AppliedFormat="n"><CharacterStyleRange AppliedCharacterStyle="CharacterStyle/$ID/[No character style]"><Content>Page </Content></CharacterStyleRange><CharacterStyleRange AppliedCharacterStyle="CharacterStyle/$ID/[No character style]"><TextVariableInstance Self="v1" Name="Seitenzahl" ResultText="7" AssociatedTextVariable="dTextVariablen&lt;?AID 001b?&gt;TV XRefPageNumber"/></CharacterStyleRange><CharacterStyleRange AppliedCharacterStyle="CharacterStyle/$ID/[No character style]"><Content>: Bove, Vinny. </Content><Change Self="c1" ChangeType="InsertedText"><Content>"Advent Horizon."</Content></Change><Change Self="c2" ChangeType="DeletedText"><Content> (draft)</Content></Change><Content> 1996.</Content></CharacterStyleRange></CrossReferenceSource>
+<CharacterStyleRange AppliedCharacterStyle="CharacterStyle/$ID/[No character style]"><Content> and </Content></CharacterStyleRange>
+<CrossReferenceSource Self="x2" AppliedFormat="n"><CharacterStyleRange AppliedCharacterStyle="CharacterStyle/$ID/[No character style]"><Content>"Intro" on page </Content><TextVariableInstance Self="v2" Name="&lt;?AID 001b?&gt;TV XRefPageNumber" ResultText="3" AssociatedTextVariable="dTextVariablen&lt;?AID 001b?&gt;TV XRefPageNumber"/></CharacterStyleRange></CrossReferenceSource>
+</ParagraphStyleRange></Story></idPkg:Story>"#;
+    let d = import_idml(&fixture_with_story(story)).unwrap();
+    d.check().unwrap();
+    let s = d.stories.values().find(|s| !s.xrefs.is_empty()).expect("story with cross-references");
+    assert_eq!(s.xrefs.len(), 2);
+    assert_eq!(s.xrefs[0].text.as_deref(), Some("Page <pageNum />: Bove, Vinny. \"Advent Horizon.\" 1996."));
+    assert_eq!(s.xrefs[0].page.as_deref(), Some("7"));
+    // Its destination is gone: the text and page it last showed.
+    assert_eq!(designcraft_compose::xref::xref_text(&d, &s.xrefs[0], None), "Page 7: Bove, Vinny. \"Advent Horizon.\" 1996.");
+    assert_eq!(s.xrefs[1].text.as_deref(), Some("\"Intro\" on page <pageNum />"), "with no destination to generate from, the text as shown");
+    let back = import_idml(&export_idml(&d)).unwrap();
+    back.check().unwrap();
+    let b = back.stories.values().find(|s| !s.xrefs.is_empty()).unwrap();
+    assert_eq!(b.xrefs[0].text, s.xrefs[0].text);
+    assert_eq!(b.xrefs[0].page, s.xrefs[0].page);
+}
+
+/// Saved cross-reference text counts as generated only when it is exactly what its format
+/// generates for its destination: text added after it (or anywhere else) is an edit, and kept.
+#[test]
+fn only_exactly_generated_cross_reference_text_is_regenerated() {
+    let mut d = Document::new(&NewDocument::default());
+    let lid = d.default_layer();
+    let (_, sid) = d.add_text_frame(SpreadRef::Doc(0), Rect::new(40.0, 40.0, 400.0, 400.0), lid, "Results\nSee", ParaFormat::default()).unwrap();
+    let target = d.paragraph_anchor(sid, 0).unwrap();
+    d.xref_formats.push(designcraft_doc::XrefFormat { name: "Page".into(), definition: "Page <pageNum />".into() });
+    for t in ["Page <pageNum />, revised", "Page <pageNum />", "Seite <pageNum />"] {
+        let st = d.story_mut(sid).unwrap();
+        let end = st.len();
+        st.insert(end, " ");
+        let x = designcraft_doc::CrossRef { target, format: "Page".into(), text: Some(t.into()), page: Some("1".into()) };
+        st.insert_xref(end + 1, x);
+    }
+    d.check().unwrap();
+    let back = import_idml(&export_idml(&d)).unwrap();
+    back.check().unwrap();
+    let s = back.stories.values().find(|s| !s.xrefs.is_empty()).unwrap();
+    let got: Vec<Option<&str>> = s.xrefs.iter().map(|x| x.text.as_deref()).collect();
+    assert_eq!(got, [Some("Page <pageNum />, revised"), None, Some("Seite <pageNum />")]);
+}
@@ -83,6 +83,7 @@ impl DesignApp {
            let was_find = self.ui.dialog.as_ref().is_some_and(|d| d.id == "findChange");
            match r {
                UiRequest::Dialog { id, params } if id == "colorTheme" => dialogs::open_color_theme(self, params),
+                UiRequest::Dialog { id, params } if id == "frameSize" => self.ui.dialog = Some(dialogs::frame_size_dialog(self, params)),
                UiRequest::Dialog { id, params } => self.ui.dialog = Some(dialogs::Dialog::new(&id, params)),
                UiRequest::View { params } => canvas::apply_view_request(self, &params),
                UiRequest::Pick { purpose, params } => {
@@ -10,7 +10,10 @@ use super::{
 /// Spread-space → canvas transform for an item at `loc`.
 pub(super) fn item_canvas_xf(doc: &Document, layout: &CanvasLayout, id: designcraft_doc::ItemId) -> Option<(Affine, &'static str)> {
    let loc = doc.find(id)?;
-    Some((layout.xf(loc.spread) * doc.parent_xf(&loc), ""))
+    // Items on spreads that aren't laid out (document pages while parents are being edited, or
+    // the reverse) have no place on the canvas.
+    let slot = layout.slot(loc.spread)?;
+    Some((slot.xf * doc.parent_xf(&loc), ""))
 }

 pub(super) fn path_screen(it: &Item, xf: &Xf, a: Affine) -> Vec<Vec<Pos2>> {
@@ -1004,6 +1004,31 @@ fn overset_frames_are_found_inside_groups() {
    assert!(out.is_empty());
 }

+/// While parents are edited, a document page's frames have no place on the canvas (they fell back
+/// to the identity transform and their ¶ marks and other overlays piled onto the right parent
+/// page), and the reverse.
+#[test]
+fn document_pages_have_no_place_on_the_parent_canvas() {
+    let mut app = DesignApp::new(designcraft_engine::Session::new(), crate::Services::default());
+    app.run("file.new", json!({"pages": 2})).unwrap();
+    let s = &mut app.session;
+    let body =
+        s.execute("frame.create", &json!({"rect": [36, 36, 300, 300], "content": "text", "text": "one\ntwo"})).unwrap()["id"].as_u64().unwrap();
+    let head = s
+        .execute("frame.create", &json!({"spread": {"kind": "parent", "index": 0}, "rect": [36, 10, 300, 30], "content": "text", "text": "head"}))
+        .unwrap()["id"]
+        .as_u64()
+        .unwrap();
+    let doc = app.session.doc().unwrap().doc.clone();
+    let (body, head) = (designcraft_doc::ItemId(body), designcraft_doc::ItemId(head));
+    let pages = CanvasLayout::new(&doc, false);
+    assert!(item_canvas_xf(&doc, &pages, body).is_some());
+    assert!(item_canvas_xf(&doc, &pages, head).is_none());
+    let parents = CanvasLayout::new(&doc, true);
+    assert!(item_canvas_xf(&doc, &parents, body).is_none(), "a page frame is not drawn over the parent");
+    assert!(item_canvas_xf(&doc, &parents, head).is_some());
+}
+
 /// The always-on overset mark sits at the frame's out port, a step along its own right edge
 /// (so a rotated frame gets it inside its edge, not straight up from the corner), and a
 /// selected overset frame gets only the mark its ports draw.
@@ -389,7 +389,8 @@ fn handle_request(app: &mut DesignApp, ctx: &egui::Context, req: &ControlRequest
            if id == "findChange" || app.ui.dialog.as_ref().is_some_and(|d| d.id == "findChange") {
                app.session.reset_find_scope();
            }
-            let d = crate::dialogs::Dialog::new(id, p.get("fields").cloned().unwrap_or(Value::Null));
+            let fields = p.get("fields").cloned().unwrap_or(Value::Null);
+            let d = if id == "frameSize" { crate::dialogs::frame_size_dialog(app, fields) } else { crate::dialogs::Dialog::new(id, fields) };
            let v = serde_json::to_value(&d).unwrap_or_default();
            app.ui.dialog = Some(d);
            ok(v)
@@ -22,6 +22,10 @@ pub struct Dialog {
    /// Set from the active document when the dialog is shown or confirmed (picas without one).
    #[serde(skip)]
    pub unit: Unit,
+    /// The vertical ruler unit, for a dialog with a height field (the Rectangle dialog): kept
+    /// from when it opened, so a bare `50` means what it did then. `None` falls back to `unit`.
+    #[serde(skip)]
+    pub vertical_unit: Option<Unit>,
 }

 impl Dialog {
@@ -81,14 +85,7 @@ impl Dialog {
        if id == "ruby" {
            fields.entry("section".to_string()).or_insert(json!("cjk.rubyPlacement"));
        }
-        if id == "frameSize" {
-            for k in ["width", "height"] {
-                if let Some(v) = fields.get(k).and_then(Value::as_f64) {
-                    fields.insert(k.into(), json!(format_measure(v, Unit::Picas)));
-                }
-            }
-        }
-        Dialog { id: id.into(), fields, unit: Unit::Picas }
+        Dialog { id: id.into(), fields, unit: Unit::Picas, vertical_unit: None }
    }
    /// Set a field and report a genuine Find domain/mode transition to the caller.
    pub(crate) fn set_field(&mut self, key: &str, value: Value) -> bool {
@@ -108,9 +105,13 @@ impl Dialog {
        }
    }
    fn m(&self, k: &str) -> Option<f64> {
+        self.m_in(k, self.unit)
+    }
+    /// A measure where a bare number is in `unit`.
+    fn m_in(&self, k: &str, unit: Unit) -> Option<f64> {
        match self.fields.get(k) {
            Some(Value::Number(n)) => n.as_f64(),
-            Some(Value::String(s)) => parse_measure(s, self.unit).ok(),
+            Some(Value::String(s)) => parse_measure(s, unit).ok(),
            _ => None,
        }
    }
@@ -1503,6 +1504,26 @@ fn doc_unit(app: &DesignApp) -> Unit {
    app.session.active().map(|s| s.doc.settings.horizontal_units).unwrap_or(Unit::Picas)
 }

+/// The document's vertical ruler unit: what a bare number means in a height field.
+fn doc_vertical_unit(app: &DesignApp) -> Unit {
+    app.session.active().map(|s| s.doc.settings.vertical_units).unwrap_or(Unit::Picas)
+}
+
+/// The Rectangle dialog a click with a frame tool opens: the width (points in `params`) shown in
+/// the horizontal ruler unit, the height in the vertical one, as Preferences › Units &
+/// Increments and the rulers' menus set them (#1964).
+pub fn frame_size_dialog(app: &DesignApp, params: Value) -> Dialog {
+    let mut d = Dialog::new("frameSize", params);
+    for (k, unit) in [("width", doc_unit(app)), ("height", doc_vertical_unit(app))] {
+        if let Some(v) = d.fields.get(k).and_then(Value::as_f64) {
+            d.fields.insert(k.into(), json!(format_measure(v, unit)));
+        }
+    }
+    d.unit = doc_unit(app);
+    d.vertical_unit = Some(doc_vertical_unit(app));
+    d
+}
+
 /// Layout › Create Guides…: guides go on every page of the spread in view (or of the parent
 /// spread being edited), as InDesign's do; "This page" narrows them to
 /// the page in view. The gutters are typed in the document's ruler unit.
@@ -4095,8 +4116,12 @@ fn format_settings(app: &mut DesignApp, ctx: &egui::Context, d: &mut Dialog) {
        d.fields.remove(FORMAT_EDIT);
        return;
    };
-    let mut fd =
-        Dialog { id: "changeFormat".into(), fields: d.fields.get(FORMAT_EDIT).and_then(Value::as_object).cloned().unwrap_or_default(), unit: d.unit };
+    let mut fd = Dialog {
+        id: "changeFormat".into(),
+        fields: d.fields.get(FORMAT_EDIT).and_then(Value::as_object).cloned().unwrap_or_default(),
+        unit: d.unit,
+        vertical_unit: None,
+    };
    let base = json!({});
    let cf = CharFields { base: &base, sparse: true };
    let find = fd.s("for") == "find";
@@ -4259,7 +4284,8 @@ fn confirm_part1(app: &mut DesignApp, d: Dialog) -> Result<Value, String> {
            let x = d.fields.get("x").and_then(Value::as_f64).unwrap_or(0.0);
            let y = d.fields.get("y").and_then(Value::as_f64).unwrap_or(0.0);
            let w = d.m("width").unwrap_or(72.0);
-            let h = d.m("height").unwrap_or(72.0);
+            // In the units the dialog showed, not ones changed while it was open.
+            let h = d.m_in("height", d.vertical_unit.unwrap_or(d.unit)).unwrap_or(72.0);
            app.run(
                "frame.create",
                json!({"spread": d.fields.get("spread").cloned().unwrap_or(json!(0)), "shape": d.s("shape"), "content": d.s("content"), "rect": [x, y, x + w, y + h]}),
@@ -4848,3 +4848,86 @@ fn convert_dialogs_use_their_separators() {
    // (The empty paragraph after a table that ends its story stays after the text.)
    assert_eq!(story.trim_end(), "Name:, Address:\nCity:, State:");
 }
+
+/// The Rectangle dialog a frame-tool click opens shows the width in the horizontal ruler unit and
+/// the height in the vertical one, not always picas, and reads bare numbers the same way (#1964).
+#[test]
+fn frame_size_dialog_follows_the_ruler_units() {
+    let mut app = DesignApp::new(designcraft_engine::Session::new(), crate::Services::default());
+    app.run("file.new", json!({})).unwrap();
+    app.run("document.preferences", json!({"horizontalUnits": "inches", "verticalUnits": "millimeters"})).unwrap();
+    // As the frame tool asks: a click at (36, 36), 72 pt by 72 pt.
+    app.session.ui_requests.push(designcraft_engine::UiRequest::Dialog {
+        id: "frameSize".into(),
+        params: json!({"spread": 0, "shape": "rectangle", "content": "graphic", "x": 36.0, "y": 36.0, "width": 72.0, "height": 72.0}),
+    });
+    app.after_engine();
+    let d = app.ui.dialog.as_ref().expect("the Rectangle dialog");
+    assert_eq!((d.id.as_str(), d.unit), ("frameSize", Unit::Inches));
+    assert_eq!(d.s("width"), format_measure(72.0, Unit::Inches));
+    assert_eq!(d.s("height"), format_measure(72.0, Unit::Millimeters));
+    assert!(!d.s("width").contains('p') && !d.s("height").contains('p'), "no picas: {} x {}", d.s("width"), d.s("height"));
+    // Bare numbers typed in each field are in that field's unit: 2 in by 50 mm.
+    let d = app.ui.dialog.as_mut().unwrap();
+    d.fields.insert("width".into(), json!("2"));
+    d.fields.insert("height".into(), json!("50"));
+    let before = app.session.doc().unwrap().doc.clone();
+    confirm(&mut app).unwrap();
+    let after = &app.session.doc().unwrap().doc;
+    let added: Vec<_> = after.spreads[0].items.iter().filter(|i| !before.spreads[0].items.iter().any(|b| b.id == i.id)).collect();
+    assert_eq!(added.len(), 1, "one frame");
+    let b = added[0].bounds();
+    assert!((b.width() - 144.0).abs() < 0.01 && (b.height() - 50.0 / 25.4 * 72.0).abs() < 0.01, "{b:?}");
+    // The properties panel's link opens it in the same units.
+    let d = frame_size_dialog(&app, json!({"width": 36.0, "height": 36.0}));
+    assert_eq!((d.s("width"), d.s("height")), (format_measure(36.0, Unit::Inches), format_measure(36.0, Unit::Millimeters)));
+    // Every ruler unit: the shown size reads back as the size, so OK leaves a 72 pt frame 72 pt.
+    let units = serde_json::to_value(Unit::ALL).unwrap();
+    for (unit, name) in Unit::ALL.iter().zip(units.as_array().unwrap()) {
+        app.run("document.preferences", json!({"horizontalUnits": name, "verticalUnits": name})).unwrap();
+        let d = frame_size_dialog(&app, json!({"width": 72.0, "height": 145.0}));
+        assert_eq!(d.unit, *unit);
+        for (k, pt) in [("width", 72.0), ("height", 145.0)] {
+            let back = d.m_in(k, *unit).unwrap_or(f64::NAN);
+            assert!((back - pt).abs() < 0.05, "{name}: {k} shows {:?}, reads back {back}", d.s(k));
+        }
+    }
+}
+
+/// #2055 review: the Rectangle dialog reads the height in the vertical unit it showed when it
+/// opened. Rulers switched while it is open (the control channel) leave a typed 50 at 50 mm.
+#[test]
+fn frame_size_dialog_keeps_its_units_while_open() {
+    let mut app = DesignApp::new(designcraft_engine::Session::new(), crate::Services::default());
+    app.run("file.new", json!({})).unwrap();
+    app.run("document.preferences", json!({"horizontalUnits": "millimeters", "verticalUnits": "millimeters"})).unwrap();
+    app.session.ui_requests.push(designcraft_engine::UiRequest::Dialog {
+        id: "frameSize".into(),
+        params: json!({"spread": 0, "shape": "rectangle", "content": "graphic", "x": 36.0, "y": 36.0, "width": 72.0, "height": 72.0}),
+    });
+    app.after_engine();
+    let d = app.ui.dialog.as_mut().expect("the Rectangle dialog");
+    d.fields.insert("width".into(), json!("50"));
+    d.fields.insert("height".into(), json!("50"));
+    app.run("document.preferences", json!({"horizontalUnits": "inches", "verticalUnits": "inches"})).unwrap();
+    let before = app.session.doc().unwrap().doc.clone();
+    confirm(&mut app).unwrap();
+    let after = &app.session.doc().unwrap().doc;
+    let added: Vec<_> = after.spreads[0].items.iter().filter(|i| !before.spreads[0].items.iter().any(|b| b.id == i.id)).collect();
+    assert_eq!(added.len(), 1, "one frame");
+    let b = added[0].bounds();
+    let mm50 = 50.0 / 25.4 * 72.0;
+    assert!((b.width() - mm50).abs() < 0.01 && (b.height() - mm50).abs() < 0.01, "50 mm by 50 mm (about 141.73 pt): {b:?}");
+    // A dialog made without the vertical unit (`Dialog::new`) reads the height in its own unit.
+    let mut d = Dialog::new("frameSize", json!({"width": "2", "height": "3"}));
+    d.unit = Unit::Inches;
+    assert_eq!(d.vertical_unit, None);
+    app.ui.dialog = Some(d);
+    let before = app.session.doc().unwrap().doc.clone();
+    confirm(&mut app).unwrap();
+    let after = &app.session.doc().unwrap().doc;
+    let added: Vec<_> = after.spreads[0].items.iter().filter(|i| !before.spreads[0].items.iter().any(|b| b.id == i.id)).collect();
+    assert_eq!(added.len(), 1, "one frame");
+    let b = added[0].bounds();
+    assert!((b.width() - 144.0).abs() < 0.01 && (b.height() - 216.0).abs() < 0.01, "{b:?}");
+}