From 80803e3ae3d546b5b9ee360c4a08c73e227b1944 Mon Sep 17 00:00:00 2001
From: aiongg <aiongtaigi@gmail.com>
Date: Tue, 13 Oct 2026 00:21:48 +0000
Subject: [PATCH 1/2] feat(parents): a parent can be based on another parent
 (#652)

Pages draw the base parent's items, then the parent's, then their own,
on the canvas, in PDF and image export, and on the parent spread itself.
Chains are followed base first with a depth bound. Overrides, parent hit
testing and the flattener's transparency check include base items.

layout.parents.options {parent, basedOn} sets or clears the base and
refuses cycles; document.inspect reports basedOn per parent. Opening a
.designcraft or IDML file clears a cyclic or dangling base with a warning.
IDML already carried the base as the parent pages' AppliedMaster; a test
covers the round trip.
---
 ROADMAP.md                         |   1 +
 crates/doc/src/build.rs            | 124 ++++++++++++++++++++++++++++-
 crates/engine/src/cmd/export.rs    |   3 +-
 crates/engine/src/cmd/file.rs      |  23 ++++--
 crates/engine/src/cmd/inspect.rs   |   5 +-
 crates/engine/src/cmd/layout.rs    | 118 +++++++++++++++++++++++++++
 crates/engine/src/cmd/overrides.rs |  75 +++++++++++++----
 crates/idml/src/import.rs          |   3 +-
 crates/idml/src/tests.rs           |  24 ++++++
 crates/pdf/src/export.rs           |  27 ++++---
 crates/render/src/lib.rs           |  28 ++++---
 crates/tools/src/lib.rs            |  22 ++---
 crates/ui-egui/src/canvas.rs       |  13 ++-
 docs/target-app-parity.md          |   3 +-
 14 files changed, 396 insertions(+), 73 deletions(-)

diff --git a/ROADMAP.md b/ROADMAP.md
index 91a95161..6881d5ec 100644
--- a/ROADMAP.md
+++ b/ROADMAP.md
@@ -129,6 +129,7 @@ list) · [roadmap.md](docs/roadmap.md) (milestones, plan) · [parity-checklist.m
 
 Newest first.
 
+- **2026-10-13** · A parent can be based on another parent (`layout.parents.options`). Pages draw the base parent's items, then the parent's, then their own, on screen and in PDF and image export; chains work, cycles are refused, overrides reach base items, `document.inspect` reports `basedOn`, and IDML round-trips it. No readiness percentage change.
 - **2026-10-12** · macOS Dock Quit uses the same unsaved-document prompts as window and menu Quit. Repeated requests keep the current answers; Cancel retains every tab and unsaved recovery checkpoint, and completed Save/Don't Save answers exit through the ordinary event loop. No readiness percentage change.
 - **2026-10-12** · Orderly native exit writes the latest recovery state after finalizing current quit approvals; incomplete or stale plans keep their documents, and Undo to the saved state clears stale recovery. Unavailable or failed recovery is reported. Cancelable macOS Dock Quit remains open (#544). No readiness percentage change.
 - **2026-10-12** · Recovered documents keep a checkpoint until saved, closed or reverted, including a second crash before autosave. Restarted document IDs and explicit recovery folders preserve other snapshots; failed republishing retains the original. No readiness percentage change.
diff --git a/crates/doc/src/build.rs b/crates/doc/src/build.rs
index c274f213..4045819b 100644
--- a/crates/doc/src/build.rs
+++ b/crates/doc/src/build.rs
@@ -547,11 +547,82 @@ impl Document {
     pub fn parent_page_for(&self, abs: usize) -> Option<(usize, usize)> {
         let page = self.page(abs)?;
         let pi = self.parent_index(page.parent?)?;
-        let ps = &self.parents[pi];
-        // A parent spread can come without pages from a file.
-        let idx = if ps.pages.len() >= 2 && page.side == PageSide::Left { 0 } else { ps.pages.len().checked_sub(1)? };
-        Some((pi, idx))
+        Some((pi, shown_parent_page(self.parents.get(pi)?.pages.len(), page.side)?))
     }
+
+    /// Parent `pi` and the parents it is based on, base first: `[A, B]` for B based on A.
+    /// A dangling id, a repeated parent or [`MAX_PARENT_DEPTH`] ends the walk.
+    pub fn parent_chain(&self, pi: usize) -> Vec<usize> {
+        let mut out = Vec::new();
+        let mut cur = Some(pi);
+        while let Some(i) = cur {
+            let Some(ps) = self.parents.get(i) else { break };
+            if out.contains(&i) || out.len() >= MAX_PARENT_DEPTH {
+                break;
+            }
+            out.push(i);
+            cur = ps.parent.as_ref().and_then(|info| info.based_on).and_then(|b| self.parent_index(b));
+        }
+        out.reverse();
+        out
+    }
+
+    /// Parent pages drawn behind page `page` of spread `sr`, back to front, as (parent index,
+    /// parent page index). A document page shows its parent and that parent's bases; a parent page
+    /// shows the parents its spread is based on.
+    pub fn shown_parent_pages(&self, sr: SpreadRef, page: usize) -> Vec<(usize, usize)> {
+        let Some(pg) = self.spread(sr).and_then(|sp| sp.pages.get(page)) else { return Vec::new() };
+        let chain = match sr {
+            SpreadRef::Doc(_) => pg.parent.and_then(|id| self.parent_index(id)).map(|pi| self.parent_chain(pi)).unwrap_or_default(),
+            SpreadRef::Parent(pi) => {
+                let mut c = self.parent_chain(pi);
+                // The spread's own items are not part of what shows behind it.
+                if c.last() == Some(&pi) {
+                    c.pop();
+                }
+                c
+            }
+        };
+        chain.into_iter().filter_map(|i| Some((i, shown_parent_page(self.parents.get(i)?.pages.len(), pg.side)?))).collect()
+    }
+
+    /// Whether basing parent `pi` on `base` would make a `based_on` cycle (or names no parent).
+    pub fn parent_base_cycles(&self, pi: usize, base: SpreadId) -> bool {
+        self.parent_index(base).is_none_or(|bi| bi == pi || self.parent_chain(bi).contains(&pi))
+    }
+
+    /// Clear `based_on` links that name a missing parent or close a cycle (hand-edited or damaged
+    /// files). Returns one warning per link cleared.
+    pub fn fix_parent_bases(&mut self) -> Vec<String> {
+        let mut warnings = Vec::new();
+        for pi in 0..self.parents.len() {
+            let Some(ps) = self.parents.get(pi) else { continue };
+            let Some(base) = ps.parent.as_ref().and_then(|info| info.based_on) else { continue };
+            let label = ps.parent.as_ref().map(ParentInfo::label).unwrap_or_default();
+            let why = if self.parent_index(base).is_none() {
+                "names a missing parent"
+            } else if self.parent_base_cycles(pi, base) {
+                "makes a cycle"
+            } else {
+                continue;
+            };
+            if let Some(info) = self.parents.get_mut(pi).map(Arc::make_mut).and_then(|ps| ps.parent.as_mut()) {
+                info.based_on = None;
+            }
+            warnings.push(format!("parent {label}: Based on Parent {why}; it was set to [None]"));
+        }
+        warnings
+    }
+}
+
+/// Deepest `based_on` chain followed.
+pub const MAX_PARENT_DEPTH: usize = 64;
+
+/// The page of a parent spread with `count` pages that shows behind a page on `side`: the left
+/// page of a facing parent for a left page, otherwise the last page. A parent spread can come
+/// without pages from a file.
+fn shown_parent_page(count: usize, side: PageSide) -> Option<usize> {
+    if count >= 2 && side == PageSide::Left { Some(0) } else { count.checked_sub(1) }
 }
 
 #[cfg(test)]
@@ -631,4 +702,49 @@ mod tests {
         d.apply_parent(&[0], None).unwrap();
         assert_eq!(d.parent_page_for(0), None);
     }
+
+    fn base(d: &mut Document, pi: usize, on: Option<SpreadId>) {
+        Arc::make_mut(&mut d.parents[pi]).parent.as_mut().unwrap().based_on = on;
+    }
+
+    /// C based on B based on A: pages using C show A, then B, then C; C itself shows A and B.
+    #[test]
+    fn parent_chain_is_base_first() {
+        let mut d = Document::new(&NewDocument { pages: 2, facing_pages: false, ..Default::default() });
+        let a = d.parents[0].id;
+        let b = d.add_parent("B", "Parent", 1, 12.0, Margins::uniform(36.0));
+        let c = d.add_parent("C", "Parent", 1, 12.0, Margins::uniform(36.0));
+        base(&mut d, 1, Some(a));
+        base(&mut d, 2, Some(b));
+        d.apply_parent(&[1], Some(c)).unwrap();
+        assert_eq!(d.parent_chain(2), vec![0, 1, 2]);
+        assert_eq!(d.shown_parent_pages(SpreadRef::Doc(1), 0), vec![(0, 0), (1, 0), (2, 0)]);
+        assert_eq!(d.shown_parent_pages(SpreadRef::Doc(0), 0), vec![(0, 0)]);
+        assert_eq!(d.shown_parent_pages(SpreadRef::Parent(2), 0), vec![(0, 0), (1, 0)]);
+        assert!(d.parent_base_cycles(0, c), "A on C closes C → B → A");
+        assert!(d.parent_base_cycles(0, a));
+        assert!(!d.parent_base_cycles(2, a));
+        assert!(d.fix_parent_bases().is_empty());
+    }
+
+    /// A cycle or a dangling base from a file is cleared with a warning; walks stay bounded before that.
+    #[test]
+    fn fix_parent_bases_breaks_cycles_and_dangling_ids() {
+        let mut d = Document::new(&NewDocument { pages: 1, facing_pages: false, ..Default::default() });
+        let a = d.parents[0].id;
+        let b = d.add_parent("B", "Parent", 1, 12.0, Margins::uniform(36.0));
+        d.add_parent("C", "Parent", 1, 12.0, Margins::uniform(36.0));
+        base(&mut d, 0, Some(b));
+        base(&mut d, 1, Some(a));
+        base(&mut d, 2, Some(SpreadId(99_999)));
+        assert_eq!(d.parent_chain(0), vec![1, 0]);
+        assert_eq!(d.parent_chain(2), vec![2]);
+        let w = d.fix_parent_bases();
+        assert_eq!(w.len(), 2, "{w:?}");
+        assert!(w[0].contains("A-Parent") && w[0].contains("cycle"), "{w:?}");
+        assert!(w[1].contains("C-Parent") && w[1].contains("missing"), "{w:?}");
+        assert_eq!(d.parents[0].parent.as_ref().unwrap().based_on, None);
+        assert_eq!(d.parents[1].parent.as_ref().unwrap().based_on, Some(a));
+        assert_eq!(d.parents[2].parent.as_ref().unwrap().based_on, None);
+    }
 }
diff --git a/crates/engine/src/cmd/export.rs b/crates/engine/src/cmd/export.rs
index 8e0f04d6..b7891d51 100644
--- a/crates/engine/src/cmd/export.rs
+++ b/crates/engine/src/cmd/export.rs
@@ -239,7 +239,8 @@ fn flatten(d: &designcraft_doc::Document, cache: &designcraft_compose::Cache, pp
     rr.threads = designcraft_render::default_threads();
     let k = ppi / 72.0;
     let parent_transparent = |pid: Option<designcraft_doc::SpreadId>| {
-        pid.and_then(|id| d.parents.iter().find(|p| p.id == id)).is_some_and(|p| p.items.iter().any(|it| transparent(it)))
+        pid.and_then(|id| d.parent_index(id))
+            .is_some_and(|pi| d.parent_chain(pi).iter().filter_map(|&i| d.parents.get(i)).any(|p| p.items.iter().any(|it| transparent(it))))
     };
     // An opaque image item showing `img` over `r`.
     let image_item =
diff --git a/crates/engine/src/cmd/file.rs b/crates/engine/src/cmd/file.rs
index 692c363e..7cc0fe8e 100644
--- a/crates/engine/src/cmd/file.rs
+++ b/crates/engine/src/cmd/file.rs
@@ -18,9 +18,9 @@ pub fn specs() -> Vec<CommandSpec> {
         cmd!(noundo "file.newSample", "Sample Document", ["Help"], None, "{} — a multi-page magazine sample", always, file_sample),
         cmd!(query "file.presets", "Document Presets", [], None, "{}", always, |_, _| Ok(serde_json::to_value(PRESETS).unwrap_or_default())),
         cmd!(noundo "file.open", "Open…", ["File"], Some("Cmd+O"),
-            "{path} — .designcraft or .idml; the fonts in a `Document Fonts` folder beside it load first → {index, documentFonts: faces loaded, warnings: font files skipped (and, for .idml, package parts missing)}",
+            "{path} — .designcraft or .idml; the fonts in a `Document Fonts` folder beside it load first → {index, documentFonts: faces loaded, warnings: font files skipped, Based on Parent links cleared (and, for .idml, package parts missing)}",
             always, file_open),
-        cmd!(noundo "file.openBytes", "Open Bytes", [], None, "{name, base64} — DesignCraft JSON or an IDML package", always, file_open_bytes),
+        cmd!(noundo "file.openBytes", "Open Bytes", [], None, "{name, base64} — DesignCraft JSON or an IDML package → {index, warnings}", always, file_open_bytes),
         cmd!(noundo "file.save", "Save", ["File"], Some("Cmd+S"), "{path?}", has_doc, file_save),
         cmd!(noundo "file.saveAs", "Save As…", ["File"], Some("Cmd+Shift+S"), "{path}", has_doc, file_save),
         cmd!(noundo "file.saveACopy", "Save a Copy…", ["File"], None, "{path} — writes the document without changing which file it is or its unsaved state", has_doc, |s, p| {
@@ -114,7 +114,15 @@ pub fn to_bytes(d: &Document) -> Vec<u8> {
 }
 
 pub fn from_bytes(b: &[u8]) -> Result<Document> {
-    designcraft_format::load(b).map_err(|e| EngineError::Other(e.to_string()))
+    load_bytes(b).map(|(d, _)| d)
+}
+
+/// Read `.designcraft` bytes and repair what a hand-edited file can get wrong without failing the
+/// open, with a warning for each repair.
+fn load_bytes(b: &[u8]) -> Result<(Document, Vec<String>)> {
+    let mut d = designcraft_format::load(b).map_err(|e| EngineError::Other(e.to_string()))?;
+    let warnings = d.fix_parent_bases();
+    Ok((d, warnings))
 }
 
 fn file_new(s: &mut Session, p: &Value) -> Result<Value> {
@@ -165,10 +173,11 @@ fn file_open(s: &mut Session, p: &Value) -> Result<Value> {
             return super::interchange::open_idml(s, p);
         }
         let bytes = std::fs::read(path).map_err(|e| EngineError::Other(format!("{path}: {e}")))?;
-        let mut d = from_bytes(&bytes)?;
+        let (mut d, mut warnings) = load_bytes(&bytes)?;
         super::interchange::resolve_packaged_links(&mut d, std::path::Path::new(path).parent());
         super::datamerge::resolve_sources_on_open(&mut d, Some(std::path::Path::new(path)));
-        let (fonts, faces, warnings) = load_document_fonts(&mut d, path);
+        let (fonts, faces, font_warnings) = load_document_fonts(&mut d, path);
+        warnings.extend(font_warnings);
         let mut st = DocState::new(d, Some(path.to_string()));
         st.fonts = fonts;
         let i = s.add_document(st);
@@ -224,13 +233,13 @@ fn file_open_bytes(s: &mut Session, p: &Value) -> Result<Value> {
     if designcraft_idml::is_idml(&b) {
         return super::interchange::open_idml(s, p);
     }
-    let mut d = from_bytes(&b)?;
+    let (mut d, warnings) = load_bytes(&b)?;
     super::datamerge::resolve_sources_on_open(&mut d, None);
     if let Some(n) = str_param(p, "name") {
         d.title = n.to_string();
     }
     let i = s.add_document(DocState::new(d, None));
-    Ok(json!({"index": i}))
+    Ok(json!({"index": i, "warnings": warnings}))
 }
 
 fn file_save(s: &mut Session, p: &Value) -> Result<Value> {
diff --git a/crates/engine/src/cmd/inspect.rs b/crates/engine/src/cmd/inspect.rs
index f3c27336..4b960ad2 100644
--- a/crates/engine/src/cmd/inspect.rs
+++ b/crates/engine/src/cmd/inspect.rs
@@ -92,7 +92,10 @@ fn inspect(s: &mut Session, _p: &Value) -> Result<Value> {
         "title": st.title(), "path": st.path, "dirty": st.is_dirty(), "pageCount": d.page_count(),
         "settings": {"pageWidth": d.settings.page_width, "pageHeight": d.settings.page_height, "facingPages": d.settings.facing_pages, "intent": d.settings.intent},
         "spreads": spreads,
-        "parents": d.parents.iter().map(|p| json!({"id": p.id.0, "label": p.parent.as_ref().map(|i| i.label()), "items": p.items.len()})).collect::<Vec<_>>(),
+        "parents": d.parents.iter().map(|p| {
+            let based_on = p.parent.as_ref().and_then(|i| i.based_on).and_then(|b| d.parents.iter().find(|x| x.id == b)).and_then(|x| x.parent.as_ref()).map(|i| i.label());
+            json!({"id": p.id.0, "label": p.parent.as_ref().map(|i| i.label()), "basedOn": based_on, "items": p.items.len()})
+        }).collect::<Vec<_>>(),
         "layers": d.layers,
         "stories": stories,
         "paragraphStyles": d.styles.paragraph.iter().map(|p| &p.name).collect::<Vec<_>>(),
diff --git a/crates/engine/src/cmd/layout.rs b/crates/engine/src/cmd/layout.rs
index bd532079..7ff43c5d 100644
--- a/crates/engine/src/cmd/layout.rs
+++ b/crates/engine/src/cmd/layout.rs
@@ -179,6 +179,15 @@ pub fn specs() -> Vec<CommandSpec> {
                 Ok(json!({"id": id.0, "prefix": prefix}))
             })
         }),
+        cmd!(
+            "layout.parents.options",
+            "Parent Options…",
+            [],
+            None,
+            "{parent: \"B\" (prefix or label), basedOn: \"A\" | null (= [None])} — the parent shows its base's items under its own, and so do the pages that use it → {parent, basedOn}",
+            has_doc,
+            parent_options
+        ),
         cmd!(noundo "layout.parents.edit", "Edit Parents", [], None, "{on: bool} — show parent spreads on the canvas", has_doc, |s, p| {
             let st = s.doc_mut()?;
             st.editing_parents = p.get("on").and_then(Value::as_bool).unwrap_or(!st.editing_parents);
@@ -619,6 +628,41 @@ fn parent_ref(d: &designcraft_doc::Document, v: Option<&Value>) -> Option<Option
     }
 }
 
+/// Layout › Pages › Parent Options: Based on Parent. A base that would make a cycle is refused.
+fn parent_options(s: &mut crate::Session, p: &Value) -> Result<Value> {
+    const CMD: &str = "layout.parents.options";
+    let d = &s.doc()?.doc;
+    let find = |name: &str| d.parents.iter().position(|x| x.parent.as_ref().is_some_and(|i| i.prefix == name || i.label() == name));
+    let name = str_param(p, "parent").ok_or_else(|| bad(CMD, "missing `parent`"))?;
+    let pi = find(name).ok_or_else(|| bad(CMD, format!("no parent `{name}`")))?;
+    let base = match p.get("basedOn") {
+        None => return Err(bad(CMD, "missing `basedOn` (a parent, or null for [None])")),
+        Some(Value::Null) => None,
+        Some(Value::String(b)) if b == "[None]" => None,
+        Some(Value::String(b)) => {
+            let bi = find(b).ok_or_else(|| bad(CMD, format!("no parent `{b}`")))?;
+            Some(d.parents.get(bi).map(|x| x.id).ok_or_else(|| bad(CMD, format!("no parent `{b}`")))?)
+        }
+        Some(v) => return Err(bad(CMD, format!("`basedOn` must be a parent name or null, not {v}"))),
+    };
+    let label = |d: &designcraft_doc::Document, i: usize| d.parents.get(i).and_then(|x| x.parent.as_ref()).map(|i| i.label());
+    if let Some(b) = base
+        && d.parent_base_cycles(pi, b)
+    {
+        let b = str_param(p, "basedOn").unwrap_or_default();
+        return Err(bad(CMD, format!("{name} cannot be based on {b}: that would make a cycle")));
+    }
+    let out = json!({"parent": label(d, pi), "basedOn": base.and_then(|b| d.parent_index(b)).and_then(|i| label(d, i))});
+    if d.parents.get(pi).and_then(|x| x.parent.as_ref()).and_then(|i| i.based_on) == base {
+        return Ok(out);
+    }
+    s.edit(|d, _| {
+        let info = d.parents.get_mut(pi).map(std::sync::Arc::make_mut).and_then(|x| x.parent.as_mut()).ok_or_else(|| bad(CMD, "no such parent"))?;
+        info.based_on = base;
+        Ok(out)
+    })
+}
+
 #[allow(dead_code)]
 fn _r(_: Result<()>) {}
 
@@ -921,3 +965,77 @@ mod adjust_tests {
         assert_eq!(b, b2);
     }
 }
+
+#[cfg(test)]
+mod parent_base_tests {
+    use serde_json::{Value, json};
+
+    fn rect(s: &mut crate::Session, spread: Value, r: [f64; 4], swatch: &str) -> u64 {
+        let id = s.execute("frame.create", &json!({"spread": spread, "rect": r, "content": "unassigned"})).unwrap()["id"].as_u64().unwrap();
+        s.execute("object.fill", &json!({"ids": [id], "swatch": swatch})).unwrap();
+        id
+    }
+
+    fn page(s: &crate::Session, abs: usize) -> designcraft_render::Rendered {
+        let mut rr = designcraft_render::Renderer::new();
+        rr.threads = 0;
+        rr.render_page(&s.doc().unwrap().doc, &s.cache, abs, 1.0, false, &Default::default()).unwrap()
+    }
+
+    /// Parent A (black), parent B based on A (cyan, half over A's square), and a page item (paper)
+    /// over B's: the page draws A, then B, then its own items.
+    #[test]
+    fn based_on_parent_draws_base_items_under_parent_items() {
+        let mut s = crate::Session::new();
+        s.execute("file.new", &json!({"width": 400, "height": 400, "pages": 2, "facingPages": false, "margins": 0})).unwrap();
+        s.execute("layout.parents.new", &json!({"prefix": "B", "name": "Opening"})).unwrap();
+        rect(&mut s, json!({"kind": "parent", "index": 0}), [0.0, 0.0, 200.0, 200.0], "[Black]");
+        rect(&mut s, json!({"kind": "parent", "index": 1}), [100.0, 0.0, 300.0, 200.0], "C=100 M=0 Y=0 K=0");
+        rect(&mut s, json!(1), [150.0, 0.0, 190.0, 40.0], "[Paper]");
+        s.execute("layout.pages.applyParent", &json!({"pages": [1], "parent": "B"})).unwrap();
+        let black = |p: [u8; 4]| p[0] < 80 && p[1] < 80 && p[2] < 80;
+        let cyan = |p: [u8; 4]| p[0] < 80 && p[1] > 120 && p[2] > 180;
+        let paper = |p: [u8; 4]| p[0] > 240 && p[1] > 240 && p[2] > 240;
+        assert!(paper(page(&s, 1).pixel(50, 100)), "B alone does not show A's items");
+
+        let r = s.execute("layout.parents.options", &json!({"parent": "B", "basedOn": "A"})).unwrap();
+        assert_eq!(r, json!({"parent": "B-Opening", "basedOn": "A-Parent"}));
+        let img = page(&s, 1);
+        assert!(black(img.pixel(50, 100)), "A's item: {:?}", img.pixel(50, 100));
+        assert!(cyan(img.pixel(150, 150)), "B's item over A's: {:?}", img.pixel(150, 150));
+        assert!(paper(img.pixel(170, 20)), "the page's item over B's: {:?}", img.pixel(170, 20));
+        assert!(black(page(&s, 0).pixel(50, 100)) && !cyan(page(&s, 0).pixel(250, 100)), "page 1 uses A only");
+        let inspect = s.execute("document.inspect", &json!({})).unwrap();
+        assert_eq!(inspect["parents"][1]["basedOn"], "A-Parent");
+        assert_eq!(inspect["parents"][0]["basedOn"], Value::Null);
+
+        // Cycles are refused.
+        assert!(s.execute("layout.parents.options", &json!({"parent": "A", "basedOn": "B"})).is_err());
+        assert!(s.execute("layout.parents.options", &json!({"parent": "B", "basedOn": "B-Opening"})).is_err());
+        assert!(s.execute("layout.parents.options", &json!({"parent": "B", "basedOn": "Z"})).is_err());
+
+        s.execute("edit.undo", &json!({})).unwrap();
+        assert!(paper(page(&s, 1).pixel(50, 100)), "undo clears Based on Parent");
+        s.execute("edit.redo", &json!({})).unwrap();
+        s.execute("layout.parents.options", &json!({"parent": "B", "basedOn": null})).unwrap();
+        assert_eq!(s.execute("document.inspect", &json!({})).unwrap()["parents"][1]["basedOn"], Value::Null);
+    }
+
+    /// A file whose parents are based on each other opens, with the cycle broken and reported.
+    #[test]
+    fn opening_a_parent_cycle_breaks_it_with_a_warning() {
+        let mut s = crate::Session::new();
+        s.execute("file.new", &json!({"pages": 1})).unwrap();
+        s.execute("layout.parents.new", &json!({"prefix": "B"})).unwrap();
+        let mut d = s.doc().unwrap().doc.as_ref().clone();
+        let (a, b) = (d.parents[0].id, d.parents[1].id);
+        std::sync::Arc::make_mut(&mut d.parents[0]).parent.as_mut().unwrap().based_on = Some(b);
+        std::sync::Arc::make_mut(&mut d.parents[1]).parent.as_mut().unwrap().based_on = Some(a);
+        let b64 = crate::cmd::base64_encode(&crate::cmd::to_bytes(&d));
+        let r = s.execute("file.openBytes", &json!({"name": "cycle", "base64": b64})).unwrap();
+        assert!(r["warnings"].to_string().contains("cycle"), "{r}");
+        let d = &s.doc().unwrap().doc;
+        assert_eq!(d.parents[0].parent.as_ref().unwrap().based_on, None);
+        assert_eq!(d.parents[1].parent.as_ref().unwrap().based_on, Some(a));
+    }
+}
diff --git a/crates/engine/src/cmd/overrides.rs b/crates/engine/src/cmd/overrides.rs
index 39d45394..ac96b8e4 100644
--- a/crates/engine/src/cmd/overrides.rs
+++ b/crates/engine/src/cmd/overrides.rs
@@ -54,35 +54,49 @@ fn page_param(s: &Session, p: &Value, cmd: &str) -> Result<usize> {
     Ok(page)
 }
 
-/// The parent items that show on a document page, with the offset from parent spread to
-/// document spread.
-fn parent_items(d: &Document, page: usize) -> Option<(Vec<ItemId>, Vec2)> {
+/// The parent items that show on a document page (its parent's and that parent's bases', back to
+/// front), each with the offset from its parent spread to the document spread.
+fn parent_items(d: &Document, page: usize) -> Option<Vec<(ItemId, Vec2)>> {
     let (si, pi) = d.page_loc(page)?;
-    let pg = &d.spreads[si].pages[pi];
-    let (ppi, ppage) = d.parent_page_for(page)?;
-    let parent = d.parents.get(ppi)?;
-    let dx = pg.x - parent.pages.get(ppage)?.x;
-    let ids =
-        parent.items.iter().filter(|it| parent.pages.len() <= 1 || parent.page_at_x(it.bounds().center().x) == Some(ppage)).map(|it| it.id).collect();
-    Some((ids, Vec2::new(dx, 0.0)))
+    let pg = d.spreads.get(si)?.pages.get(pi)?;
+    let shown = d.shown_parent_pages(SpreadRef::Doc(si), pi);
+    if shown.is_empty() {
+        return None;
+    }
+    let mut out = Vec::new();
+    for (ppi, ppage) in shown {
+        let Some(parent) = d.parents.get(ppi) else { continue };
+        let Some(ppg) = parent.pages.get(ppage) else { continue };
+        let off = Vec2::new(pg.x - ppg.x, 0.0);
+        out.extend(
+            parent
+                .items
+                .iter()
+                .filter(|it| parent.pages.len() <= 1 || parent.page_at_x(it.bounds().center().x) == Some(ppage))
+                .map(|it| (it.id, off)),
+        );
+    }
+    Some(out)
 }
 
 fn override_items(s: &mut Session, p: &Value) -> Result<Value> {
     let page = page_param(s, p, "layout.overrideParentItems")?;
     let wanted: Option<Vec<ItemId>> = super::ids_param(p, "ids");
     s.edit(|d, sel| {
-        let (all, off) = parent_items(d, page).ok_or_else(|| bad("layout.overrideParentItems", "the page has no parent"))?;
+        let all = parent_items(d, page).ok_or_else(|| bad("layout.overrideParentItems", "the page has no parent"))?;
         let (si, pi) = d.page_loc(page).ok_or_else(|| bad("layout.overrideParentItems", "no such page"))?;
         let already = d.spreads[si].pages[pi].overridden.clone();
-        let ids: Vec<ItemId> = all.into_iter().filter(|i| wanted.as_ref().is_none_or(|w| w.contains(i)) && !already.contains(i)).collect();
-        if ids.is_empty() {
+        let picked: Vec<(ItemId, Vec2)> =
+            all.into_iter().filter(|(i, _)| wanted.as_ref().is_none_or(|w| w.contains(i)) && !already.contains(i)).collect();
+        if picked.is_empty() {
             return Ok(json!({"ids": []}));
         }
+        let ids: Vec<ItemId> = picked.iter().map(|(i, _)| *i).collect();
         let src = d.clone();
-        // Copies on the document spread (stories and images come along).
+        // Copies on the document spread (stories and images come along), base parents' first.
         let mut new = Vec::new();
-        for id in &ids {
-            let copy = super::object::duplicate_from(d, &src, &[*id], SpreadRef::Doc(si), off)?;
+        for (id, off) in &picked {
+            let copy = super::object::duplicate_from(d, &src, &[*id], SpreadRef::Doc(si), *off)?;
             if let Some(nid) = copy.first() {
                 if let Some(it) = d.item_mut(*nid) {
                     it.overrides = Some(*id);
@@ -173,4 +187,33 @@ mod tests {
         assert!(d.spreads[si].pages[pi].overridden.is_empty());
         d.check().unwrap();
     }
+
+    /// On a page whose parent B is based on A, A's items can be overridden too.
+    #[test]
+    fn override_items_from_a_base_parent() {
+        let mut s = Session::new();
+        s.execute("file.new", &json!({"pages": 2, "facingPages": false})).unwrap();
+        s.execute("layout.parents.new", &json!({"prefix": "B"})).unwrap();
+        let on = |s: &mut Session, index: usize, rect: [f64; 4]| {
+            let r = s.execute("frame.create", &json!({"spread": {"kind": "parent", "index": index}, "rect": rect, "content": "unassigned"})).unwrap();
+            ItemId(r["id"].as_u64().unwrap())
+        };
+        let a_item = on(&mut s, 0, [72.0, 72.0, 200.0, 200.0]);
+        let b_item = on(&mut s, 1, [300.0, 72.0, 400.0, 200.0]);
+        s.execute("layout.parents.options", &json!({"parent": "B", "basedOn": "A"})).unwrap();
+        s.execute("layout.pages.applyParent", &json!({"pages": [1], "parent": "B"})).unwrap();
+        let r = s.execute("layout.overrideParentItems", &json!({"page": 1, "ids": [a_item.0]})).unwrap();
+        let copy = ItemId(r["ids"][0].as_u64().unwrap());
+        let d = s.doc().unwrap().doc.clone();
+        assert_eq!(d.item(copy).unwrap().overrides, Some(a_item));
+        assert_eq!(d.page_of_item(copy), Some(1));
+        let b = d.item(copy).unwrap().bounds();
+        assert!((b.x0 - 72.0).abs() < 1e-9 && (b.y0 - 72.0).abs() < 1e-9, "{b:?}");
+        // Overriding the rest picks up B's item only.
+        let r = s.execute("layout.overrideParentItems", &json!({"page": 1})).unwrap();
+        let rest: Vec<ItemId> = r["ids"].as_array().unwrap().iter().map(|v| ItemId(v.as_u64().unwrap())).collect();
+        let d = s.doc().unwrap().doc.clone();
+        assert_eq!(rest.iter().map(|i| d.item(*i).unwrap().overrides).collect::<Vec<_>>(), vec![Some(b_item)]);
+        d.check().unwrap();
+    }
 }
diff --git a/crates/idml/src/import.rs b/crates/idml/src/import.rs
index 46c3253b..949abf3f 100644
--- a/crates/idml/src/import.rs
+++ b/crates/idml/src/import.rs
@@ -107,11 +107,12 @@ pub fn import_idml_report(bytes: &[u8], read_link: &dyn Fn(&str) -> Option<Vec<u
     }
     let mut im = Importer::new(read_link);
     im.run(&root, &top)?;
-    let document = im.finish(&root).map_err(|e| match e {
+    let mut document = im.finish(&root).map_err(|e| match e {
         // Without its spread parts there is nothing to open: say which parts were missing.
         IdmlError::Invalid(msg) if !warnings.is_empty() => IdmlError::Invalid(format!("{msg} ({})", warnings.join("; "))),
         e => e,
     })?;
+    warnings.extend(document.fix_parent_bases());
     document.check().map_err(|e| IdmlError::Invalid(e.to_string()))?;
     Ok(Imported { document, warnings })
 }
diff --git a/crates/idml/src/tests.rs b/crates/idml/src/tests.rs
index 23ec99bd..667312d4 100644
--- a/crates/idml/src/tests.rs
+++ b/crates/idml/src/tests.rs
@@ -1454,3 +1454,27 @@ fn list_numbering_format_expression_and_bullet_import_and_round_trip() {
     check(&d);
     check(&import_idml(&export_idml(&d)).unwrap());
 }
+
+/// Based on Parent travels as the parent pages' `AppliedMaster`; a cycle in a file is broken on
+/// import with a warning.
+#[test]
+fn parent_based_on_round_trips_and_cycles_are_broken() {
+    let mut d = Document::new(&NewDocument { pages: 2, ..Default::default() });
+    let a = d.parents[0].id;
+    let b = d.add_parent("B", "Opening", 2, 12.0, designcraft_doc::Margins::uniform(36.0));
+    d.add_parent("C", "Closing", 2, 12.0, designcraft_doc::Margins::uniform(36.0));
+    let set = |d: &mut Document, pi: usize, on| std::sync::Arc::make_mut(&mut d.parents[pi]).parent.as_mut().unwrap().based_on = on;
+    set(&mut d, 1, Some(a));
+    set(&mut d, 2, Some(b));
+    let back = import_idml(&export_idml(&d)).unwrap();
+    let base_of = |d: &Document, pi: usize| {
+        let b = d.parents[pi].parent.as_ref().unwrap().based_on?;
+        d.parents.iter().find(|p| p.id == b).and_then(|p| p.parent.as_ref()).map(|i| i.prefix.clone())
+    };
+    assert_eq!((base_of(&back, 0), base_of(&back, 1), base_of(&back, 2)), (None, Some("A".into()), Some("B".into())));
+
+    set(&mut d, 0, Some(b));
+    let r = import_idml_report(&export_idml(&d), &|_| None).unwrap();
+    assert!(r.warnings.iter().any(|w| w.contains("A-Parent") && w.contains("cycle")), "{:?}", r.warnings);
+    assert_eq!((base_of(&r.document, 0), base_of(&r.document, 1)), (None, Some("A".into())));
+}
diff --git a/crates/pdf/src/export.rs b/crates/pdf/src/export.rs
index dcf8abb8..1da8c5de 100644
--- a/crates/pdf/src/export.rs
+++ b/crates/pdf/src/export.rs
@@ -6,7 +6,7 @@ use std::sync::Arc;
 use designcraft_color::swatch::{ColorType, SwatchValue};
 use designcraft_color::{BlendMode as DcBlend, Color, GradientKind};
 use designcraft_compose::Cache;
-use designcraft_doc::{AssetId, Content, Document, Item, PageSide, Spread, StrokeAlign, StrokeType};
+use designcraft_doc::{AssetId, Content, Document, Item, PageSide, Spread, SpreadRef, StrokeAlign, StrokeType};
 use designcraft_geom::kurbo::{PathEl, Shape as _};
 use designcraft_geom::{Affine, BezPath, Rect, Vec2, corners};
 use krilla::color::{cmyk, luma, rgb};
@@ -627,18 +627,21 @@ impl Exporter<'_> {
                 if !page.show_parent_items {
                     continue;
                 }
-                let Some((ppi, ppage)) = doc.parent_page_for(first + pi) else { continue };
-                let parent = &doc.parents[ppi];
-                let dx = page.x - parent.pages[ppage].x;
-                for it in &parent.items {
-                    if it.layer != layer.id || page.overridden.contains(&it.id) {
-                        continue;
+                // The parent's bases first, then the parent.
+                for (ppi, ppage) in doc.shown_parent_pages(SpreadRef::Doc(si), pi) {
+                    let Some(parent) = doc.parents.get(ppi) else { continue };
+                    let Some(ppg) = parent.pages.get(ppage) else { continue };
+                    let dx = page.x - ppg.x;
+                    for it in &parent.items {
+                        if it.layer != layer.id || page.overridden.contains(&it.id) {
+                            continue;
+                        }
+                        // Parent items belong to the parent page they sit on.
+                        if parent.page_at_x(it.bounds().center().x) != Some(ppage) && parent.pages.len() > 1 {
+                            continue;
+                        }
+                        self.top_item(s, it, Affine::translate((dx, 0.0)), Some(first + pi), true);
                     }
-                    // Parent items belong to the parent page they sit on.
-                    if parent.page_at_x(it.bounds().center().x) != Some(ppage) && parent.pages.len() > 1 {
-                        continue;
-                    }
-                    self.top_item(s, it, Affine::translate((dx, 0.0)), Some(first + pi), true);
                 }
             }
             for it in &sp.items {
diff --git a/crates/render/src/lib.rs b/crates/render/src/lib.rs
index 2cc5c548..7b42dcbb 100644
--- a/crates/render/src/lib.rs
+++ b/crates/render/src/lib.rs
@@ -394,21 +394,24 @@ impl Renderer {
                 }
             }
         }
-        // Layers back to front; within each layer parent items first (document spreads only).
+        // Layers back to front; within each layer parent items first.
         for layer in doc.layers.iter().rev() {
             if !layer.visible || f.opts.printing_only && !layer.printable {
                 continue;
             }
-            if let SpreadRef::Doc(si) = sr {
-                let first = doc.first_page_of_spread(si);
-                for (pi, page) in sp.pages.iter().enumerate() {
-                    if !page.show_parent_items {
-                        continue;
-                    }
-                    let Some((ppi, ppage)) = doc.parent_page_for(first + pi) else { continue };
-                    let parent = &doc.parents[ppi];
-                    let dx = page.x - parent.pages[ppage].x;
-                    let pr = parent.pages[ppage].bounds();
+            // Document pages show their parent and its bases; a parent spread shows its bases.
+            let first = match sr {
+                SpreadRef::Doc(si) => Some(doc.first_page_of_spread(si)),
+                SpreadRef::Parent(_) => None,
+            };
+            for (pi, page) in sp.pages.iter().enumerate() {
+                if !page.show_parent_items {
+                    continue;
+                }
+                for (ppi, ppage) in doc.shown_parent_pages(sr, pi) {
+                    let Some(parent) = doc.parents.get(ppi) else { continue };
+                    let Some(ppg) = parent.pages.get(ppage) else { continue };
+                    let dx = page.x - ppg.x;
                     for it in &parent.items {
                         if it.layer != layer.id || page.overridden.contains(&it.id) {
                             continue;
@@ -417,8 +420,7 @@ impl Renderer {
                         if parent.page_at_x(it.bounds().center().x) != Some(ppage) && parent.pages.len() > 1 {
                             continue;
                         }
-                        let _ = pr;
-                        self.draw_item(ctx, f, it, Affine::translate((dx, 0.0)), Some(first + pi));
+                        self.draw_item(ctx, f, it, Affine::translate((dx, 0.0)), first.map(|a| a + pi));
                     }
                 }
             }
diff --git a/crates/tools/src/lib.rs b/crates/tools/src/lib.rs
index 247494f8..e58be750 100644
--- a/crates/tools/src/lib.rs
+++ b/crates/tools/src/lib.rs
@@ -223,16 +223,18 @@ impl ToolContext<'_> {
         let spread = self.doc.spreads.get(si)?;
         let pi = spread.page_at_x(sp.x)?;
         let page = self.doc.first_page_of_spread(si) + pi;
-        let (ppi, ppg) = self.doc.parent_page_for(page)?;
-        let parent = &self.doc.parents[ppi];
-        let pg = &spread.pages[pi];
-        let at = sp - designcraft_geom::Vec2::new(pg.x - parent.pages[ppg].x, 0.0);
-        parent
-            .items
-            .iter()
-            .rev()
-            .find(|it| !it.locked && !pg.overridden.contains(&it.id) && designcraft_doc::edit_hit(it, at, self.tol(4.0)))
-            .map(|it| (page, it.id))
+        let pg = spread.pages.get(pi)?;
+        // Front to back: the page's parent, then the parents it is based on.
+        self.doc.shown_parent_pages(SpreadRef::Doc(si), pi).into_iter().rev().find_map(|(ppi, ppg)| {
+            let parent = self.doc.parents.get(ppi)?;
+            let at = sp - designcraft_geom::Vec2::new(pg.x - parent.pages.get(ppg)?.x, 0.0);
+            parent
+                .items
+                .iter()
+                .rev()
+                .find(|it| !it.locked && !pg.overridden.contains(&it.id) && designcraft_doc::edit_hit(it, at, self.tol(4.0)))
+                .map(|it| (page, it.id))
+        })
     }
 
     fn hit_parent(&self, sr: SpreadRef, sp: Point) -> Option<(SpreadRef, ItemId)> {
diff --git a/crates/ui-egui/src/canvas.rs b/crates/ui-egui/src/canvas.rs
index 4c7313e6..dbfe4d2c 100644
--- a/crates/ui-egui/src/canvas.rs
+++ b/crates/ui-egui/src/canvas.rs
@@ -700,13 +700,12 @@ fn draw_frames(app: &DesignApp, painter: &egui::Painter, xf: &Xf, doc: &Document
     for slot in &layout.slots {
         let Some(sp) = doc.spread(slot.spread) else { continue };
         let a = slot.xf;
-        // Parent items on document pages: dotted edges.
-        if let SpreadRef::Doc(si) = slot.spread {
-            let first = doc.first_page_of_spread(si);
-            for (pi, page) in sp.pages.iter().enumerate() {
-                let Some((ppi, ppg)) = doc.parent_page_for(first + pi) else { continue };
-                let parent = &doc.parents[ppi];
-                let dx = page.x - parent.pages[ppg].x;
+        // Parent items on document pages, and base parents' items on a parent spread: dotted edges.
+        for (pi, page) in sp.pages.iter().enumerate() {
+            for (ppi, ppg) in doc.shown_parent_pages(slot.spread, pi) {
+                let Some(parent) = doc.parents.get(ppi) else { continue };
+                let Some(ppage) = parent.pages.get(ppg) else { continue };
+                let dx = page.x - ppage.x;
                 for it in &parent.items {
                     if (parent.pages.len() > 1 && parent.page_at_x(it.bounds().center().x) != Some(ppg)) || page.overridden.contains(&it.id) {
                         continue;
diff --git a/docs/target-app-parity.md b/docs/target-app-parity.md
index 78e968dc..e6eed73e 100644
--- a/docs/target-app-parity.md
+++ b/docs/target-app-parity.md
@@ -1,6 +1,6 @@
 # DesignCraft parity with Adobe InDesign
 
-> **Last reviewed:** 2026-10-10 · **Last updated:** 2026-10-12 · **Change:** minor (cancelable macOS Dock Quit) · **Target:** Adobe InDesign 2026 (21.6.0.57, macOS)
+> **Last reviewed:** 2026-10-10 · **Last updated:** 2026-10-13 · **Change:** minor (Based on Parent) · **Target:** Adobe InDesign 2026 (21.6.0.57, macOS)
 
 The authoritative assessment of how close DesignCraft is to Adobe InDesign. [ROADMAP.md](../ROADMAP.md)
 summarizes it; [gaps.md](gaps.md) lists every known shortfall one at a time; the feature-by-feature
@@ -426,6 +426,7 @@ It is evidence of breadth: each item exists. It is not a claim of InDesign-level
 - Stroke panel: cap, join, miter limit, alignment, type, Start/End arrowheads (12 kinds, drawn on screen and in PDF; the path is shortened under pointed heads) and gap colour under dashes and dots.
 - Preferences (⌘K: General, Type, Units & Increments, Grids, Guides & Pasteboard, Display Performance) backed by `prefs.set` (application) and `document.preferences` (units, increments, grids — undoable, saved with the document; right-click a ruler to pick its units, the horizontal and vertical rulers each have their own); scaling applies to content and scales stroke weights (Include Stroke Weight), and X/Y/W/H measure the stroke's outer edge (Dimensions Include Stroke Weight). Quick Apply (⌘Return) finds paragraph, character and object styles as well as commands.
 - Parent item overrides: Cmd+Shift-click a parent item on a page (or Override All Parent Page Items, ⌥⇧⌘L) makes an editable local copy that hides the parent's; Remove All Local Overrides and Detach All Objects from Parent in the Pages panel menu.
+- Based on Parent (`layout.parents.options {parent, basedOn}`): a parent shows its base parent's items under its own, on its pages and on the parent itself; chains work, cycles are refused, and items from any parent in the chain can be overridden. IDML carries it as the parent pages' `AppliedMaster`; a cycle or missing base in a file is cleared with a warning on open. The Pages panel has no Parent Options dialog yet.
 - Place PDF: placed PDF pages are sized by their crop box, drawn on screen through hayro (with mip levels) and embedded in exported PDFs as vector form XObjects (krilla), `<PDF>` in IDML.
 - Menus expose the engine's features (TOC, numbering & sections, text variables, hyperlinks, cross-references, footnotes, step and repeat, spelling, fitting/content, effects, Data Merge, Preflight, EPUB); any menu command with parameters gets a dialog generated from its parameter documentation.
 - Table of contents (generate/update, dot leaders) and text variables (running headers, last page number, chapter number, file name, dates, custom) resolved per page.

From 182db943c20ea7205af7578260ea424289b2cdc4 Mon Sep 17 00:00:00 2001
From: aiongg <aiongtaigi@gmail.com>
Date: Tue, 13 Oct 2026 00:51:41 +0000
Subject: [PATCH 2/2] fix(parents): bound every based-on walk; base items
 follow the parent showing them (#652)

Cycle checks walk based_on with a seen-set over all parents, so a cycle
longer than the drawing depth cap is still found. Snapping lists parent
items through shown_parent_pages instead of recursing, and offers base
items on a parent spread. A base parent's text on a parent spread is
composed for that spread, so page-number markers show its prefix.
Cmd+Shift-click hits what is drawn: it honours Show Parent Items, hidden
and locked layers, the facing-page filter and layer order. IDML import
warns when a parent spread's pages name different bases or their own
spread.
---
 crates/compose/src/cache.rs        |  41 +++++-
 crates/compose/src/lib.rs          |   2 +-
 crates/doc/src/build.rs            |  34 ++++-
 crates/engine/src/cmd/layout.rs    |  28 +++++
 crates/engine/src/cmd/overrides.rs |  34 +++++
 crates/idml/src/import.rs          |  17 ++-
 crates/pdf/src/tests.rs            |  22 ++++
 crates/render/src/fx.rs            |   3 +-
 crates/render/src/lib.rs           |  22 ++--
 crates/render/src/text.rs          |   4 +-
 crates/tools/src/lib.rs            |  37 ++++--
 crates/tools/src/snap.rs           | 195 ++++++-----------------------
 crates/tools/src/tests.rs          |  23 ++++
 docs/gaps.md                       |   7 +-
 14 files changed, 282 insertions(+), 187 deletions(-)

diff --git a/crates/compose/src/cache.rs b/crates/compose/src/cache.rs
index 8aabbf0f..7388a9ae 100644
--- a/crates/compose/src/cache.rs
+++ b/crates/compose/src/cache.rs
@@ -13,8 +13,28 @@ use designcraft_doc::{Document, Item, Story, StoryId, Styles, WrapMode};
 use crate::vars::RunningIndex;
 use crate::{ComposeOptions, ComposedStory};
 
-/// A story, composed for one absolute page (parent-page items) or for its own frames (`None`).
-type Key = (StoryId, Option<usize>);
+/// Where a story's frames are shown, which decides what its page-number markers and variables
+/// read.
+#[derive(Clone, Copy, Debug, Default, PartialEq, Eq, Hash)]
+pub enum ShownOn {
+    /// In its own frames.
+    #[default]
+    Own,
+    /// As a parent item on this absolute document page.
+    Page(usize),
+    /// As a base parent's item on this parent spread (index into `parents`): markers show that
+    /// parent's prefix.
+    Parent(usize),
+}
+
+impl From<Option<usize>> for ShownOn {
+    fn from(page: Option<usize>) -> Self {
+        page.map_or(ShownOn::Own, ShownOn::Page)
+    }
+}
+
+/// A story, composed for where it is shown.
+type Key = (StoryId, ShownOn);
 
 struct Entry {
     sig: Vec<usize>,
@@ -61,12 +81,21 @@ impl Cache {
     /// `None` for a story's own frames. Pages are identified by index, not name: names repeat when
     /// sections restart their numbering.
     pub fn get(&self, doc: &Document, sid: StoryId, page: Option<usize>) -> Arc<ComposedStory> {
+        self.get_on(doc, sid, page.into())
+    }
+
+    /// [`Cache::get`] for any [`ShownOn`].
+    pub fn get_on(&self, doc: &Document, sid: StoryId, on: ShownOn) -> Arc<ComposedStory> {
         let Some(story) = doc.stories.get(&sid) else { return Arc::new(ComposedStory { story: sid, ..Default::default() }) };
         let (mut sig, keep_items) = signature(doc, story);
-        let key = (sid, page);
+        let key = (sid, on);
         // The key holds the page's index, which a renumbering doesn't change: its name (section
         // start number, style, prefix) is part of the signature.
-        let page_name = page.map(|p| doc.page_name(p));
+        let (page_name, page) = match on {
+            ShownOn::Own => (None, None),
+            ShownOn::Page(p) => (Some(doc.page_name(p)), Some(p)),
+            ShownOn::Parent(pi) => (doc.parents.get(pi).and_then(|sp| sp.parent.as_ref()).map(|i| i.prefix.clone()), None),
+        };
         if let Some(name) = &page_name {
             use std::hash::{Hash, Hasher};
             let mut h = std::collections::hash_map::DefaultHasher::new();
@@ -153,7 +182,7 @@ impl Cache {
         }
         let replaced = g.0.insert(key, Entry { sig, _keep: (story.clone(), doc.styles.clone(), keep_items), out: out.clone(), stamp });
         drop(g);
-        if key.1.is_none()
+        if key.1 == ShownOn::Own
             && let Some(old) = replaced
         {
             self.previous.lock().unwrap_or_else(|e| e.into_inner()).insert(sid, (old.sig, old.out));
@@ -170,7 +199,7 @@ impl Cache {
         let matches = |s: &[usize]| s.len() >= sig.len() && s[..sig.len()] == sig[..];
         {
             let g = self.map.lock().unwrap_or_else(|e| e.into_inner());
-            if let Some(e) = g.0.get(&(sid, None))
+            if let Some(e) = g.0.get(&(sid, ShownOn::Own))
                 && matches(&e.sig)
             {
                 return Some(e.out.clone());
diff --git a/crates/compose/src/lib.rs b/crates/compose/src/lib.rs
index 3dd7c25b..91ea88d4 100644
--- a/crates/compose/src/lib.rs
+++ b/crates/compose/src/lib.rs
@@ -36,7 +36,7 @@ use designcraft_fonts::{FontDb, ScopedFonts};
 use designcraft_geom::{Point, Rect};
 
 use crate::breaker::{Break, Spacing};
-pub use crate::cache::Cache;
+pub use crate::cache::{Cache, ShownOn};
 use crate::notes::Notes;
 pub use crate::notes::{find_note, hit_note, note_caret};
 use crate::shape::{Glyph, StyleTable, SubstCtx};
diff --git a/crates/doc/src/build.rs b/crates/doc/src/build.rs
index 4045819b..ff510b41 100644
--- a/crates/doc/src/build.rs
+++ b/crates/doc/src/build.rs
@@ -588,7 +588,20 @@ impl Document {
 
     /// Whether basing parent `pi` on `base` would make a `based_on` cycle (or names no parent).
     pub fn parent_base_cycles(&self, pi: usize, base: SpreadId) -> bool {
-        self.parent_index(base).is_none_or(|bi| bi == pi || self.parent_chain(bi).contains(&pi))
+        let Some(mut cur) = self.parent_index(base) else { return true };
+        // Not `parent_chain`: its depth cap would miss a long cycle. Every parent is visited at most once.
+        let mut seen = std::collections::HashSet::new();
+        loop {
+            if cur == pi {
+                return true;
+            }
+            if !seen.insert(cur) || seen.len() > self.parents.len() {
+                return false;
+            }
+            let next = self.parents.get(cur).and_then(|ps| ps.parent.as_ref()).and_then(|info| info.based_on).and_then(|b| self.parent_index(b));
+            let Some(n) = next else { return false };
+            cur = n;
+        }
     }
 
     /// Clear `based_on` links that name a missing parent or close a cycle (hand-edited or damaged
@@ -747,4 +760,23 @@ mod tests {
         assert_eq!(d.parents[1].parent.as_ref().unwrap().based_on, Some(a));
         assert_eq!(d.parents[2].parent.as_ref().unwrap().based_on, None);
     }
+
+    /// A cycle longer than the drawing depth cap is still found and broken.
+    #[test]
+    fn fix_parent_bases_breaks_a_long_cycle() {
+        let mut d = Document::new(&NewDocument { pages: 1, facing_pages: false, ..Default::default() });
+        for i in 1..65 {
+            d.add_parent(&format!("P{i}"), "Parent", 1, 12.0, Margins::uniform(36.0));
+        }
+        assert_eq!(d.parents.len(), 65);
+        let ids: Vec<SpreadId> = d.parents.iter().map(|p| p.id).collect();
+        for i in 0..65 {
+            base(&mut d, i, Some(ids[(i + 1) % 65]));
+        }
+        assert_eq!(d.parent_chain(0).len(), MAX_PARENT_DEPTH);
+        let w = d.fix_parent_bases();
+        assert_eq!(w.len(), 1, "{w:?}");
+        assert_eq!(d.parents[0].parent.as_ref().unwrap().based_on, None);
+        assert!((0..65).all(|i| d.parent_base_cycles(i, ids[(i + 1) % 65]) == (i == 0)), "only the cleared link would close it again");
+    }
 }
diff --git a/crates/engine/src/cmd/layout.rs b/crates/engine/src/cmd/layout.rs
index 7ff43c5d..6a851935 100644
--- a/crates/engine/src/cmd/layout.rs
+++ b/crates/engine/src/cmd/layout.rs
@@ -1005,6 +1005,13 @@ mod parent_base_tests {
         assert!(cyan(img.pixel(150, 150)), "B's item over A's: {:?}", img.pixel(150, 150));
         assert!(paper(img.pixel(170, 20)), "the page's item over B's: {:?}", img.pixel(170, 20));
         assert!(black(page(&s, 0).pixel(50, 100)) && !cyan(page(&s, 0).pixel(250, 100)), "page 1 uses A only");
+        // Parent B itself shows A's items under its own.
+        let mut rr = designcraft_render::Renderer::new();
+        rr.threads = 0;
+        let placed = [designcraft_render::Placed { spread: designcraft_doc::SpreadRef::Parent(1), xf: designcraft_geom::Affine::IDENTITY }];
+        let opts = designcraft_render::RenderOptions { background: Some([255, 255, 255, 255]), ..Default::default() };
+        let img = rr.render(&s.doc().unwrap().doc, &s.cache, &placed, 400, 400, designcraft_geom::Affine::IDENTITY, &opts);
+        assert!(black(img.pixel(50, 100)) && cyan(img.pixel(150, 150)), "{:?} {:?}", img.pixel(50, 100), img.pixel(150, 150));
         let inspect = s.execute("document.inspect", &json!({})).unwrap();
         assert_eq!(inspect["parents"][1]["basedOn"], "A-Parent");
         assert_eq!(inspect["parents"][0]["basedOn"], Value::Null);
@@ -1021,6 +1028,27 @@ mod parent_base_tests {
         assert_eq!(s.execute("document.inspect", &json!({})).unwrap()["parents"][1]["basedOn"], Value::Null);
     }
 
+    /// A's page-number marker shown on parent XYZ (based on A) reads XYZ, as markers on XYZ's own items do.
+    #[test]
+    fn base_parent_markers_read_the_showing_parent() {
+        let mut s = crate::Session::new();
+        s.execute("file.new", &json!({"pages": 1, "facingPages": false})).unwrap();
+        s.execute("layout.parents.new", &json!({"prefix": "XYZ"})).unwrap();
+        s.execute("layout.parents.options", &json!({"parent": "XYZ", "basedOn": "A"})).unwrap();
+        let marker = designcraft_doc::story::PAGE_NUMBER.to_string();
+        let r = s
+            .execute("frame.create", &json!({"spread": {"kind": "parent", "index": 0}, "rect": [72, 30, 500, 60], "content": "text", "text": marker}))
+            .unwrap();
+        let d = s.doc().unwrap().doc.clone();
+        let sid = d.item(designcraft_doc::ItemId(r["id"].as_u64().unwrap())).unwrap().text_frame().unwrap().story;
+        let glyphs = |on| -> usize {
+            let cs = s.cache.get_on(&d, sid, on);
+            cs.frames.iter().flat_map(|f| f.lines.iter()).map(|l| l.glyphs.iter().filter(|g| g.visible && g.adv > 0.0).count()).sum()
+        };
+        assert_eq!(glyphs(designcraft_compose::ShownOn::Own), 1, "A");
+        assert_eq!(glyphs(designcraft_compose::ShownOn::Parent(1)), 3, "XYZ");
+    }
+
     /// A file whose parents are based on each other opens, with the cycle broken and reported.
     #[test]
     fn opening_a_parent_cycle_breaks_it_with_a_warning() {
diff --git a/crates/engine/src/cmd/overrides.rs b/crates/engine/src/cmd/overrides.rs
index ac96b8e4..3fd8b2e8 100644
--- a/crates/engine/src/cmd/overrides.rs
+++ b/crates/engine/src/cmd/overrides.rs
@@ -216,4 +216,38 @@ mod tests {
         assert_eq!(rest.iter().map(|i| d.item(*i).unwrap().overrides).collect::<Vec<_>>(), vec![Some(b_item)]);
         d.check().unwrap();
     }
+
+    /// Facing pages: 2-page B based on 2-page A. Each document page offers only the items on its
+    /// side of A, and the copy lands where the item showed: page 1 (a single right page at x 0)
+    /// shows A's right-page items 612 pt to the left.
+    #[test]
+    fn override_base_items_on_facing_pages_keeps_their_place() {
+        let mut s = Session::new();
+        s.execute("file.new", &json!({"pages": 3, "facingPages": true})).unwrap();
+        s.execute("layout.parents.new", &json!({"prefix": "B"})).unwrap();
+        s.execute("layout.parents.options", &json!({"parent": "B", "basedOn": "A"})).unwrap();
+        s.execute("layout.pages.applyParent", &json!({"pages": [0, 1, 2], "parent": "B"})).unwrap();
+        let on_a = |s: &mut Session, rect: [f64; 4]| {
+            let r = s.execute("frame.create", &json!({"spread": {"kind": "parent", "index": 0}, "rect": rect, "content": "unassigned"})).unwrap();
+            ItemId(r["id"].as_u64().unwrap())
+        };
+        let left = on_a(&mut s, [72.0, 72.0, 200.0, 200.0]);
+        let right = on_a(&mut s, [684.0, 72.0, 812.0, 200.0]);
+        let copy_of = |s: &mut Session, page: usize, id: ItemId| -> Option<ItemId> {
+            let r = s.execute("layout.overrideParentItems", &json!({"page": page, "ids": [id.0]})).unwrap();
+            r["ids"].as_array().unwrap().first().map(|v| ItemId(v.as_u64().unwrap()))
+        };
+        assert_eq!(copy_of(&mut s, 0, left), None, "A's left-page item does not show on a right page");
+        let c = copy_of(&mut s, 0, right).unwrap();
+        let x0 = |s: &Session, id: ItemId| s.doc().unwrap().doc.item(id).unwrap().bounds().x0;
+        assert!((x0(&s, c) - 72.0).abs() < 1e-9, "{}", x0(&s, c));
+        // Page 2 is the left page of the second spread, page 3 its right page at x 612.
+        let c = copy_of(&mut s, 1, left).unwrap();
+        assert!((x0(&s, c) - 72.0).abs() < 1e-9, "{}", x0(&s, c));
+        assert_eq!(s.doc().unwrap().doc.page_of_item(c), Some(1));
+        let c = copy_of(&mut s, 2, right).unwrap();
+        assert!((x0(&s, c) - 684.0).abs() < 1e-9, "{}", x0(&s, c));
+        assert_eq!(s.doc().unwrap().doc.page_of_item(c), Some(2));
+        s.doc().unwrap().doc.check().unwrap();
+    }
 }
diff --git a/crates/idml/src/import.rs b/crates/idml/src/import.rs
index 949abf3f..5e42004f 100644
--- a/crates/idml/src/import.rs
+++ b/crates/idml/src/import.rs
@@ -107,6 +107,7 @@ pub fn import_idml_report(bytes: &[u8], read_link: &dyn Fn(&str) -> Option<Vec<u
     }
     let mut im = Importer::new(read_link);
     im.run(&root, &top)?;
+    warnings.append(&mut im.warnings);
     let mut document = im.finish(&root).map_err(|e| match e {
         // Without its spread parts there is nothing to open: say which parts were missing.
         IdmlError::Invalid(msg) if !warnings.is_empty() => IdmlError::Invalid(format!("{msg} ({})", warnings.join("; "))),
@@ -190,6 +191,8 @@ struct Importer<'r> {
     stories: BTreeMap<StoryId, Story>,
     story_ids: HashMap<String, StoryId>,
     parents: Vec<Spread>,
+    /// Things read but not kept as they were, for the import report.
+    warnings: Vec<String>,
     parent_ids: HashMap<String, SpreadId>,
     spreads: Vec<Spread>,
     page_index: HashMap<String, usize>,
@@ -277,6 +280,7 @@ impl<'r> Importer<'r> {
             stories: BTreeMap::new(),
             story_ids: HashMap::new(),
             parents: Vec::new(),
+            warnings: Vec::new(),
             parent_ids: HashMap::new(),
             spreads: Vec::new(),
             page_index: HashMap::new(),
@@ -1965,7 +1969,18 @@ impl<'r> Importer<'r> {
                 let n = e.get("Name").unwrap_or("Parent");
                 n.split_once('-').map(|(_, b)| b.to_string()).unwrap_or_else(|| n.to_string())
             });
-            let based_on = pages.first().and_then(|(_, p)| p.get("AppliedMaster")).and_then(|m| self.parent_ids.get(m)).copied().filter(|b| *b != id);
+            // A parent spread has one base: its first page's. Pages that disagree lose theirs.
+            let applied: Vec<Option<SpreadId>> =
+                pages.iter().map(|(_, p)| p.get("AppliedMaster").and_then(|m| self.parent_ids.get(m)).copied()).collect();
+            let label = format!("{prefix}-{name}");
+            if applied.windows(2).any(|w| w[0] != w[1]) {
+                self.warnings.push(format!("parent {label}: its pages are based on different parents; only the first page's is kept"));
+            }
+            let based_on = applied.first().copied().flatten();
+            if applied.contains(&Some(id)) {
+                self.warnings.push(format!("parent {label}: a page names its own parent as its base, which is ignored"));
+            }
+            let based_on = based_on.filter(|b| *b != id);
             Some(ParentInfo { prefix, name, based_on })
         } else {
             None
diff --git a/crates/pdf/src/tests.rs b/crates/pdf/src/tests.rs
index 9ac53d05..609a4b8d 100644
--- a/crates/pdf/src/tests.rs
+++ b/crates/pdf/src/tests.rs
@@ -446,3 +446,25 @@ fn column_rules_are_drawn() {
     assert!((xs[0] - 214.0).abs() < 0.01 && (xs[1] - 398.0).abs() < 0.01, "{xs:?}");
     assert!(rules(false).is_empty());
 }
+
+/// A page whose parent B is based on A carries A's items, then B's.
+#[test]
+fn based_on_parent_items_export_base_first() {
+    let mut d = Document::new(&NewDocument { pages: 1, facing_pages: false, ..NewDocument::default() });
+    d.swatches.push(Swatch::color("Base Cyan", Color::cmyk(1.0, 0.0, 0.0, 0.0)));
+    d.swatches.push(Swatch::color("Parent Magenta", Color::cmyk(0.0, 1.0, 0.0, 0.0)));
+    let a = d.parents[0].id;
+    let b = d.add_parent("B", "Opening", 1, 12.0, designcraft_doc::Margins::uniform(36.0));
+    std::sync::Arc::make_mut(&mut d.parents[1]).parent.as_mut().unwrap().based_on = Some(a);
+    d.apply_parent(&[0], Some(b)).unwrap();
+    let lid = d.default_layer();
+    for (pi, swatch, r) in [(0, "Base Cyan", Rect::new(36.0, 36.0, 136.0, 136.0)), (1, "Parent Magenta", Rect::new(200.0, 36.0, 300.0, 136.0))] {
+        let mut it = Item::new(ItemId(d.alloc()), lid, designcraft_doc::Shape::Rectangle, designcraft_geom::shapes::rectangle(r));
+        it.fill = Fill::swatch(swatch);
+        d.insert_item(SpreadRef::Parent(pi), it, None).unwrap();
+    }
+    let s = uncompressed(&d, PdfOptions::default());
+    let (cyan, magenta) = (s.find("1 0 0 0 k"), s.find("0 1 0 0 k"));
+    assert!(cyan.is_some() && magenta.is_some(), "both parents' items are on the page");
+    assert!(cyan < magenta, "the base parent's item is drawn first");
+}
diff --git a/crates/render/src/fx.rs b/crates/render/src/fx.rs
index 6b29516f..b52f7c28 100644
--- a/crates/render/src/fx.rs
+++ b/crates/render/src/fx.rs
@@ -23,6 +23,7 @@ use vello_cpu::peniko::{self, BlendMode, Compose, Mix};
 use vello_cpu::{RenderContext, kurbo};
 
 use crate::{Frame, Renderer, color_of};
+use designcraft_compose::ShownOn;
 
 /// Shadow offset (spread units) for an InDesign angle (degrees, light direction) and distance.
 pub(crate) fn offset(angle: f64, distance: f64) -> Vec2 {
@@ -66,7 +67,7 @@ fn shadow(sigma: f64, color: peniko::Color) -> Filter {
 
 impl Renderer {
     /// Draw an item with soft effects: below-effects, the (feathered) body, inner shadow.
-    pub(crate) fn draw_item_fx(&mut self, ctx: &mut RenderContext, f: &Frame, it: &Item, bp: &BezPath, xf: Affine, page: Option<usize>) {
+    pub(crate) fn draw_item_fx(&mut self, ctx: &mut RenderContext, f: &Frame, it: &Item, bp: &BezPath, xf: Affine, page: ShownOn) {
         let doc = f.doc;
         let e = &it.effects;
         let sw = if it.stroke.is_none() { 0.0 } else { it.stroke.extent() };
diff --git a/crates/render/src/lib.rs b/crates/render/src/lib.rs
index 7b42dcbb..4c9c5e4b 100644
--- a/crates/render/src/lib.rs
+++ b/crates/render/src/lib.rs
@@ -13,7 +13,7 @@ use std::collections::HashMap;
 use std::sync::Arc;
 
 use designcraft_color::BlendMode as DcBlend;
-use designcraft_compose::{Cache, ComposedStory};
+use designcraft_compose::{Cache, ComposedStory, ShownOn};
 use designcraft_doc::{Content, Document, Item, PageSide, SpreadRef, StoryId, StrokeAlign, StrokeType};
 use designcraft_geom::corners;
 use designcraft_geom::{Affine, BezPath, Rect, Shape, Vec2};
@@ -216,7 +216,7 @@ pub struct Renderer {
     resources: Resources,
     glyphs: text::GlyphCache,
     /// Composed stories looked up during the current render.
-    stories: HashMap<(StoryId, Option<usize>), Arc<ComposedStory>>,
+    stories: HashMap<(StoryId, ShownOn), Arc<ComposedStory>>,
     pub threads: u16,
     pub stats: FrameStats,
 }
@@ -404,6 +404,12 @@ impl Renderer {
                 SpreadRef::Doc(si) => Some(doc.first_page_of_spread(si)),
                 SpreadRef::Parent(_) => None,
             };
+            // Base items compose for where they show: the document page, or this parent spread.
+            let shown_on = |pi: usize| match (sr, first) {
+                (SpreadRef::Parent(p), _) => ShownOn::Parent(p),
+                (_, Some(a)) => ShownOn::Page(a + pi),
+                (_, None) => ShownOn::Own,
+            };
             for (pi, page) in sp.pages.iter().enumerate() {
                 if !page.show_parent_items {
                     continue;
@@ -420,19 +426,19 @@ impl Renderer {
                         if parent.page_at_x(it.bounds().center().x) != Some(ppage) && parent.pages.len() > 1 {
                             continue;
                         }
-                        self.draw_item(ctx, f, it, Affine::translate((dx, 0.0)), first.map(|a| a + pi));
+                        self.draw_item(ctx, f, it, Affine::translate((dx, 0.0)), shown_on(pi));
                     }
                 }
             }
             for it in &sp.items {
                 if it.layer == layer.id {
-                    self.draw_item(ctx, f, it, Affine::IDENTITY, None);
+                    self.draw_item(ctx, f, it, Affine::IDENTITY, ShownOn::Own);
                 }
             }
         }
     }
 
-    fn draw_item(&mut self, ctx: &mut RenderContext, f: &Frame, it: &Item, parent: Affine, page: Option<usize>) {
+    fn draw_item(&mut self, ctx: &mut RenderContext, f: &Frame, it: &Item, parent: Affine, page: ShownOn) {
         if it.hidden || f.opts.hidden.contains(&it.id) || f.opts.printing_only && it.nonprinting {
             return;
         }
@@ -532,18 +538,18 @@ impl Renderer {
 
     /// The composed story for a frame (memoised for the current render: the cache lookup
     /// validates the whole thread each time).
-    fn story(&mut self, f: &Frame, sid: StoryId, page: Option<usize>) -> Arc<ComposedStory> {
+    fn story(&mut self, f: &Frame, sid: StoryId, page: ShownOn) -> Arc<ComposedStory> {
         let key = (sid, page);
         if let Some(cs) = self.stories.get(&key) {
             return cs.clone();
         }
-        let cs = f.cache.get(f.doc, sid, page);
+        let cs = f.cache.get_on(f.doc, sid, page);
         self.stories.insert(key, cs.clone());
         cs
     }
 
     /// Fill, content and stroke of a leaf item (no opacity, blend or effects).
-    pub(crate) fn draw_body(&mut self, ctx: &mut RenderContext, f: &Frame, it: &Item, bp: &BezPath, xf: Affine, page: Option<usize>) {
+    pub(crate) fn draw_body(&mut self, ctx: &mut RenderContext, f: &Frame, it: &Item, bp: &BezPath, xf: Affine, page: ShownOn) {
         let doc = f.doc;
         // Fill.
         if !it.fill.is_none() {
diff --git a/crates/render/src/text.rs b/crates/render/src/text.rs
index 734ec275..e3d36788 100644
--- a/crates/render/src/text.rs
+++ b/crates/render/src/text.rs
@@ -9,7 +9,7 @@
 use std::collections::HashMap;
 use std::sync::Arc;
 
-use designcraft_compose::{ComposedStory, FrameText, Line};
+use designcraft_compose::{ComposedStory, FrameText, Line, ShownOn};
 use designcraft_doc::ItemId;
 use designcraft_fonts::FontDb;
 use designcraft_geom::{Affine, BezPath, Rect, Shape};
@@ -410,7 +410,7 @@ impl Renderer {
         {
             for o in &ft.objects {
                 if let Some(obj) = st.objects.get(o.index) {
-                    self.draw_item(ctx, f, &obj.item, xf * Affine::translate(o.origin.to_vec2()), None);
+                    self.draw_item(ctx, f, &obj.item, xf * Affine::translate(o.origin.to_vec2()), ShownOn::Own);
                 }
             }
         }
diff --git a/crates/tools/src/lib.rs b/crates/tools/src/lib.rs
index e58be750..0ec0b05a 100644
--- a/crates/tools/src/lib.rs
+++ b/crates/tools/src/lib.rs
@@ -224,17 +224,32 @@ impl ToolContext<'_> {
         let pi = spread.page_at_x(sp.x)?;
         let page = self.doc.first_page_of_spread(si) + pi;
         let pg = spread.pages.get(pi)?;
-        // Front to back: the page's parent, then the parents it is based on.
-        self.doc.shown_parent_pages(SpreadRef::Doc(si), pi).into_iter().rev().find_map(|(ppi, ppg)| {
-            let parent = self.doc.parents.get(ppi)?;
-            let at = sp - designcraft_geom::Vec2::new(pg.x - parent.pages.get(ppg)?.x, 0.0);
-            parent
-                .items
-                .iter()
-                .rev()
-                .find(|it| !it.locked && !pg.overridden.contains(&it.id) && designcraft_doc::edit_hit(it, at, self.tol(4.0)))
-                .map(|it| (page, it.id))
-        })
+        if !pg.show_parent_items {
+            return None;
+        }
+        // What the renderer draws on this page, in its order: by layer, then the parent's bases
+        // before the parent. The last hit is the topmost.
+        let mut shown = Vec::new();
+        for (ppi, ppg) in self.doc.shown_parent_pages(SpreadRef::Doc(si), pi) {
+            let Some(parent) = self.doc.parents.get(ppi) else { continue };
+            let Some(parent_page) = parent.pages.get(ppg) else { continue };
+            let off = designcraft_geom::Vec2::new(pg.x - parent_page.x, 0.0);
+            for it in &parent.items {
+                if pg.overridden.contains(&it.id) || parent.pages.len() > 1 && parent.page_at_x(it.bounds().center().x) != Some(ppg) {
+                    continue;
+                }
+                shown.push((it, off));
+            }
+        }
+        shown.sort_by_key(|(it, _)| self.doc.layer_rank(it.layer));
+        shown
+            .into_iter()
+            .rev()
+            .find(|(it, off)| {
+                let layer = self.doc.layer(it.layer);
+                !it.locked && !it.hidden && !layer.is_some_and(|l| !l.visible || l.locked) && designcraft_doc::edit_hit(it, sp - *off, self.tol(4.0))
+            })
+            .map(|(it, _)| (page, it.id))
     }
 
     fn hit_parent(&self, sr: SpreadRef, sp: Point) -> Option<(SpreadRef, ItemId)> {
diff --git a/crates/tools/src/snap.rs b/crates/tools/src/snap.rs
index 6d5c8f6a..4471abce 100644
--- a/crates/tools/src/snap.rs
+++ b/crates/tools/src/snap.rs
@@ -8,7 +8,7 @@
 
 use std::collections::HashSet;
 
-use designcraft_doc::{Item, ItemId, Orientation, PageSide, Selection, SpreadId, SpreadRef, StrokeAlign};
+use designcraft_doc::{Document, Item, ItemId, Orientation, Selection, SpreadRef, StrokeAlign};
 use designcraft_geom::snap::snap_to_grid;
 use designcraft_geom::{Affine, Point, Rect, Vec2, format_measure};
 
@@ -204,15 +204,13 @@ fn match_rotation(cx: &ToolContext, req: &SnapRequest<'_>, zone_length: f64) ->
             push_rotation(&mut best, cx.selection, req, item, Affine::IDENTITY, false, 0, &mut seen, proposed, tol);
         }
     }
-    // Parent editing already lists those items on the spread. Do not add them again.
-    if !layout_edits_parents(cx) {
+    if shows_parent_items(cx, req) {
         push_parent_rotations(&mut best, cx, req, &mut seen, proposed, tol);
     }
     best.map(|(_, angle)| angle)
 }
 
-/// Shown parent items, same page and `based_on` walk as parent lengths.
-/// Parent items are only translated onto the page, so the angle is still `item.xf`.
+/// Shown parent items. Parent items are only translated onto the page, so the angle is still `item.xf`.
 fn push_parent_rotations(
     best: &mut Option<(f64, f64)>,
     cx: &ToolContext,
@@ -221,57 +219,11 @@ fn push_parent_rotations(
     proposed: f64,
     tol: f64,
 ) {
-    let SpreadRef::Doc(si) = req.spread else { return };
-    let page_count = cx.doc.spreads.get(si).map(|sp| sp.pages.len()).unwrap_or(0);
-    let first = cx.doc.first_page_of_spread(si);
-    for pi in 0..page_count {
-        let Some(abs) = first.checked_add(pi) else { continue };
-        let Some(page) = cx.doc.page(abs) else { continue };
-        if !page.show_parent_items {
-            continue;
-        }
-        let doc_side = page.side;
-        let overridden = page.overridden.clone();
-        let Some((ppi, _)) = cx.doc.parent_page_for(abs) else { continue };
-        let mut seen_spreads = HashSet::new();
-        push_parent_rotation_chain(best, cx, req, doc_side, &overridden, ppi, seen_items, &mut seen_spreads, proposed, tol);
+    for (item, _) in shown_parent_items(cx.doc, req.spread) {
+        push_rotation(best, cx.selection, req, item, Affine::IDENTITY, false, 0, seen_items, proposed, tol);
     }
 }
 
-fn push_parent_rotation_chain(
-    best: &mut Option<(f64, f64)>,
-    cx: &ToolContext,
-    req: &SnapRequest<'_>,
-    doc_side: PageSide,
-    overridden: &[ItemId],
-    index: usize,
-    seen_items: &mut HashSet<ItemId>,
-    seen_spreads: &mut HashSet<SpreadId>,
-    proposed: f64,
-    tol: f64,
-) {
-    let Some(parent) = cx.doc.parents.get(index) else { return };
-    if !seen_spreads.insert(parent.id) {
-        return;
-    }
-    let next = parent.parent.as_ref().and_then(|info| info.based_on);
-    if let Some(page_idx) = shown_parent_page_index(parent.pages.len(), doc_side) {
-        for item in &parent.items {
-            if overridden.contains(&item.id) {
-                continue;
-            }
-            // A facing parent only shows items whose center sits on this document page's parent page.
-            if parent.pages.len() > 1 && parent.page_at_x(item.bounds().center().x) != Some(page_idx) {
-                continue;
-            }
-            push_rotation(best, cx.selection, req, item, Affine::IDENTITY, false, 0, seen_items, proposed, tol);
-        }
-    }
-    let Some(next_id) = next else { return };
-    let Some(next_index) = cx.doc.parent_index(next_id) else { return };
-    push_parent_rotation_chain(best, cx, req, doc_side, overridden, next_index, seen_items, seen_spreads, proposed, tol);
-}
-
 fn push_rotation(
     best: &mut Option<(f64, f64)>,
     selection: &Selection,
@@ -938,7 +890,7 @@ fn dimension_lengths(cx: &ToolContext, req: &SnapRequest<'_>) -> Vec<f64> {
             push_own_lengths(&mut out, cx.selection, req, item, Affine::IDENTITY, false, 0, &mut seen);
         }
     }
-    if !layout_edits_parents(cx) {
+    if shows_parent_items(cx, req) {
         push_parent_lengths(&mut out, cx, req, &mut seen);
     }
     out
@@ -1021,54 +973,11 @@ fn stroke_outset(item: &Item) -> f64 {
 }
 
 fn push_parent_lengths(out: &mut Vec<f64>, cx: &ToolContext, req: &SnapRequest<'_>, seen_items: &mut HashSet<ItemId>) {
-    let SpreadRef::Doc(si) = req.spread else { return };
-    let page_count = cx.doc.spreads.get(si).map(|sp| sp.pages.len()).unwrap_or(0);
-    let first = cx.doc.first_page_of_spread(si);
-    for pi in 0..page_count {
-        let Some(abs) = first.checked_add(pi) else { continue };
-        let Some(page) = cx.doc.page(abs) else { continue };
-        if !page.show_parent_items {
-            continue;
-        }
-        let doc_side = page.side;
-        let overridden = page.overridden.clone();
-        let Some((ppi, _)) = cx.doc.parent_page_for(abs) else { continue };
-        let mut seen_spreads = HashSet::new();
-        push_parent_length_chain(out, cx, req, doc_side, &overridden, ppi, seen_items, &mut seen_spreads);
+    for (item, _) in shown_parent_items(cx.doc, req.spread) {
+        push_own_lengths(out, cx.selection, req, item, Affine::IDENTITY, false, 0, seen_items);
     }
 }
 
-fn push_parent_length_chain(
-    out: &mut Vec<f64>,
-    cx: &ToolContext,
-    req: &SnapRequest<'_>,
-    doc_side: PageSide,
-    overridden: &[ItemId],
-    index: usize,
-    seen_items: &mut HashSet<ItemId>,
-    seen_spreads: &mut HashSet<SpreadId>,
-) {
-    let Some(parent) = cx.doc.parents.get(index) else { return };
-    if !seen_spreads.insert(parent.id) {
-        return;
-    }
-    let next = parent.parent.as_ref().and_then(|info| info.based_on);
-    if let Some(page_idx) = shown_parent_page_index(parent.pages.len(), doc_side) {
-        for item in &parent.items {
-            if overridden.contains(&item.id) {
-                continue;
-            }
-            if parent.pages.len() > 1 && parent.page_at_x(item.bounds().center().x) != Some(page_idx) {
-                continue;
-            }
-            push_own_lengths(out, cx.selection, req, item, Affine::IDENTITY, false, 0, seen_items);
-        }
-    }
-    let Some(next_id) = next else { return };
-    let Some(next_index) = cx.doc.parent_index(next_id) else { return };
-    push_parent_length_chain(out, cx, req, doc_side, overridden, next_index, seen_items, seen_spreads);
-}
-
 /// Ruler guides, margins, and column sides. No overlay.
 ///
 /// A page guide attracts when the moving rect overlaps that page on the other axis. A spread
@@ -1143,7 +1052,7 @@ fn pass_align(cx: &ToolContext, req: &SnapRequest<'_>, axis: Axis, tol: f64) ->
             offer_box(&mut best, req.rect, flags, axis, rect, tol, cx.snap.align_edges, cx.snap.align_centers);
         }
     }
-    if !layout_edits_parents(cx) {
+    if shows_parent_items(cx, req) {
         offer_parent_items(&mut best, cx, req, flags, axis, tol);
     }
     best.map(|b| b.hit)
@@ -1159,6 +1068,12 @@ fn layout_edits_parents(cx: &ToolContext) -> bool {
     cx.layout.slots.iter().any(|slot| matches!(slot.spread, SpreadRef::Parent(_)))
 }
 
+/// Whether to offer the parent items drawn on `req.spread`. A parent spread shows its bases' items,
+/// which are not on it.
+fn shows_parent_items(cx: &ToolContext, req: &SnapRequest<'_>) -> bool {
+    matches!(req.spread, SpreadRef::Parent(_)) || !layout_edits_parents(cx)
+}
+
 /// Visible box used for alignment. Groups with children contribute the union of the children.
 fn item_target_rect(selection: &Selection, req: &SnapRequest<'_>, item: &Item) -> Option<Rect> {
     if item.hidden || align_skips_item(selection, req, item.id) {
@@ -1228,72 +1143,44 @@ fn group_box(item: &Item, seen: &mut HashSet<ItemId>, depth: usize, filter: Opti
     acc.filter(|r| rect_finite(*r))
 }
 
-/// Parent items shown on the document spread, shifted into that spread's space.
+/// Parent items shown on the spread, shifted into that spread's space.
 fn offer_parent_items(best: &mut Option<Best>, cx: &ToolContext, req: &SnapRequest<'_>, flags: [bool; 3], axis: Axis, tol: f64) {
-    let SpreadRef::Doc(si) = req.spread else { return };
-    let page_count = cx.doc.spreads.get(si).map(|sp| sp.pages.len()).unwrap_or(0);
-    let first = cx.doc.first_page_of_spread(si);
-    for pi in 0..page_count {
-        let Some(abs) = first.checked_add(pi) else { continue };
-        let Some(page) = cx.doc.page(abs) else { continue };
+    for (item, dx) in shown_parent_items(cx.doc, req.spread) {
+        let Some(rect) = item_target_rect(cx.selection, req, item) else { continue };
+        offer_box(best, req.rect, flags, axis, shift_x(rect, dx), tol, cx.snap.align_edges, cx.snap.align_centers);
+    }
+}
+
+/// Parent items drawn on `spread`, back to front, each with the x shift from its parent spread:
+/// a document page's parent and its bases, or a parent spread's bases. Same page and override
+/// filters as the renderer.
+fn shown_parent_items(doc: &Document, spread: SpreadRef) -> Vec<(&Item, f64)> {
+    let Some(sp) = doc.spread(spread) else { return Vec::new() };
+    let mut out = Vec::new();
+    for (pi, page) in sp.pages.iter().enumerate() {
         if !page.show_parent_items {
             continue;
         }
-        let doc_x = page.x;
-        let doc_side = page.side;
-        let overridden = page.overridden.clone();
-        let Some((ppi, _)) = cx.doc.parent_page_for(abs) else { continue };
-        let mut seen = HashSet::new();
-        offer_parent_chain(best, cx, req, flags, axis, tol, doc_x, doc_side, &overridden, ppi, &mut seen);
-    }
-}
-
-/// Walk `based_on`. A repeated spread id ends the walk.
-fn offer_parent_chain(
-    best: &mut Option<Best>,
-    cx: &ToolContext,
-    req: &SnapRequest<'_>,
-    flags: [bool; 3],
-    axis: Axis,
-    tol: f64,
-    doc_x: f64,
-    doc_side: PageSide,
-    overridden: &[ItemId],
-    index: usize,
-    seen: &mut HashSet<SpreadId>,
-) {
-    let Some(parent) = cx.doc.parents.get(index) else { return };
-    if !seen.insert(parent.id) {
-        return;
-    }
-    let next = parent.parent.as_ref().and_then(|info| info.based_on);
-    if let Some(page_idx) = shown_parent_page_index(parent.pages.len(), doc_side)
-        && let Some(parent_page) = parent.pages.get(page_idx)
-    {
-        let dx = doc_x - parent_page.x;
-        if dx.is_finite() {
+        for (ppi, ppage) in doc.shown_parent_pages(spread, pi) {
+            let Some(parent) = doc.parents.get(ppi) else { continue };
+            let Some(parent_page) = parent.pages.get(ppage) else { continue };
+            let dx = page.x - parent_page.x;
+            if !dx.is_finite() {
+                continue;
+            }
             for item in &parent.items {
-                if overridden.contains(&item.id) {
+                if page.overridden.contains(&item.id) {
                     continue;
                 }
-                // Same other-page skip as the renderer: a facing parent only shows items
-                // whose center sits on the parent page this document page uses.
-                if parent.pages.len() > 1 && parent.page_at_x(item.bounds().center().x) != Some(page_idx) {
+                // A facing parent only shows items whose center sits on the parent page this page uses.
+                if parent.pages.len() > 1 && parent.page_at_x(item.bounds().center().x) != Some(ppage) {
                     continue;
                 }
-                let Some(rect) = item_target_rect(cx.selection, req, item) else { continue };
-                offer_box(best, req.rect, flags, axis, shift_x(rect, dx), tol, cx.snap.align_edges, cx.snap.align_centers);
+                out.push((item.as_ref(), dx));
             }
         }
     }
-    let Some(next_id) = next else { return };
-    let Some(next_index) = cx.doc.parent_index(next_id) else { return };
-    offer_parent_chain(best, cx, req, flags, axis, tol, doc_x, doc_side, overridden, next_index, seen);
-}
-
-/// Left page of a facing parent, otherwise the last page. Same choice as `Document::parent_page_for`.
-fn shown_parent_page_index(page_count: usize, side: PageSide) -> Option<usize> {
-    if page_count >= 2 && side == PageSide::Left { Some(0) } else { page_count.checked_sub(1) }
+    out
 }
 
 fn shift_x(r: Rect, dx: f64) -> Rect {
diff --git a/crates/tools/src/tests.rs b/crates/tools/src/tests.rs
index 6c75b0da..7f1abc1c 100644
--- a/crates/tools/src/tests.rs
+++ b/crates/tools/src/tests.rs
@@ -83,6 +83,29 @@ fn cmd_shift_click_overrides_parent_item() {
     assert_eq!(a, vec![Action::Exec("layout.overrideParentItems".into(), serde_json::json!({"page": 0, "ids": [pid.0]}))]);
 }
 
+/// On a page whose parent B is based on A, A's items are hit too, B's win where they overlap, and
+/// nothing is hit when the page hides parent items.
+#[test]
+fn parent_hit_reaches_base_parent_items_topmost_first() {
+    let mut d = Document::new(&NewDocument { pages: 1, facing_pages: false, ..Default::default() });
+    let lid = d.default_layer();
+    let a = d.parents[0].id;
+    let b = d.add_parent("B", "Opening", 1, 12.0, designcraft_doc::Margins::uniform(36.0));
+    Arc::make_mut(&mut d.parents[1]).parent.as_mut().unwrap().based_on = Some(a);
+    d.apply_parent(&[0], Some(b)).unwrap();
+    let (a_item, _) = d.add_text_frame(SpreadRef::Parent(0), Rect::new(100.0, 100.0, 200.0, 200.0), lid, "a", ParaFormat::default()).unwrap();
+    let (b_item, _) = d.add_text_frame(SpreadRef::Parent(1), Rect::new(150.0, 150.0, 250.0, 250.0), lid, "b", ParaFormat::default()).unwrap();
+    let hit = |d: &Document, x: f64, y: f64| {
+        let (s, c, l) = (Selection::default(), Cache::new(), CanvasLayout::new(d, false));
+        let off = l.xf(SpreadRef::Doc(0)).translation();
+        ctx(d, &s, &c, &l).hit_parent_on_page(Point::new(x + off.x, y + off.y))
+    };
+    assert_eq!(hit(&d, 120.0, 120.0), Some((0, a_item)));
+    assert_eq!(hit(&d, 175.0, 175.0), Some((0, b_item)), "B's item is drawn over A's");
+    Arc::make_mut(&mut d.spreads[0]).pages[0].show_parent_items = false;
+    assert_eq!(hit(&d, 120.0, 120.0), None);
+}
+
 #[test]
 fn gradient_tool_drag_sets_the_vector() {
     let mut d = Document::new(&NewDocument::default());
diff --git a/docs/gaps.md b/docs/gaps.md
index ebd2d7da..b00ddfb8 100644
--- a/docs/gaps.md
+++ b/docs/gaps.md
@@ -1,6 +1,6 @@
 # Where DesignCraft falls short of InDesign
 
-> **Last reviewed:** 2026-10-10 · **Last updated:** 2026-10-12 · **Change:** minor (book chapter update safety) · **Target:** Adobe InDesign 2026 (21.6)
+> **Last reviewed:** 2026-10-10 · **Last updated:** 2026-10-13 · **Change:** minor (Based on Parent leftovers) · **Target:** Adobe InDesign 2026 (21.6)
 
 Every known shortfall against InDesign 2026, one entry each, ranked by how much it stops an
 InDesign professional from doing real work. This is the work list: agents pick from the top.
@@ -165,7 +165,9 @@ Kind: **F** feature · **U** UI/UX · **T** typography · **FF** file format ·
   Profile / Edit Original, File ▸ File Info / Open PDF / Document and Print Presets / User
   Settings, Type ▸ Size presets, Table ▸ Table Options / Cell Options submenus, Paste Before/After,
   Convert Rows/Columns, Object ▸ Interactive ▸ Convert to (form fields), Flex Layout (new in 2026),
-  View ▸ Extras badges and Story Editor options.
+  View ▸ Extras badges and Story Editor options. Pages panel ▸ Parent Options (Based on Parent is
+  the `layout.parents.options` command only); overriding a base parent's items on a parent spread
+  itself (overrides work on document pages only).
 - **Estimate:** 40–70 h (most are thin wrappers over existing engine features).
 - **Doc:** [ui-parity.md](ui-parity.md)
 
@@ -227,5 +229,6 @@ Cue. These are excluded from every percentage.
 
 | Date | Change | Summary |
 |---|---|---|
+| 2026-10-13 | minor | Gap 16: Parent Options dialog and overrides of base items on a parent spread |
 | 2026-10-10 | minor | Gap 0 added and marked alpha blocker: manual text threading is missing (stage re-normalized to pre-alpha) |
 | 2026-10-10 | major | Created: 25 ranked gaps from the full re-measure against InDesign 2026 21.6 and issues #1–#352 |