From 7694c1117056d52fce675fab477531822559d807 Mon Sep 17 00:00:00 2001
From: vangel76 <vangel1976@googlemail.com>
Date: Sun, 8 Nov 2026 03:10:16 +0100
Subject: [PATCH 01/30] aep: a layer's markers and Source Text are read where
 they are stored, not searched for (#3276)

A layer's marker list is a direct child of its root tdgp, and its Source Text record
btds a direct child of the ADBE Text Properties group. Markers walked the whole layer
subtree twice per layer (most layers have no marker list, so the walk always ran to the
end), and the three text-document accessors walked it once each.
---
 crates/aep/src/container/textdoc.rs | 75 ++++++++++++++++++++++++++---
 crates/aep/src/import/markers.rs    |  2 +-
 2 files changed, 68 insertions(+), 9 deletions(-)

diff --git a/crates/aep/src/container/textdoc.rs b/crates/aep/src/container/textdoc.rs
index 566a48534..51b15d7df 100644
--- a/crates/aep/src/container/textdoc.rs
+++ b/crates/aep/src/container/textdoc.rs
@@ -881,23 +881,31 @@ impl TextDocument {
 }
 
 impl<'f, 'a> Layer<'f, 'a> {
-    /// The text document of a text layer (`LIST btdk` below `ADBE Text Properties`).
+    /// The Source Text record `LIST btds` (`ADBE Text Document`). It is a direct child of the
+    /// `ADBE Text Properties` group, which is a direct child of the layer's root `tdgp`
+    /// (`Layr/tdgp/tdgp/btds`, in every sample), so only that level is searched rather than the
+    /// whole layer.
+    fn source_text_record(&self) -> Option<&'f Chunk<'a>> {
+        let root = self.chunk.child_list(b"tdgp")?;
+        root.children().iter().filter(|g| g.is_list(b"tdgp")).find_map(|g| g.child_list(b"btds"))
+    }
+
+    /// The text document of a text layer (`LIST btdk` in the Source Text record `btds`).
     pub fn text_document(&self) -> Option<TextDocument> {
-        TextDocument::parse(self.chunk.find_list(b"btdk")?.bytes()?)
+        TextDocument::parse(self.source_text_record()?.child_list(b"btdk")?.bytes()?)
     }
 
     /// The Source Text property record: the `tdbs` in `btds[ADBE Text Document]` (a placeholder
     /// in every sample: no keys, no expression). Source Text keyframes and expressions were not
     /// sampled; a `list` (keys) or an expression in it marks them.
     pub fn source_text_property(&self) -> Option<Property<'f, 'a>> {
-        let btds = self.chunk.descendants().map(|(_, c)| c).find(|c| c.is_list(b"btds"))?;
-        Property::from_chunk(btds.child_list(b"tdbs")?)
+        Property::from_chunk(self.source_text_record()?.child_list(b"tdbs")?)
     }
 
-    /// The number of text documents (`LIST btdk`) of the layer: 1 in every sample; more would be
-    /// one per Source Text keyframe (not sampled).
+    /// The number of text documents (`LIST btdk`) in the Source Text record: 1 in every sample;
+    /// more would be one per Source Text keyframe (not sampled).
     pub fn text_document_count(&self) -> usize {
-        self.chunk.descendants().filter(|(_, c)| c.is_list(b"btdk")).count()
+        self.source_text_record().map_or(0, |btds| btds.descendants().filter(|(_, c)| c.is_list(b"btdk")).count())
     }
 }
 
@@ -942,10 +950,23 @@ pub enum CueType {
     Other(u32),
 }
 
+impl<'a> Chunk<'a> {
+    /// The marker list `LIST mrst` of a marker holder: a layer (`LIST Layr`) or a composition's
+    /// `SecL` list. A layer's `mrst` is a direct child of its root `tdgp` (`ADBE Marker`), so only
+    /// that place is looked at; most layers have none, and searching their whole property tree
+    /// for it was a large part of an import. Any other holder is searched depth-first.
+    pub(crate) fn marker_list(&self) -> Option<&Chunk<'a>> {
+        if self.is_list(b"Layr") {
+            return self.child_list(b"tdgp")?.child_list(b"mrst");
+        }
+        self.find_list(b"mrst")
+    }
+}
+
 /// Reads the markers below `holder` (a layer or the composition's `SecL` list): the `mrst` list has a
 /// property whose 16-byte records give the times and one `Nmrd` list per marker with the strings.
 fn markers_in(holder: &Chunk<'_>) -> Vec<Marker> {
-    let Some(mrst) = holder.find_list(b"mrst") else { return Vec::new() };
+    let Some(mrst) = holder.marker_list() else { return Vec::new() };
     let Some(prop) = mrst.child_list(b"tdbs").and_then(Property::from_chunk) else { return Vec::new() };
     let Some(keys) = prop.keys() else { return Vec::new() };
     let scale = prop.time_scale().unwrap_or(0);
@@ -1006,6 +1027,44 @@ impl<'f, 'a> Comp<'f, 'a> {
 mod tests {
     use super::*;
 
+    fn list(t: &[u8; 4], kids: Vec<Chunk<'static>>) -> Chunk<'static> {
+        Chunk::list(*t, kids)
+    }
+
+    #[test]
+    fn a_layers_marker_list_is_the_one_in_its_root_group() {
+        let marked = |tag: u8| list(b"mrst", vec![Chunk::data(*b"test", vec![tag])]);
+        // The stored place: `Layr/tdgp/mrst`.
+        let layer = list(b"Layr", vec![list(b"tdgp", vec![list(b"tdgp", vec![]), marked(1)])]);
+        assert_eq!(layer.marker_list().and_then(|m| m.child(b"test")).and_then(Chunk::bytes), Some(&[1u8][..]));
+        // A list deeper in the layer is not the layer's marker list (the old depth-first search
+        // found it); a layer without a marker list in its root group has no markers.
+        let deep = list(b"Layr", vec![list(b"tdgp", vec![list(b"tdgp", vec![marked(2)])])]);
+        assert!(deep.marker_list().is_none());
+        assert!(Layer { chunk: &deep }.markers().is_empty());
+        // Any other holder (a composition's `SecL`) is still searched depth-first.
+        let secl = list(b"SecL", vec![list(b"tdgp", vec![list(b"tdgp", vec![marked(3)])])]);
+        assert_eq!(secl.marker_list().and_then(|m| m.child(b"test")).and_then(Chunk::bytes), Some(&[3u8][..]));
+    }
+
+    #[test]
+    fn the_source_text_record_is_found_in_the_text_group() {
+        let doc = b"/1 << /1 [ << /0 << /0 (\xfe\xff\0H\0\r) /6 << /0 [ << /0 << /0 << /6 << /0 0 /1 50 /53 << /0 << /1 [ 1 1 0 0 ] >> >> >> >> >> /1 2 >> ] >> >> >> ] >>";
+        // `btdk` is an opaque list (its body is not a chunk sequence), as the reader makes it.
+        let btdk = || Chunk { id: *b"LIST", body: crate::container::Body::OpaqueList { list_type: *b"btdk", data: doc.to_vec().into() }, pad: None };
+        let btds_real = |n: usize| list(b"btds", std::iter::once(list(b"tdbs", vec![])).chain((0..n).map(|_| btdk())).collect());
+        let layer = list(b"Layr", vec![list(b"tdgp", vec![list(b"tdgp", vec![]), list(b"tdgp", vec![btds_real(2)])])]);
+        let view = Layer { chunk: &layer };
+        assert_eq!(view.text_document().map(|d| d.text), Some("H".to_string()));
+        assert!(view.source_text_property().is_some());
+        assert_eq!(view.text_document_count(), 2);
+        // A record anywhere else in the layer is not its Source Text.
+        let elsewhere = list(b"Layr", vec![list(b"tdgp", vec![list(b"tdgp", vec![list(b"tdgp", vec![btds_real(1)])])])]);
+        let view = Layer { chunk: &elsewhere };
+        assert!(view.text_document().is_none() && view.source_text_property().is_none());
+        assert_eq!(view.text_document_count(), 0);
+    }
+
     #[test]
     fn non_finite_numbers_are_not_numbers() {
         let TextValue::Dict(pairs) = parse_text_dict(b"/1 inf /2 nan /3 1e999 /4 -inf /5 2.5 /6 7") else { panic!("a dict") };
diff --git a/crates/aep/src/import/markers.rs b/crates/aep/src/import/markers.rs
index b65840c69..93faea90a 100644
--- a/crates/aep/src/import/markers.rs
+++ b/crates/aep/src/import/markers.rs
@@ -24,7 +24,7 @@ use crate::import::time::TimeMap;
 
 /// The time scale of the marker list below `holder` (the layer, or the composition's `SecL`).
 fn marker_scale(holder: &Chunk<'_>) -> Option<u32> {
-    holder.find_list(b"mrst")?.child_list(b"tdbs").and_then(AepProp::from_chunk)?.time_scale().filter(|s| *s != 0)
+    holder.marker_list()?.child_list(b"tdbs").and_then(AepProp::from_chunk)?.time_scale().filter(|s| *s != 0)
 }
 
 /// The markers of a layer (`holder` = the layer chunk) or a composition (`holder` = its `SecL`).

From 8bf184a2d4d175417858b38113d5bc23002fb25f Mon Sep 17 00:00:00 2001
From: vangel76 <vangel1976@googlemail.com>
Date: Sun, 8 Nov 2026 03:15:24 +0100
Subject: [PATCH 02/30] aep export: build the prototype template once, sort
 names with cached keys (#3277)

The template every export clones from is immutable; it is now built by the
first export of the process and kept (about 0.93 MB). The name sort builds
each natural key once instead of on every comparison. Root solids move into
the Solids folder instead of being copied. The two key-list rewrites share one
emit-local helper and match names compare as bytes instead of a decoded String.
Output is byte-identical.
---
 crates/aep/src/export/emit.rs     | 416 ++++++++++++++++++++++++------
 crates/aep/src/export/template.rs |  17 ++
 2 files changed, 355 insertions(+), 78 deletions(-)

diff --git a/crates/aep/src/export/emit.rs b/crates/aep/src/export/emit.rs
index e7423efe9..0f49f995f 100644
--- a/crates/aep/src/export/emit.rs
+++ b/crates/aep/src/export/emit.rs
@@ -7,7 +7,7 @@ use crate::{AepFile, Chunk};
 use effectcraft_project::{ItemId, LayerId};
 
 use crate::export::plan::{CompPlan, Entry, ItemPlan, KeyPlan, LayerPlan, LayerSrc, ProjectPlan, PropKind, PropPlan, SolidPlan, natural_key};
-use crate::export::template::Template;
+use crate::export::template::{self, Template};
 use crate::export::tree::{
     R, child_data, data_mut, kids_mut, list_mut, put, put_bits, put_cstr, put_f32, put_f64, put_i32, put_u8, put_u16, put_u32, set_utf8, tpl,
 };
@@ -58,10 +58,14 @@ struct Cx<'t> {
 type Sorted = (String, u64, Vec<Chunk<'static>>);
 
 pub(crate) fn emit(plan: &ProjectPlan, extra: &[u8]) -> R<Vec<u8>> {
-    let t = Template::load()?;
+    emit_with(template::shared()?, plan, extra)
+}
+
+/// [`emit`] with the prototypes of `t`.
+fn emit_with(t: &Template, plan: &ProjectPlan, extra: &[u8]) -> R<Vec<u8>> {
     let special = plan.root.iter().find(|e| e.name == "Solids" && matches!(e.plan, ItemPlan::Folder(_))).map(|e| e.ec);
     let mut cx = Cx {
-        t: &t,
+        t,
         ids: Ids { next: FIRST_ID },
         solid_ids: HashMap::new(),
         comp_ids: HashMap::new(),
@@ -77,16 +81,14 @@ pub(crate) fn emit(plan: &ProjectPlan, extra: &[u8]) -> R<Vec<u8>> {
 
     let mut root: Vec<Sorted> = Vec::new();
     build_level(&plan.root, &mut cx, &ids_by_entry, &mut |name, key, chunks| root.push((name, key, chunks)))?;
-    // The Solids folder: root-level solids and the hidden solids of null layers.
-    let mut solids_children: Vec<Sorted> = Vec::new();
-    for (name, key, chunks) in root.iter().filter(|(_, k, _)| *k & ROOT_SOLID != 0) {
-        solids_children.push((name.clone(), *key, chunks.clone()));
-    }
-    root.retain(|(_, k, c)| *k & ROOT_SOLID == 0 && !c.is_empty());
-    for (i, (name, chunk)) in cx.extra_solids.iter().enumerate() {
-        let mut v = vec![chunk.clone()];
+    // The Solids folder: root-level solids and the hidden solids of null layers (moved, not
+    // copied: the root keeps neither).
+    let (mut solids_children, mut root): (Vec<Sorted>, Vec<Sorted>) = root.into_iter().partition(|(_, k, _)| *k & ROOT_SOLID != 0);
+    root.retain(|(_, _, c)| !c.is_empty());
+    for (i, (name, chunk)) in std::mem::take(&mut cx.extra_solids).into_iter().enumerate() {
+        let mut v = vec![chunk];
         v.extend(cx.t.fset.iter().cloned());
-        solids_children.push((name.clone(), i as u64, v));
+        solids_children.push((name, i as u64, v));
     }
     let mut folder = match cx.special_slot.take() {
         Some((item, inner)) => {
@@ -125,24 +127,39 @@ pub(crate) fn emit(plan: &ProjectPlan, extra: &[u8]) -> R<Vec<u8>> {
 /// Marks a root entry that goes into the `Solids` folder.
 const ROOT_SOLID: u64 = 1 << 63;
 
+/// Sorts by name in natural order, then by the tie-break key. Each name's [`natural_key`] is built
+/// once, not on every comparison; the sort is stable, as `sort_by` is.
 fn sort_named(v: &mut [Sorted]) {
-    v.sort_by(|a, b| natural_cmp(&a.0, &b.0).then(a.1.cmp(&b.1)));
+    v.sort_by_cached_key(|(name, key, _)| (Natural(natural_key(name)), *key));
 }
 
-fn natural_cmp(a: &str, b: &str) -> std::cmp::Ordering {
-    let (ka, kb) = (natural_key(a), natural_key(b));
-    for (x, y) in ka.iter().zip(kb.iter()) {
-        let c = match (x.0, y.0) {
-            (true, true) => x.2.cmp(&y.2).then_with(|| x.1.cmp(&y.1)),
-            (false, false) => x.1.cmp(&y.1),
-            (true, false) => std::cmp::Ordering::Less,
-            (false, true) => std::cmp::Ordering::Greater,
-        };
-        if c != std::cmp::Ordering::Equal {
-            return c;
+/// A [`natural_key`] ordered segment by segment: a number before text, numbers by value and then
+/// by their digits (`1` before `01`), text by its lowercase string; a key that is a prefix of the
+/// other first. Two keys compare equal only when they are equal.
+#[derive(PartialEq, Eq)]
+struct Natural(Vec<(bool, String, u128)>);
+
+impl Ord for Natural {
+    fn cmp(&self, other: &Self) -> std::cmp::Ordering {
+        for (x, y) in self.0.iter().zip(other.0.iter()) {
+            let c = match (x.0, y.0) {
+                (true, true) => x.2.cmp(&y.2).then_with(|| x.1.cmp(&y.1)),
+                (false, false) => x.1.cmp(&y.1),
+                (true, false) => std::cmp::Ordering::Less,
+                (false, true) => std::cmp::Ordering::Greater,
+            };
+            if c != std::cmp::Ordering::Equal {
+                return c;
+            }
         }
+        self.0.len().cmp(&other.0.len())
+    }
+}
+
+impl PartialOrd for Natural {
+    fn partial_cmp(&self, other: &Self) -> Option<std::cmp::Ordering> {
+        Some(self.cmp(other))
     }
-    ka.len().cmp(&kb.len())
 }
 
 fn assign_ids(entries: &[Entry], cx: &mut Cx<'_>, map: &mut HashMap<ItemId, u32>) -> R<()> {
@@ -404,8 +421,7 @@ fn put_used_comps(cx: &Cx<'_>, item: &mut Chunk<'static>, cp: &CompPlan) -> R<()
 fn put_time_remap_max(layr: &mut Chunk<'static>, seconds: f64) -> R<()> {
     let root = list_mut(layr, b"tdgp")?;
     let kids = kids_mut(root)?;
-    let at =
-        kids.iter().position(|c| c.is(b"tdmn") && tdmn_name(c).as_deref() == Some("ADBE Time Remapping")).ok_or_else(|| tpl("layer without Time Remapping"))?;
+    let at = kids.iter().position(|c| c.is(b"tdmn") && tdmn_is(c, "ADBE Time Remapping")).ok_or_else(|| tpl("layer without Time Remapping"))?;
     let tdbs = kids.get_mut(at + 1).ok_or_else(|| tpl("Time Remapping without a record"))?;
     put_f64(child_data(tdbs, b"tduM")?, 0, seconds)
 }
@@ -420,8 +436,7 @@ fn put_time_remap_max(layr: &mut Chunk<'static>, seconds: f64) -> R<()> {
 fn put_time_remap(cx: &Cx<'_>, layr: &mut Chunk<'static>, remap: &PropPlan) -> R<()> {
     let root = list_mut(layr, b"tdgp")?;
     let kids = kids_mut(root)?;
-    let at =
-        kids.iter().position(|c| c.is(b"tdmn") && tdmn_name(c).as_deref() == Some("ADBE Time Remapping")).ok_or_else(|| tpl("layer without Time Remapping"))?;
+    let at = kids.iter().position(|c| c.is(b"tdmn") && tdmn_is(c, "ADBE Time Remapping")).ok_or_else(|| tpl("layer without Time Remapping"))?;
     let tdbs = kids.get_mut(at + 1).ok_or_else(|| tpl("Time Remapping without a record"))?;
     put_u32(child_data(tdbs, b"tdsb")?, 0, 1)?;
     {
@@ -454,21 +469,12 @@ fn put_time_remap(cx: &Cx<'_>, layr: &mut Chunk<'static>, remap: &PropPlan) -> R
             .find(|k| matches!(&k.body, crate::Body::List { list_type, .. } if list_type == b"list"))
             .cloned()
             .ok_or_else(|| tpl("keyed prototype without a list"))?;
-        let n = u32::try_from(remap.keys.len()).map_err(|_| tpl("too many keys"))?;
         let size = 48usize;
-        {
-            let lhd3 = child_data(&mut list, b"lhd3")?;
-            crate::export::synth::put_key_counts(lhd3, n, 48)?;
-        }
         let mut ldat = Vec::with_capacity(size * remap.keys.len());
         for k in &remap.keys {
             ldat.extend(plain_record(1, k, size)?);
         }
-        let ld = kids_mut(&mut list)?;
-        match ld.iter_mut().find(|c| c.is(b"ldat")) {
-            Some(c) => *c = Chunk::data(*b"ldat", ldat),
-            None => ld.push(Chunk::data(*b"ldat", ldat)),
-        }
+        set_key_list(&mut list, ldat, remap.keys.len(), size)?;
         if let Some(slot) = rk.get_mut(cdat_at) {
             *slot = list;
         }
@@ -616,10 +622,7 @@ fn put_masks(cx: &Cx<'_>, layr: &mut Chunk<'static>, lp: &LayerPlan) -> R<()> {
     let parade = crate::export::masks::build_parade(&cx.t.masks, &lp.masks, lp.source_size)?;
     let root = list_mut(layr, b"tdgp")?;
     let kids = kids_mut(root)?;
-    let at = kids
-        .iter()
-        .position(|c| c.is(b"tdmn") && tdmn_name(c).as_deref() == Some("ADBE Transform Group"))
-        .ok_or_else(|| tpl("layer without a Transform group"))?;
+    let at = kids.iter().position(|c| c.is(b"tdmn") && tdmn_is(c, "ADBE Transform Group")).ok_or_else(|| tpl("layer without a Transform group"))?;
     kids.splice(at..at, parade);
     Ok(())
 }
@@ -633,10 +636,7 @@ fn put_effects(cx: &mut Cx<'_>, layr: &mut Chunk<'static>, lp: &LayerPlan, layer
     let parade = crate::export::effects::build_parade(&cx.t.effects, &lp.fx, layer_id, layer_ids, lp.source_size, &mut cx.fx_use)?;
     let root = list_mut(layr, b"tdgp")?;
     let kids = kids_mut(root)?;
-    let at = kids
-        .iter()
-        .position(|c| c.is(b"tdmn") && tdmn_name(c).as_deref() == Some("ADBE Transform Group"))
-        .ok_or_else(|| tpl("layer without a Transform group"))?;
+    let at = kids.iter().position(|c| c.is(b"tdmn") && tdmn_is(c, "ADBE Transform Group")).ok_or_else(|| tpl("layer without a Transform group"))?;
     kids.splice(at..at, parade);
     Ok(())
 }
@@ -659,9 +659,17 @@ const GROUP_ORDER: [&str; 13] = [
     "ADBE Group End",
 ];
 
-fn tdmn_name(c: &Chunk<'_>) -> Option<String> {
-    let d = c.bytes()?;
-    Some(d.iter().take_while(|b| **b != 0).map(|b| char::from(*b)).collect())
+/// The match name of a `tdmn` chunk: its bytes up to the first NUL, not decoded (empty for a chunk
+/// without data). Every name the exporter looks for is ASCII, so comparing bytes is the same as
+/// comparing the Latin-1 text the other exporter modules decode.
+fn tdmn_bytes<'c>(c: &'c Chunk<'_>) -> &'c [u8] {
+    let d = c.bytes().unwrap_or_default();
+    d.split(|b| *b == 0).next().unwrap_or_default()
+}
+
+/// True when `c` has data and names `name`.
+fn tdmn_is(c: &Chunk<'_>, name: &str) -> bool {
+    c.bytes().is_some() && tdmn_bytes(c) == name.as_bytes()
 }
 
 /// Inserts the properties of `lp` into the layer's Transform group, in the order the file uses.
@@ -671,20 +679,17 @@ fn put_properties(cx: &Cx<'_>, layr: &mut Chunk<'static>, lp: &LayerPlan, cp: &C
     }
     let root = list_mut(layr, b"tdgp")?;
     let kids = kids_mut(root)?;
-    let at = kids
-        .iter()
-        .position(|c| c.is(b"tdmn") && tdmn_name(c).as_deref() == Some("ADBE Transform Group"))
-        .ok_or_else(|| tpl("layer without a Transform group"))?;
+    let at = kids.iter().position(|c| c.is(b"tdmn") && tdmn_is(c, "ADBE Transform Group")).ok_or_else(|| tpl("layer without a Transform group"))?;
     let group = kids.get_mut(at + 1).ok_or_else(|| tpl("Transform group without a list"))?;
     let gk = kids_mut(group)?;
     // Split the group into its header (up to the first match name) and (tdmn, node) pairs.
     let first = gk.iter().position(|c| c.is(b"tdmn")).ok_or_else(|| tpl("empty Transform group"))?;
     let header: Vec<Chunk<'static>> = gk.drain(..first).collect();
-    let mut pairs: Vec<(String, Vec<Chunk<'static>>)> = Vec::new();
+    let mut pairs: Vec<(Vec<u8>, Vec<Chunk<'static>>)> = Vec::new();
     let mut it = std::mem::take(gk).into_iter();
     while let Some(m) = it.next() {
-        let name = tdmn_name(&m).unwrap_or_default();
-        if name == "ADBE Group End" {
+        let name = tdmn_bytes(&m).to_vec();
+        if name == b"ADBE Group End" {
             pairs.push((name, vec![m]));
             continue;
         }
@@ -694,22 +699,19 @@ fn put_properties(cx: &Cx<'_>, layr: &mut Chunk<'static>, lp: &LayerPlan, cp: &C
     for p in &lp.props {
         let name = p.kind.match_name();
         let built = build_prop(cx, p, lp, cp)?;
-        let tdmn = pairs.iter().find(|(n, _)| n == name).and_then(|(_, v)| v.first().cloned()).unwrap_or_else(|| {
-            cx.t.stat
-                .iter()
-                .chain(cx.t.keyd.iter())
-                .find(|c| c.is(b"tdmn") && tdmn_name(c).as_deref() == Some(name))
-                .cloned()
-                .unwrap_or_else(|| Chunk::data(*b"tdmn", Vec::new()))
+        let tdmn = pairs.iter().find(|(n, _)| n == name.as_bytes()).and_then(|(_, v)| v.first().cloned()).unwrap_or_else(|| {
+            cx.t.stat.iter().chain(cx.t.keyd.iter()).find(|c| c.is(b"tdmn") && tdmn_is(c, name)).cloned().unwrap_or_else(|| Chunk::data(*b"tdmn", Vec::new()))
         });
         let entry = vec![tdmn, built];
-        if let Some(slot) = pairs.iter_mut().find(|(n, _)| n == name) {
+        if let Some(slot) = pairs.iter_mut().find(|(n, _)| n == name.as_bytes()) {
             slot.1 = entry;
         } else {
-            pairs.push((name.to_string(), entry));
+            pairs.push((name.as_bytes().to_vec(), entry));
         }
     }
-    let rank = |n: &str| if n == "ADBE Group End" { usize::MAX } else { GROUP_ORDER.iter().position(|g| *g == n).unwrap_or(GROUP_ORDER.len()) };
+    let rank = |n: &[u8]| {
+        if n == b"ADBE Group End" { usize::MAX } else { GROUP_ORDER.iter().position(|g| g.as_bytes() == n).unwrap_or(GROUP_ORDER.len()) }
+    };
     pairs.sort_by_key(|(n, _)| rank(n));
     gk.extend(header);
     gk.extend(pairs.into_iter().flat_map(|(_, v)| v));
@@ -743,22 +745,12 @@ fn build_prop(cx: &Cx<'_>, p: &PropPlan, lp: &LayerPlan, cp: &CompPlan) -> R<Chu
             put_f64(cdat, i * 8, *v)?;
         }
     } else {
-        let list = list_mut(&mut tdbs, b"list")?;
-        let n = u32::try_from(p.keys.len()).map_err(|_| tpl("too many keys"))?;
         let size = if p.kind.spatial() { 56 + 24 * p.kind.dims() } else { 8 + 40 * p.kind.dims() };
-        {
-            let lhd3 = child_data(list, b"lhd3")?;
-            crate::export::synth::put_key_counts(lhd3, n, u32::try_from(size).map_err(|_| tpl("record size"))?)?;
-        }
         let mut ldat = Vec::with_capacity(size * p.keys.len());
         for k in &p.keys {
             ldat.extend(key_record(p.kind, k, size)?);
         }
-        let ld = kids_mut(list)?;
-        match ld.iter_mut().find(|c| c.is(b"ldat")) {
-            Some(c) => *c = Chunk::data(*b"ldat", ldat),
-            None => ld.push(Chunk::data(*b"ldat", ldat)),
-        }
+        set_key_list(list_mut(&mut tdbs, b"list")?, ldat, p.keys.len(), size)?;
     }
     if let Some((text, _)) = &p.expr {
         let kids = kids_mut(&mut tdbs)?;
@@ -768,6 +760,25 @@ fn build_prop(cx: &Cx<'_>, p: &PropPlan, lp: &LayerPlan, cp: &CompPlan) -> R<Chu
     Ok(tdbs)
 }
 
+/// Writes `count` key records of `size` bytes into the key list `list`: the counts into `lhd3`,
+/// the records as its `ldat` (replaced, or added when missing).
+///
+/// The same as `masks::set_key_list`, which takes the property record (`tdbs`) instead of the
+/// list; the time remap fills a list before it is put into its record.
+fn set_key_list(list: &mut Chunk<'static>, records: Vec<u8>, count: usize, size: usize) -> R<()> {
+    let n = u32::try_from(count).map_err(|_| tpl("too many keys"))?;
+    {
+        let lhd3 = child_data(list, b"lhd3")?;
+        crate::export::synth::put_key_counts(lhd3, n, u32::try_from(size).map_err(|_| tpl("record size"))?)?;
+    }
+    let ld = kids_mut(list)?;
+    match ld.iter_mut().find(|c| c.is(b"ldat")) {
+        Some(c) => *c = Chunk::data(*b"ldat", records),
+        None => ld.push(Chunk::data(*b"ldat", records)),
+    }
+    Ok(())
+}
+
 /// One keyframe record (`docs/aep-format.md`, 3.5).
 fn key_record(kind: PropKind, k: &KeyPlan, size: usize) -> R<Vec<u8>> {
     let mut r = vec![0u8; size];
@@ -818,3 +829,252 @@ pub(crate) fn plain_record(n: usize, k: &KeyPlan, size: usize) -> R<Vec<u8>> {
     }
     Ok(r)
 }
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use std::sync::Arc;
+
+    use effectcraft_color::Label;
+    use effectcraft_keyframe::{Keyframe, Value};
+    use effectcraft_project::{Comp, Expression, ItemKind, LayerSource, Project, Property, Solid, build};
+    use effectcraft_time::{FrameRate, TICKS_PER_SECOND, Tick};
+
+    fn secs(s: f64) -> Tick {
+        Tick((s * TICKS_PER_SECOND as f64).round() as i64)
+    }
+
+    fn add_layer(p: &mut Project, comp: ItemId, name: &str, source: LayerSource, edit: impl FnOnce(&mut effectcraft_project::Layer)) {
+        let mut c = p.comp(comp).cloned().expect("comp");
+        let mut l = build::layer(p, &c, name, source, (640, 360), None);
+        l.name = name.to_string();
+        edit(&mut l);
+        c.layers.insert(0, l);
+        if let Some(i) = p.item_mut(comp) {
+            i.kind = ItemKind::Comp(Arc::new(c));
+        }
+    }
+
+    fn two_keys(prop: Option<&mut Property>) {
+        let prop = prop.expect("property");
+        let v = prop.value.clone();
+        prop.keys = vec![Keyframe::new(secs(0.0), v.clone()), Keyframe::new(secs(1.5), v)];
+    }
+
+    /// A project that reaches every part of `emit`: folders (one named `Solids`), root and nested
+    /// solids with names that sort naturally, a precomposition, null layers (hidden solids), keyed
+    /// Transform properties, an expression and a keyed time remap.
+    fn varied(tag: &str) -> Project {
+        let mut p = Project::default();
+        let solid = |w| ItemKind::Solid(Solid { color: [0.2, 0.4, 0.6], width: w, height: 360, pixel_aspect: 1.0 });
+        let solids = p.add_item("Solids", Label::None, None, ItemKind::Folder);
+        let nested = p.add_item("Folder 10", Label::None, None, ItemKind::Folder);
+        p.add_item("folder 9", Label::None, Some(nested), ItemKind::Folder);
+        let mut ids = Vec::new();
+        for name in ["Solid 10", "Solid 2", "solid 2", "Solid 02", "Solid", "Ölung 1", ""] {
+            ids.push(p.add_item(&format!("{name}{tag}"), Label::Red, None, solid(640)));
+        }
+        p.add_item("In Solids 3", Label::None, Some(solids), solid(320));
+        p.add_item("In folder", Label::None, Some(nested), solid(100));
+        let pre = p.add_item("Pre 1", Label::None, Some(nested), ItemKind::Comp(Arc::new(Comp::new(640, 360, FrameRate::new(25, 1), secs(3.0)))));
+        add_layer(&mut p, pre, "S", LayerSource::Solid { item: ids[0] }, |_| {});
+        let main = p.add_item("Main", Label::None, None, ItemKind::Comp(Arc::new(Comp::new(1920, 1080, FrameRate::new(30, 1), secs(5.0)))));
+        add_layer(&mut p, main, "Null A", LayerSource::Null, |_| {});
+        add_layer(&mut p, main, "Null B", LayerSource::Null, |l| two_keys(l.props.prop_mut("transform/position")));
+        add_layer(&mut p, main, "Solid layer", LayerSource::Solid { item: ids[1] }, |l| {
+            two_keys(l.props.prop_mut("transform/opacity"));
+            two_keys(l.props.prop_mut("transform/anchor"));
+            if let Some(r) = l.props.prop_mut("transform/rotation") {
+                r.expr = Some(Expression { text: "time * 10".into(), enabled: true });
+            }
+        });
+        add_layer(&mut p, main, "Precomp", LayerSource::Comp { item: pre }, |l| {
+            let mut r = Property::new(9_000, "timeRemap", "Time Remap", Value::Scalar(0.0));
+            r.keys = vec![Keyframe::new(secs(0.0), Value::Scalar(3.0)), Keyframe::new(secs(3.0), Value::Scalar(0.0))];
+            l.props.children.insert(0, r.into());
+        });
+        p
+    }
+
+    fn plan_of(p: &Project) -> ProjectPlan {
+        let mut col = crate::export::report::Collector::default();
+        crate::export::plan::plan(p, &mut col)
+    }
+
+    /// The template is built once and every later export uses the same one.
+    #[test]
+    fn the_template_is_built_once() {
+        let a = template::shared().expect("template");
+        let b = template::shared().expect("template");
+        assert!(std::ptr::eq(a, b));
+    }
+
+    /// Exports with the shared template give the bytes a freshly built template gives, also after
+    /// other exports have used it (nothing an export does reaches the template).
+    #[test]
+    fn the_shared_template_exports_what_a_fresh_one_does() {
+        let (a, b) = (plan_of(&varied("")), plan_of(&varied(" x")));
+        let fresh = |plan: &ProjectPlan| emit_with(&Template::load().expect("template"), plan, b"trailer").expect("emit");
+        let (want_a, want_b) = (fresh(&a), fresh(&b));
+        assert!(want_a != want_b);
+        // The project exports without losses and the remap is written.
+        let r = crate::export::export(&varied(""), &crate::export::ExportOptions { allow_losses: false }).expect("lossless");
+        assert_eq!(r.report.exported.time_remaps, 1);
+        // The null layers' hidden solids and the root solids went into the `Solids` folder.
+        let file = crate::parse(&want_a).expect("parse");
+        let folder = file.walk().map(|(_, c)| c).filter(|c| c.is_list(b"Sfdr")).map(|c| c.children().iter().filter(|k| k.is_list(b"Item")).count()).max();
+        assert_eq!(folder, Some(10));
+        for _ in 0..3 {
+            assert!(emit(&a, b"trailer").expect("emit") == want_a);
+            assert!(emit(&b, b"trailer").expect("emit") == want_b);
+        }
+    }
+
+    /// Exports running at the same time on several threads, the first of them possibly building
+    /// the shared template, all give the single-threaded bytes.
+    #[test]
+    fn concurrent_exports_give_the_same_bytes() {
+        let plans: Vec<ProjectPlan> = ["", " x", " y", " z"].iter().map(|t| plan_of(&varied(t))).collect();
+        let want: Vec<Vec<u8>> = plans.iter().map(|plan| emit_with(&Template::load().expect("template"), plan, &[]).expect("emit")).collect();
+        let got: Vec<Vec<Vec<u8>>> = std::thread::scope(|s| {
+            let handles: Vec<_> = (0..8)
+                .map(|i| {
+                    let plans = &plans;
+                    s.spawn(move || (0..4).map(|k| emit(&plans[(i + k) % plans.len()], &[]).expect("emit")).collect::<Vec<_>>())
+                })
+                .collect();
+            handles.into_iter().map(|h| h.join().expect("thread")).collect()
+        });
+        for (i, bytes) in got.iter().enumerate() {
+            for (k, b) in bytes.iter().enumerate() {
+                assert!(b == &want[(i + k) % want.len()], "thread {i}, export {k}");
+            }
+        }
+    }
+
+    /// The comparator `sort_named` used before its keys were cached: `natural_key` built on every
+    /// comparison.
+    fn old_sort_named(v: &mut [Sorted]) {
+        fn natural_cmp(a: &str, b: &str) -> std::cmp::Ordering {
+            let (ka, kb) = (natural_key(a), natural_key(b));
+            for (x, y) in ka.iter().zip(kb.iter()) {
+                let c = match (x.0, y.0) {
+                    (true, true) => x.2.cmp(&y.2).then_with(|| x.1.cmp(&y.1)),
+                    (false, false) => x.1.cmp(&y.1),
+                    (true, false) => std::cmp::Ordering::Less,
+                    (false, true) => std::cmp::Ordering::Greater,
+                };
+                if c != std::cmp::Ordering::Equal {
+                    return c;
+                }
+            }
+            ka.len().cmp(&kb.len())
+        }
+        v.sort_by(|a, b| natural_cmp(&a.0, &b.0).then(a.1.cmp(&b.1)));
+    }
+
+    /// The cached-key sort orders names exactly as the comparator it replaced, and keeps entries
+    /// with the same name and key in their order (each carries its position as a marker chunk).
+    #[test]
+    fn sort_named_orders_as_the_old_comparator() {
+        let parts = [
+            "",
+            "0",
+            "00",
+            "1",
+            "01",
+            "2",
+            "10",
+            "a",
+            "A",
+            "b",
+            " ",
+            "-",
+            ".",
+            "é",
+            "É",
+            "ß",
+            "İ",
+            "\u{0}",
+            "Solid ",
+            "solid ",
+            "x9",
+            "9x",
+            "340282366920938463463374607431768211455",
+            "340282366920938463463374607431768211456",
+            "999999999999999999999999999999999999999999",
+        ];
+        // A small deterministic generator (splitmix64).
+        let mut state = 0x2545_f491_4f6c_dd1d_u64;
+        let mut next = move || {
+            state = state.wrapping_add(0x9e37_79b9_7f4a_7c15);
+            let mut z = state;
+            z = (z ^ (z >> 30)).wrapping_mul(0xbf58_476d_1ce4_e5b9);
+            z = (z ^ (z >> 27)).wrapping_mul(0x94d0_49bb_1331_11eb);
+            (z ^ (z >> 31)) as usize
+        };
+        for round in 0..200 {
+            let n = 1 + next() % 40;
+            let v: Vec<Sorted> = (0..n)
+                .map(|i| {
+                    let name: String = (0..next() % 4).map(|_| parts[next() % parts.len()]).collect();
+                    let key = (next() % 3) as u64 | if next() % 2 == 0 { ROOT_SOLID } else { 0 };
+                    (name, key, vec![Chunk::data(*b"mark", (i as u32).to_le_bytes().to_vec())])
+                })
+                .collect();
+            let (mut old, mut new) = (v.clone(), v);
+            old_sort_named(&mut old);
+            sort_named(&mut new);
+            assert_eq!(old, new, "round {round}");
+        }
+    }
+
+    /// `tdmn_is` and `tdmn_bytes` agree with the Latin-1 decoding they replaced for every name the
+    /// emitter looks up, which holds because those names are ASCII.
+    #[test]
+    fn match_names_compare_as_the_latin1_decoding_did() {
+        fn old_tdmn_name(c: &Chunk<'_>) -> Option<String> {
+            let d = c.bytes()?;
+            Some(d.iter().take_while(|b| **b != 0).map(|b| char::from(*b)).collect())
+        }
+        let mut wanted: Vec<&str> = GROUP_ORDER.to_vec();
+        wanted.extend(PropKind::ALL.iter().map(|k| k.match_name()));
+        wanted.extend(["ADBE Time Remapping", "ADBE Transform Group", "ADBE Group End"]);
+        assert!(wanted.iter().all(|n| n.is_ascii()));
+        let mut chunks: Vec<Chunk<'static>> = wanted.iter().map(|n| Chunk::data(*b"tdmn", format!("{n}\0\0junk").into_bytes())).collect();
+        chunks.extend([
+            Chunk::data(*b"tdmn", Vec::new()),
+            Chunk::data(*b"tdmn", b"ADBE Position".to_vec()),
+            Chunk::data(*b"tdmn", b"ADBE Position_0\0".to_vec()),
+            Chunk::data(*b"tdmn", b"ADBE Opacit\xe9\0".to_vec()),
+            Chunk::data(*b"tdmn", b"\xc3\x84DBE Scale\0".to_vec()),
+            Chunk::data(*b"tdmn", b"\0ADBE Scale".to_vec()),
+            Chunk::list(*b"tdmn", Vec::new()),
+        ]);
+        for c in &chunks {
+            for n in &wanted {
+                assert_eq!(tdmn_is(c, n), old_tdmn_name(c).as_deref() == Some(*n), "{c:?} {n}");
+            }
+            let old = old_tdmn_name(c).unwrap_or_default();
+            if old.is_ascii() {
+                assert_eq!(tdmn_bytes(c), old.as_bytes());
+            }
+        }
+    }
+
+    /// `set_key_list` writes the counts and replaces the records, or adds them when the list has
+    /// none.
+    #[test]
+    fn set_key_list_writes_counts_and_records() {
+        let lhd3 = || Chunk::data(*b"lhd3", vec![0; 52]);
+        let mut want_lhd3 = vec![0; 52];
+        crate::export::synth::put_key_counts(&mut want_lhd3, 3, 48).expect("counts");
+        for start in [vec![lhd3(), Chunk::data(*b"ldat", vec![9; 4])], vec![lhd3()]] {
+            let mut list = Chunk::list(*b"list", start);
+            set_key_list(&mut list, vec![7; 144], 3, 48).expect("set");
+            assert_eq!(list.children(), &[Chunk::data(*b"lhd3", want_lhd3.clone()), Chunk::data(*b"ldat", vec![7; 144])]);
+        }
+        let mut no_header = Chunk::list(*b"list", Vec::new());
+        assert!(set_key_list(&mut no_header, Vec::new(), 0, 48).is_err());
+    }
+}
diff --git a/crates/aep/src/export/template.rs b/crates/aep/src/export/template.rs
index 91daba636..608fa75e1 100644
--- a/crates/aep/src/export/template.rs
+++ b/crates/aep/src/export/template.rs
@@ -81,6 +81,23 @@ fn transform_records(keyed: bool) -> Vec<Chunk<'static>> {
         .collect()
 }
 
+/// The template every export clones from: built by the first export of the process and kept, as
+/// [`Template::load`] always builds the same prototypes and nothing changes them afterwards (the
+/// exporter only reads them through `&Template` and clones what it edits).
+///
+/// Concurrent exports are safe: the `static` requires `Template: Send + Sync`, which the compiler
+/// checks. Exports that race on the first call each build a template; one is kept and the others
+/// are dropped, and all of them are equal. A failed build is not kept, so the next export tries
+/// again and reports the same error.
+pub(crate) fn shared() -> R<&'static Template> {
+    static SHARED: std::sync::OnceLock<Template> = std::sync::OnceLock::new();
+    if let Some(t) = SHARED.get() {
+        return Ok(t);
+    }
+    let t = Template::load()?;
+    Ok(SHARED.get_or_init(|| t))
+}
+
 impl Template {
     pub fn load() -> R<Template> {
         let file = AepFile { chunks: crate::export::base::project_chunks(), trailer: std::borrow::Cow::Borrowed(&[]) };

From 38d51dd1856119f4a330d590d1f87cab2a0775ca Mon Sep 17 00:00:00 2001
From: vangel76 <vangel1976@googlemail.com>
Date: Sun, 8 Nov 2026 03:17:17 +0100
Subject: [PATCH 03/30] aep container: size sibling lists, hex and write output
 once; borrow plain .aepx attributes (#3275)

- read.rs: count the chunk headers of a sequence first and allocate the
  children Vec once (bounded by the input and by the chunk limit).
- aepx.rs: decode_hex sizes its output once; attribute values without
  an entity are borrowed instead of copied through decode_entities.
- typed.rs: PropGroup::get compares match names without building a
  String (same result as the lossy compare, invalid UTF-8 included).
- write.rs: reserve the exact output size up front (try_reserve, so a
  hand-built tree cannot abort on the allocation).
- read.rs, settings.rs, values.rs: use the shared bytes.rs readers.

Output is identical on the corpus (tree, written bytes, import).
---
 crates/aep/src/container/aepx.rs     | 88 ++++++++++++++++++++++++----
 crates/aep/src/container/read.rs     | 88 +++++++++++++++++++++++++---
 crates/aep/src/container/settings.rs |  9 +--
 crates/aep/src/container/typed.rs    | 27 ++++++++-
 crates/aep/src/container/values.rs   |  7 +--
 crates/aep/src/container/write.rs    | 74 +++++++++++++++++++++++
 6 files changed, 265 insertions(+), 28 deletions(-)

diff --git a/crates/aep/src/container/aepx.rs b/crates/aep/src/container/aepx.rs
index a45cbae1d..db78797ef 100644
--- a/crates/aep/src/container/aepx.rs
+++ b/crates/aep/src/container/aepx.rs
@@ -122,7 +122,7 @@ struct Reader<'d> {
     trailer: Option<Vec<u8>>,
 }
 
-impl Reader<'_> {
+impl<'d> Reader<'d> {
     fn run(mut self) -> Result<AepFile<'static>, AepError> {
         if self.data.starts_with(&[0xef, 0xbb, 0xbf]) {
             self.pos = 3;
@@ -227,7 +227,8 @@ impl Reader<'_> {
         let at = self.pos;
         self.pos = self.pos.saturating_add(1);
         let name = self.name()?;
-        let mut attrs: Vec<((usize, usize), Vec<u8>)> = Vec::new();
+        let data = self.data;
+        let mut attrs: Vec<((usize, usize), Cow<'d, [u8]>)> = Vec::new();
         let self_closing = loop {
             self.skip_ws();
             let rest = self.rest();
@@ -255,12 +256,19 @@ impl Reader<'_> {
             }
             let vstart = self.pos.saturating_add(1);
             let vend = self.find(vstart, &[quote]).ok_or(xml(vstart, "an attribute value is not closed"))?;
-            let raw = self.data.get(vstart..vend).unwrap_or(&[]);
+            let raw = data.get(vstart..vend).unwrap_or(&[]);
             if raw.contains(&b'<') {
                 return Err(xml(vstart, "`<` inside an attribute value"));
             }
-            let mut value = Vec::new();
-            decode_entities(raw, vstart, &mut value)?;
+            // A value without `&` is its own decoding (most of them, every `bdata` After Effects
+            // writes): borrow it instead of copying it.
+            let value = if raw.contains(&b'&') {
+                let mut value = Vec::new();
+                decode_entities(raw, vstart, &mut value)?;
+                Cow::Owned(value)
+            } else {
+                Cow::Borrowed(raw)
+            };
             self.pos = vend.saturating_add(1);
             attrs.push((key, value));
         };
@@ -476,11 +484,15 @@ fn decode_hex(text: &[u8], offset: usize) -> Result<Vec<u8>, AepError> {
         _ => None,
     };
     let (pairs, _) = text.as_chunks::<2>();
-    pairs
-        .iter()
-        .map(|[hi, lo]| digit(*hi).zip(digit(*lo)).map(|(h, l)| (h << 4) | l))
-        .collect::<Option<Vec<u8>>>()
-        .ok_or(xml(offset, "bdata holds a character that is not a hex digit"))
+    // Sized once (collecting into `Option<Vec>` has no size hint and regrows step by step).
+    let mut out = Vec::with_capacity(pairs.len());
+    for [hi, lo] in pairs {
+        match (digit(*hi), digit(*lo)) {
+            (Some(h), Some(l)) => out.push((h << 4) | l),
+            _ => return Err(xml(offset, "bdata holds a character that is not a hex digit")),
+        }
+    }
+    Ok(out)
 }
 
 /// The JSON body of an `alas` chunk from the attributes of a `fileReference`, keys in document
@@ -628,6 +640,62 @@ mod tests {
         assert!(matches!(read_aepx(b"<AfterEffectsProject>\xff</AfterEffectsProject>"), Err(AepError::Xml { .. })));
     }
 
+    #[test]
+    fn attribute_values_decode_entities_only_where_they_have_them() {
+        // An entity inside `bdata` still decodes before the hex does.
+        let f = read_aepx(doc("<a bdata=\"&#x30;1&#65;b\"/>").as_bytes()).unwrap();
+        assert_eq!(f.chunks[0].bytes(), Some(&[0x01, 0xab][..]));
+        // A bad entity in any attribute, even of an element that is skipped, is still an error.
+        for bad in ["<a other=\"&nbsp;\"/>", "<Unknown x=\"&bogus;\"/>", "<a bdata=\"00\" note=\"&amp\"/>"] {
+            assert!(matches!(read_aepx(doc(bad).as_bytes()), Err(AepError::Xml { .. })), "{bad}");
+        }
+        // Without `&` the value is taken as written.
+        let f = read_aepx(doc("<a bdata=\"0aFf\" x=\"y\"/>").as_bytes()).unwrap();
+        assert_eq!(f.chunks[0].bytes(), Some(&[0x0a, 0xff][..]));
+    }
+
+    #[test]
+    fn decode_hex_matches_the_collecting_version() {
+        fn old(text: &[u8], offset: usize) -> Result<Vec<u8>, AepError> {
+            if text.len() % 2 == 1 {
+                return Err(xml(offset, "bdata has an odd number of hex digits"));
+            }
+            let digit = |b: u8| match b {
+                b'0'..=b'9' => Some(b - b'0'),
+                b'a'..=b'f' => Some(b - b'a' + 10),
+                b'A'..=b'F' => Some(b - b'A' + 10),
+                _ => None,
+            };
+            let (pairs, _) = text.as_chunks::<2>();
+            pairs
+                .iter()
+                .map(|[hi, lo]| digit(*hi).zip(digit(*lo)).map(|(h, l)| (h << 4) | l))
+                .collect::<Option<Vec<u8>>>()
+                .ok_or(xml(offset, "bdata holds a character that is not a hex digit"))
+        }
+        let alphabet = b"0123456789abcdefABCDEFgG \0";
+        let mut seed = 0x2545_f491_4f6c_dd1du64;
+        for len in 0..200usize {
+            for _ in 0..20 {
+                let text: Vec<u8> = (0..len)
+                    .map(|_| {
+                        seed ^= seed << 13;
+                        seed ^= seed >> 7;
+                        seed ^= seed << 17;
+                        // Mostly hex digits, now and then a byte that is not one.
+                        let i = (seed % 1000) as usize;
+                        alphabet[if i < 990 { i % 22 } else { 22 + i % 4 }]
+                    })
+                    .collect();
+                let new = decode_hex(&text, 7);
+                assert_eq!(new, old(&text, 7));
+                if let Ok(v) = new {
+                    assert_eq!(v.capacity(), v.len());
+                }
+            }
+        }
+    }
+
     #[test]
     fn limits_hold() {
         let deep = format!("<AfterEffectsProject>{}{}</AfterEffectsProject>", "<a>".repeat(100_000), "</a>".repeat(100_000));
diff --git a/crates/aep/src/container/read.rs b/crates/aep/src/container/read.rs
index abae015ba..596404d15 100644
--- a/crates/aep/src/container/read.rs
+++ b/crates/aep/src/container/read.rs
@@ -2,6 +2,7 @@
 
 use std::borrow::Cow;
 
+use crate::container::bytes::{array, be_u32};
 use crate::container::chunk::{AepFile, Body, Chunk, LIST, NESTED_IDS};
 use crate::container::error::AepError;
 
@@ -39,7 +40,7 @@ pub fn parse_with_limits(data: &[u8], limits: Limits) -> Result<AepFile<'_>, Aep
     if id4(data, 0) != Some(*b"RIFX") {
         return Err(AepError::NotRifx);
     }
-    let declared = u64::from(be32(data, 4).ok_or(AepError::NotRifx)?);
+    let declared = u64::from(be_u32(data, 4).ok_or(AepError::NotRifx)?);
     let form = id4(data, 8).ok_or(AepError::NotRifx)?;
     if &form != b"Egg!" {
         return Err(AepError::BadFormType(form));
@@ -56,13 +57,8 @@ pub fn parse_with_limits(data: &[u8], limits: Limits) -> Result<AepFile<'_>, Aep
     Ok(AepFile { chunks, trailer: Cow::Borrowed(trailer) })
 }
 
-fn be32(data: &[u8], at: usize) -> Option<u32> {
-    id4(data, at).map(u32::from_be_bytes)
-}
-
 fn id4(data: &[u8], at: usize) -> Option<[u8; 4]> {
-    let b = data.get(at..at.checked_add(4)?)?;
-    Some([*b.first()?, *b.get(1)?, *b.get(2)?, *b.get(3)?])
+    array::<4>(data, at)
 }
 
 struct Parser<'a> {
@@ -74,13 +70,16 @@ struct Parser<'a> {
 impl<'a> Parser<'a> {
     /// Parses the sibling chunks that exactly fill `start..end`.
     fn sequence(&mut self, start: usize, end: usize, depth: usize) -> Result<Vec<Chunk<'a>>, AepError> {
-        let mut out = Vec::new();
+        // Sized once: a well-formed sequence fills exactly this many slots. The count is bounded by
+        // the input (one per 8 bytes at most) and by the chunks the limit still allows.
+        let capacity = self.count_siblings(start, end).min(self.limits.max_chunks.saturating_sub(self.count));
+        let mut out = Vec::with_capacity(capacity);
         let mut pos = start;
         while pos < end {
             let short = AepError::Malformed { offset: pos, what: "bytes left over that are too short for a chunk header" };
             let body_start = pos.checked_add(8).filter(|b| *b <= end).ok_or(short)?;
             let id = id4(self.data, pos).ok_or(AepError::Malformed { offset: pos, what: "short read" })?;
-            let size = be32(self.data, pos + 4).ok_or(AepError::Malformed { offset: pos, what: "short read" })? as usize;
+            let size = be_u32(self.data, pos + 4).ok_or(AepError::Malformed { offset: pos, what: "short read" })? as usize;
             let avail = end - body_start;
             if size > avail {
                 return Err(AepError::ChunkTooLarge { offset: pos, size: size as u64, available: avail as u64 });
@@ -103,6 +102,20 @@ impl<'a> Parser<'a> {
         Ok(out)
     }
 
+    /// The number of chunk headers that tile `start..end` the way [`Self::sequence`] walks them,
+    /// stopping at the first that does not fit. Never more than `(end - start) / 8`.
+    fn count_siblings(&self, start: usize, end: usize) -> usize {
+        let mut n = 0usize;
+        let mut pos = start;
+        while let Some(body_start) = pos.checked_add(8).filter(|b| *b <= end) {
+            let Some(size) = be_u32(self.data, pos.saturating_add(4)) else { break };
+            let Some(next) = usize::try_from(size).ok().and_then(|s| body_start.checked_add(s)).filter(|e| *e <= end) else { break };
+            n = n.saturating_add(1);
+            pos = if size % 2 == 1 && next < end { next.saturating_add(1) } else { next };
+        }
+        n
+    }
+
     /// Like [`Self::sequence`] but a structural problem yields `None` (the caller keeps bytes).
     fn tentative(&mut self, start: usize, end: usize, depth: usize) -> Result<Option<Vec<Chunk<'a>>>, AepError> {
         match self.sequence(start, end, depth) {
@@ -140,3 +153,60 @@ impl<'a> Parser<'a> {
         Ok(Body::Data(Cow::Borrowed(self.slice(start, end))))
     }
 }
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    /// Every children `Vec` in the tree, depth first.
+    fn child_vecs<'f, 'a>(chunks: &'f [Chunk<'a>], out: &mut Vec<&'f Vec<Chunk<'a>>>) {
+        for c in chunks {
+            match &c.body {
+                Body::List { children, .. } | Body::Chunks(children) => {
+                    out.push(children);
+                    child_vecs(children, out);
+                }
+                Body::Data(_) | Body::OpaqueList { .. } => {}
+            }
+        }
+    }
+
+    #[test]
+    fn every_sibling_list_is_allocated_once_at_its_exact_length() {
+        let inner: Vec<Chunk<'static>> = (0..37u8).map(|i| Chunk::data(*b"cdat", vec![i; usize::from(i % 5)])).collect();
+        let middle: Vec<Chunk<'static>> = (0..9).map(|_| Chunk::list(*b"tdbs", inner.clone())).collect();
+        let file = AepFile { chunks: vec![Chunk::data(*b"head", vec![0; 3]), Chunk::list(*b"Fold", middle)], trailer: Cow::Borrowed(&[]) };
+        let bytes = crate::container::write(&file).expect("write");
+        let parsed = parse(&bytes).expect("parse");
+        assert_eq!(crate::container::write(&parsed).expect("rewrite"), bytes);
+        let mut vecs = vec![&parsed.chunks];
+        child_vecs(&parsed.chunks, &mut vecs);
+        assert_eq!(vecs.len(), 11);
+        for v in vecs {
+            assert_eq!(v.capacity(), v.len(), "a sibling Vec grew past its length");
+        }
+    }
+
+    #[test]
+    fn the_preallocation_is_bounded_by_the_input_and_the_chunk_limit() {
+        // 1000 empty headers: the most chunks the bytes can hold.
+        let mut data = b"RIFX\0\0\0\0Egg!".to_vec();
+        data.extend(std::iter::repeat_n(*b"abcd\0\0\0\0", 1000).flatten());
+        let declared = u32::try_from(data.len() - 8).expect("small");
+        data[4..8].copy_from_slice(&declared.to_be_bytes());
+        let parser = Parser { data: &data, limits: Limits::default(), count: 0 };
+        assert_eq!(parser.count_siblings(12, data.len()), 1000);
+        assert!(parser.count_siblings(12, data.len()) <= (data.len() - 12) / 8);
+        // A header whose size runs past the end stops the count; a stray tail is not counted.
+        assert_eq!(parser.count_siblings(12, data.len() - 3), 999);
+        let mut big = data.clone();
+        big[16..20].copy_from_slice(&u32::MAX.to_be_bytes());
+        let parser = Parser { data: &big, limits: Limits::default(), count: 0 };
+        assert_eq!(parser.count_siblings(12, big.len()), 0);
+        let f = parse(&data).expect("parse");
+        assert_eq!((f.chunks.len(), f.chunks.capacity()), (1000, 1000));
+        // Under a tighter limit the parse fails as before, without sizing for more than allowed.
+        let tight = Limits { max_depth: 64, max_chunks: 10 };
+        assert_eq!(parse_with_limits(&data, tight), Err(AepError::TooManyChunks));
+    }
+}
diff --git a/crates/aep/src/container/settings.rs b/crates/aep/src/container/settings.rs
index b44588232..a39f09dff 100644
--- a/crates/aep/src/container/settings.rs
+++ b/crates/aep/src/container/settings.rs
@@ -2,6 +2,7 @@
 //! linear-light switches, the time display and the frame count start. Cases 620-634: one change
 //! each against the base project 620; every field below is the only byte (or chunk) that changes.
 
+use crate::container::bytes::be_u32;
 use crate::container::chunk::AepFile;
 use crate::container::footage::json_string;
 
@@ -130,7 +131,7 @@ fn base64_decode(text: &str) -> Option<Vec<u8>> {
 /// The profile description (ICC.1 tag `desc`): a v2 `desc` (ASCII) or a v4 `mluc` (its first
 /// record, UTF-16BE). `None` when the profile or the tag is cut short.
 fn icc_description(icc: &[u8]) -> Option<String> {
-    let be32 = |at: usize| icc.get(at..at.checked_add(4)?).and_then(|b| b.try_into().ok()).map(u32::from_be_bytes);
+    let be32 = |at: usize| be_u32(icc, at);
     let count = be32(128)?;
     let tag = (0..count.min(1024)).find_map(|i| {
         let at = 132usize.checked_add(usize::try_from(i).ok()?.checked_mul(12)?)?;
@@ -141,13 +142,13 @@ fn icc_description(icc: &[u8]) -> Option<String> {
     let body = icc.get(off..off.checked_add(len)?)?;
     let text = match body.get(..4)? {
         b"desc" => {
-            let n = usize::try_from(u32::from_be_bytes(body.get(8..12)?.try_into().ok()?)).ok()?;
+            let n = usize::try_from(be_u32(body, 8)?).ok()?;
             let ascii = body.get(12..12usize.checked_add(n)?)?;
             String::from_utf8_lossy(ascii.split(|b| *b == 0).next().unwrap_or_default()).into_owned()
         }
         b"mluc" => {
-            let n = usize::try_from(u32::from_be_bytes(body.get(20..24)?.try_into().ok()?)).ok()?;
-            let at = usize::try_from(u32::from_be_bytes(body.get(24..28)?.try_into().ok()?)).ok()?;
+            let n = usize::try_from(be_u32(body, 20)?).ok()?;
+            let at = usize::try_from(be_u32(body, 24)?).ok()?;
             let units: Vec<u16> = body.get(at..at.checked_add(n)?)?.as_chunks::<2>().0.iter().map(|p| u16::from_be_bytes(*p)).collect();
             String::from_utf16_lossy(&units)
         }
diff --git a/crates/aep/src/container/typed.rs b/crates/aep/src/container/typed.rs
index a61c69090..2450cbd3c 100644
--- a/crates/aep/src/container/typed.rs
+++ b/crates/aep/src/container/typed.rs
@@ -287,7 +287,7 @@ impl<'f, 'a> PropGroup<'f, 'a> {
                 pending = c.bytes();
             } else if c.id == crate::container::chunk::LIST
                 && let Some(body) = pending.take()
-                && match_name(body) == name
+                && match_name_is(body, name)
             {
                 return Some(PropNode::of(c));
             }
@@ -314,6 +314,14 @@ fn match_name(body: &[u8]) -> String {
     text(until_nul(body))
 }
 
+/// `match_name(body) == name` without building the `String`: equal bytes match; otherwise only
+/// a body that is not valid UTF-8 can still match (through its U+FFFD replacements), and only a
+/// name that holds U+FFFD.
+fn match_name_is(body: &[u8], name: &str) -> bool {
+    let bytes = until_nul(body);
+    bytes == name.as_bytes() || (name.contains('\u{FFFD}') && String::from_utf8_lossy(bytes) == name)
+}
+
 /// A property (`LIST tdbs`): `tdsb`, `tdsn`, the 124-byte header `tdb4`, then either the static
 /// value `cdat` or a keyframe `LIST list`.
 #[derive(Debug, Clone, Copy)]
@@ -536,4 +544,21 @@ mod tests {
         assert!(g.get("C").is_none());
         assert_eq!(g.names(), ["A", "B", "A"]);
     }
+
+    #[test]
+    fn match_name_is_agrees_with_comparing_the_decoded_name() {
+        let bodies: [&[u8]; 9] =
+            [b"ADBE Position\0\0\0", b"ADBE Position", b"ADBE Pos", b"", b"\0ADBE", b"ADBE \xff Bad\0", b"\xff", b"\xef\xbf\xbd", "Gr\u{fc}n\0".as_bytes()];
+        let names = ["ADBE Position", "ADBE Pos", "", "ADBE \u{FFFD} Bad", "\u{FFFD}", "Gr\u{fc}n", "ADBE Position\0", "ADBE \u{FFFD}"];
+        for body in bodies {
+            for name in names {
+                assert_eq!(match_name_is(body, name), match_name(body) == name, "{body:?} vs {name:?}");
+            }
+        }
+        // Names read back from a group find their entries, a damaged one included.
+        let group = Chunk::list(*b"tdgp", vec![Chunk::data(*b"tdmn", b"X\xffY\0".to_vec()), Chunk::list(*b"tdbs", Vec::new())]);
+        let g = PropGroup::from_chunk(&group).expect("group");
+        let names = g.names();
+        assert!(g.get(&names[0]).is_some());
+    }
 }
diff --git a/crates/aep/src/container/values.rs b/crates/aep/src/container/values.rs
index a690751a2..4a001ee1e 100644
--- a/crates/aep/src/container/values.rs
+++ b/crates/aep/src/container/values.rs
@@ -8,6 +8,7 @@
 //! 100 %. These defaults are verified for AV layers (solids); cameras and lights use other
 //! conventions (see the `camera` module).
 
+use crate::container::bytes::be_f64;
 use crate::container::typed::{Layer, Project, PropGroup, PropNode};
 
 /// Where a [`Tracked`] value came from.
@@ -192,8 +193,7 @@ impl<'f, 'a> Layer<'f, 'a> {
         let otda = otst.child_list(b"otky")?.child(b"otda")?.bytes()?;
         let mut degrees = [0.0; 3];
         for (i, slot) in degrees.iter_mut().enumerate() {
-            let b = otda.get(i * 8..i * 8 + 8)?;
-            *slot = f64::from_be_bytes(b.try_into().ok()?);
+            *slot = be_f64(otda, i * 8)?;
         }
         Some(Orientation {
             degrees,
@@ -227,8 +227,7 @@ impl<'f, 'a> Layer<'f, 'a> {
                     .filter(|c| c.is(b"otda"))
                     .map(|c| {
                         let b = c.bytes()?;
-                        let at = |i: usize| b.get(i * 8..i * 8 + 8).and_then(|s| s.try_into().ok()).map(f64::from_be_bytes);
-                        Some([at(0)?, at(1)?, at(2)?])
+                        Some([be_f64(b, 0)?, be_f64(b, 8)?, be_f64(b, 16)?])
                     })
                     .collect()
             })
diff --git a/crates/aep/src/container/write.rs b/crates/aep/src/container/write.rs
index 3ccab50a4..38410c080 100644
--- a/crates/aep/src/container/write.rs
+++ b/crates/aep/src/container/write.rs
@@ -17,6 +17,15 @@ const MAX_WRITE_DEPTH: usize = 256;
 /// [`AepError::TooDeep`] for an absurdly deep hand-built tree.
 pub fn write(file: &AepFile<'_>) -> Result<Vec<u8>, AepError> {
     let mut out = Vec::new();
+    // Sized once to the exact output when the tree fits a container (a tree that does not fails
+    // below anyway). `try_reserve` so a hand-built tree that repeats one large borrowed body many
+    // times cannot abort on the allocation; the writer then grows as it goes, as before.
+    if let Some(len) = sequence_len(&file.chunks, 1)
+        && u32::try_from(len.saturating_add(4)).is_ok()
+        && let Some(total) = len.checked_add(12).and_then(|n| n.checked_add(file.trailer.len()))
+    {
+        let _ = out.try_reserve_exact(total);
+    }
     out.extend_from_slice(b"RIFX");
     out.extend_from_slice(&[0; 4]);
     out.extend_from_slice(b"Egg!");
@@ -56,6 +65,28 @@ fn write_sequence(out: &mut Vec<u8>, chunks: &[Chunk<'_>], depth: usize) -> Resu
     Ok(())
 }
 
+/// The number of bytes [`write_sequence`] produces for `chunks`; `None` past the depth limit or
+/// on overflow (both make the write fail).
+fn sequence_len(chunks: &[Chunk<'_>], depth: usize) -> Option<usize> {
+    if depth > MAX_WRITE_DEPTH {
+        return None;
+    }
+    let count = chunks.len();
+    let mut total = 0usize;
+    for (i, chunk) in chunks.iter().enumerate() {
+        let body = match &chunk.body {
+            Body::Data(d) => d.len(),
+            Body::Chunks(c) => sequence_len(c, depth + 1)?,
+            Body::List { children, .. } => sequence_len(children, depth + 1)?.checked_add(4)?,
+            Body::OpaqueList { data, .. } => data.len().checked_add(4)?,
+        };
+        // The same pad rule as `write_chunk`.
+        let pad = usize::from(body % 2 == 1 && (chunk.pad.is_some() || i + 1 != count));
+        total = total.checked_add(8)?.checked_add(body)?.checked_add(pad)?;
+    }
+    Some(total)
+}
+
 fn write_chunk(out: &mut Vec<u8>, chunk: &Chunk<'_>, is_last: bool, depth: usize) -> Result<(), AepError> {
     out.extend_from_slice(&chunk.id);
     let size_at = out.len();
@@ -84,3 +115,46 @@ fn write_chunk(out: &mut Vec<u8>, chunk: &Chunk<'_>, is_last: bool, depth: usize
     }
     Ok(())
 }
+
+#[cfg(test)]
+mod tests {
+    use std::borrow::Cow;
+
+    use super::*;
+
+    #[test]
+    fn the_output_is_sized_once_to_its_exact_length() {
+        let odd = |n: u8| Chunk::data(*b"cdat", vec![n; usize::from(n)]);
+        let mut padded = odd(3);
+        padded.pad = Some(0x7f);
+        let trees = [
+            AepFile { chunks: Vec::new(), trailer: Cow::Borrowed(&[]) },
+            AepFile {
+                chunks: vec![
+                    odd(1),
+                    Chunk::list(*b"Fold", vec![odd(2), odd(3), Chunk::list(*b"tdgp", vec![odd(5)])]),
+                    Chunk { id: *b"LIST", body: Body::OpaqueList { list_type: *b"btdk", data: Cow::Owned(vec![1, 2, 3]) }, pad: None },
+                    Chunk { id: *b"tdmn", body: Body::Chunks(vec![odd(7), padded]), pad: None },
+                    odd(9),
+                ],
+                trailer: Cow::Borrowed(b"<x:xmpmeta/>"),
+            },
+        ];
+        for file in &trees {
+            let out = write(file).expect("write");
+            assert_eq!(sequence_len(&file.chunks, 1).map(|n| n + 12 + file.trailer.len()), Some(out.len()));
+            assert_eq!(out.capacity(), out.len(), "the output grew past its size");
+        }
+    }
+
+    #[test]
+    fn a_tree_past_the_depth_limit_has_no_size() {
+        let mut deep = Chunk::data(*b"cdat", vec![0]);
+        for _ in 0..=MAX_WRITE_DEPTH {
+            deep = Chunk::list(*b"tdgp", vec![deep]);
+        }
+        let file = AepFile { chunks: vec![deep], trailer: Cow::Borrowed(&[]) };
+        assert_eq!(sequence_len(&file.chunks, 1), None);
+        assert_eq!(write(&file), Err(AepError::TooDeep));
+    }
+}

From efa0c94d2bc9591b20be6a24f293ab9a89fddae7 Mon Sep 17 00:00:00 2001
From: vangel76 <vangel1976@googlemail.com>
Date: Sun, 8 Nov 2026 03:24:05 +0100
Subject: [PATCH 04/30] aep container: review fixes (#3275)

- read.rs: reserve with try_reserve_exact, so a raised chunk limit on a
  small target cannot abort before parsing; the capped reservation and a
  deep, retry-heavy nest of broken lists are pinned by tests.
- write.rs: a tree past the 32-bit container size fails with TooLarge
  before anything is serialised.
- aepx.rs: drop an unneeded local and lifetime annotation.
---
 crates/aep/src/container/aepx.rs  |  7 ++--
 crates/aep/src/container/read.rs  | 64 +++++++++++++++++++++++++++++--
 crates/aep/src/container/write.rs | 32 ++++++++++++----
 3 files changed, 87 insertions(+), 16 deletions(-)

diff --git a/crates/aep/src/container/aepx.rs b/crates/aep/src/container/aepx.rs
index db78797ef..21c30ae8b 100644
--- a/crates/aep/src/container/aepx.rs
+++ b/crates/aep/src/container/aepx.rs
@@ -122,7 +122,7 @@ struct Reader<'d> {
     trailer: Option<Vec<u8>>,
 }
 
-impl<'d> Reader<'d> {
+impl Reader<'_> {
     fn run(mut self) -> Result<AepFile<'static>, AepError> {
         if self.data.starts_with(&[0xef, 0xbb, 0xbf]) {
             self.pos = 3;
@@ -227,8 +227,7 @@ impl<'d> Reader<'d> {
         let at = self.pos;
         self.pos = self.pos.saturating_add(1);
         let name = self.name()?;
-        let data = self.data;
-        let mut attrs: Vec<((usize, usize), Cow<'d, [u8]>)> = Vec::new();
+        let mut attrs = Vec::new();
         let self_closing = loop {
             self.skip_ws();
             let rest = self.rest();
@@ -256,7 +255,7 @@ impl<'d> Reader<'d> {
             }
             let vstart = self.pos.saturating_add(1);
             let vend = self.find(vstart, &[quote]).ok_or(xml(vstart, "an attribute value is not closed"))?;
-            let raw = data.get(vstart..vend).unwrap_or(&[]);
+            let raw = self.data.get(vstart..vend).unwrap_or(&[]);
             if raw.contains(&b'<') {
                 return Err(xml(vstart, "`<` inside an attribute value"));
             }
diff --git a/crates/aep/src/container/read.rs b/crates/aep/src/container/read.rs
index 596404d15..8c43d9314 100644
--- a/crates/aep/src/container/read.rs
+++ b/crates/aep/src/container/read.rs
@@ -70,10 +70,10 @@ struct Parser<'a> {
 impl<'a> Parser<'a> {
     /// Parses the sibling chunks that exactly fill `start..end`.
     fn sequence(&mut self, start: usize, end: usize, depth: usize) -> Result<Vec<Chunk<'a>>, AepError> {
-        // Sized once: a well-formed sequence fills exactly this many slots. The count is bounded by
-        // the input (one per 8 bytes at most) and by the chunks the limit still allows.
-        let capacity = self.count_siblings(start, end).min(self.limits.max_chunks.saturating_sub(self.count));
-        let mut out = Vec::with_capacity(capacity);
+        // Sized once: a well-formed sequence fills exactly this many slots. `try_reserve` so a
+        // limit raised past what the target can allocate fails nothing here (the Vec then grows).
+        let mut out = Vec::new();
+        let _ = out.try_reserve_exact(self.capacity_for(start, end));
         let mut pos = start;
         while pos < end {
             let short = AepError::Malformed { offset: pos, what: "bytes left over that are too short for a chunk header" };
@@ -102,6 +102,12 @@ impl<'a> Parser<'a> {
         Ok(out)
     }
 
+    /// The slots to reserve for the sequence `start..end`: its header count, bounded by the input
+    /// (one per 8 bytes at most) and by the chunks the limit still allows.
+    fn capacity_for(&self, start: usize, end: usize) -> usize {
+        self.count_siblings(start, end).min(self.limits.max_chunks.saturating_sub(self.count))
+    }
+
     /// The number of chunk headers that tile `start..end` the way [`Self::sequence`] walks them,
     /// stopping at the first that does not fit. Never more than `(end - start) / 8`.
     fn count_siblings(&self, start: usize, end: usize) -> usize {
@@ -182,6 +188,8 @@ mod tests {
         let mut vecs = vec![&parsed.chunks];
         child_vecs(&parsed.chunks, &mut vecs);
         assert_eq!(vecs.len(), 11);
+        // `try_reserve_exact` gives exactly the requested capacity with std's allocator today; a
+        // Vec grown push by push would have rounded up to a power of two (37 -> 64, 9 -> 16).
         for v in vecs {
             assert_eq!(v.capacity(), v.len(), "a sibling Vec grew past its length");
         }
@@ -208,5 +216,53 @@ mod tests {
         // Under a tighter limit the parse fails as before, without sizing for more than allowed.
         let tight = Limits { max_depth: 64, max_chunks: 10 };
         assert_eq!(parse_with_limits(&data, tight), Err(AepError::TooManyChunks));
+        // The reservation never exceeds what the chunk limit still allows.
+        let mut parser = Parser { data: &data, limits: tight, count: 0 };
+        assert_eq!(parser.capacity_for(12, data.len()), 10);
+        parser.count = 7;
+        assert_eq!(parser.capacity_for(12, data.len()), 3);
+        parser.count = 11;
+        assert_eq!(parser.capacity_for(12, data.len()), 0);
+        let parser = Parser { data: &data, limits: Limits::default(), count: 0 };
+        assert_eq!(parser.capacity_for(12, data.len()), 1000);
+    }
+
+    /// `LIST Fold` around `inner`, followed by 6 bytes too short for a header, so the list's
+    /// sequence fails and the list is kept opaque.
+    fn broken_level(inner: &[u8]) -> Vec<u8> {
+        let mut body = b"Fold".to_vec();
+        body.extend_from_slice(inner);
+        body.extend_from_slice(&[0xee; 6]);
+        let mut out = b"LIST".to_vec();
+        out.extend_from_slice(&u32::try_from(body.len()).expect("small").to_be_bytes());
+        out.extend_from_slice(&body);
+        out
+    }
+
+    #[test]
+    fn nested_lists_with_broken_tails_parse_each_header_once() {
+        // A wide, well-formed list at the bottom, then 50 levels that each fail and fall back to
+        // opaque: every level re-parses its child before giving up.
+        let mut wide = b"Fold".to_vec();
+        wide.extend(std::iter::repeat_n(*b"abcd\0\0\0\0", 1000).flatten());
+        let mut level = b"LIST".to_vec();
+        level.extend_from_slice(&u32::try_from(wide.len()).expect("small").to_be_bytes());
+        level.extend_from_slice(&wide);
+        for _ in 0..50 {
+            level = broken_level(&level);
+        }
+        let mut data = b"RIFX\0\0\0\0Egg!".to_vec();
+        data.extend_from_slice(&level);
+        let declared = u32::try_from(data.len() - 8).expect("small");
+        data[4..8].copy_from_slice(&declared.to_be_bytes());
+        // 1 + 50 + 1000 headers in the file: the parse counts each exactly once (the count spans
+        // every attempt), so the work stays linear in the input.
+        let headers = 1 + 50 + 1000;
+        let f = parse_with_limits(&data, Limits { max_depth: 64, max_chunks: headers }).expect("parse");
+        assert_eq!(parse_with_limits(&data, Limits { max_depth: 64, max_chunks: headers - 1 }), Err(AepError::TooManyChunks));
+        // The outermost list keeps its bytes, and the file writes back unchanged.
+        let [top] = f.chunks.as_slice() else { panic!("one top-level chunk") };
+        assert!(matches!(&top.body, Body::OpaqueList { list_type, data } if list_type == b"Fold" && data.len() + 12 == level.len()));
+        assert_eq!(crate::container::write(&f).expect("write"), data);
     }
 }
diff --git a/crates/aep/src/container/write.rs b/crates/aep/src/container/write.rs
index 38410c080..35a5b6276 100644
--- a/crates/aep/src/container/write.rs
+++ b/crates/aep/src/container/write.rs
@@ -17,14 +17,17 @@ const MAX_WRITE_DEPTH: usize = 256;
 /// [`AepError::TooDeep`] for an absurdly deep hand-built tree.
 pub fn write(file: &AepFile<'_>) -> Result<Vec<u8>, AepError> {
     let mut out = Vec::new();
-    // Sized once to the exact output when the tree fits a container (a tree that does not fails
-    // below anyway). `try_reserve` so a hand-built tree that repeats one large borrowed body many
-    // times cannot abort on the allocation; the writer then grows as it goes, as before.
-    if let Some(len) = sequence_len(&file.chunks, 1)
-        && u32::try_from(len.saturating_add(4)).is_ok()
-        && let Some(total) = len.checked_add(12).and_then(|n| n.checked_add(file.trailer.len()))
-    {
-        let _ = out.try_reserve_exact(total);
+    // Sized once to the exact output. A tree past the 32-bit container size fails at once (the
+    // same error the write below would give after serialising it). `try_reserve` so a hand-built
+    // tree that repeats one large borrowed body many times cannot abort on the allocation; the
+    // writer then grows as it goes, as before.
+    if let Some(len) = sequence_len(&file.chunks, 1) {
+        if u32::try_from(len.saturating_add(4)).is_err() {
+            return Err(AepError::TooLarge);
+        }
+        if let Some(total) = len.checked_add(12).and_then(|n| n.checked_add(file.trailer.len())) {
+            let _ = out.try_reserve_exact(total);
+        }
     }
     out.extend_from_slice(b"RIFX");
     out.extend_from_slice(&[0; 4]);
@@ -143,10 +146,23 @@ mod tests {
         for file in &trees {
             let out = write(file).expect("write");
             assert_eq!(sequence_len(&file.chunks, 1).map(|n| n + 12 + file.trailer.len()), Some(out.len()));
+            // Exact with std's allocator today; grown push by push it would be rounded up.
             assert_eq!(out.capacity(), out.len(), "the output grew past its size");
         }
     }
 
+    #[cfg(target_pointer_width = "64")]
+    #[test]
+    fn a_tree_past_the_container_size_fails_before_serialising() {
+        // 4097 chunks borrowing one 1 MiB body: over 4 GiB of output, none of it written.
+        let body = vec![0u8; 1 << 20];
+        let chunks: Vec<Chunk<'_>> = (0..4097).map(|_| Chunk::data(*b"cdat", &body[..])).collect();
+        let file = AepFile { chunks, trailer: Cow::Borrowed(&[]) };
+        assert_eq!(write(&file), Err(AepError::TooLarge));
+        // Just under the limit still sizes, and fails nothing up front.
+        assert!(sequence_len(&file.chunks[..4000], 1).is_some_and(|n| u32::try_from(n + 4).is_ok()));
+    }
+
     #[test]
     fn a_tree_past_the_depth_limit_has_no_size() {
         let mut deep = Chunk::data(*b"cdat", vec![0]);

From cdb81c06ec5a46a9ace0b3c4b6cbbcd1c9e3f878 Mon Sep 17 00:00:00 2001
From: vangel76 <vangel1976@googlemail.com>
Date: Sun, 8 Nov 2026 03:26:16 +0100
Subject: [PATCH 05/30] aep export: note what the concurrency test covers and
 why a failed template build is not kept (#3277)

---
 crates/aep/src/export/emit.rs     | 6 ++++--
 crates/aep/src/export/template.rs | 1 +
 2 files changed, 5 insertions(+), 2 deletions(-)

diff --git a/crates/aep/src/export/emit.rs b/crates/aep/src/export/emit.rs
index 0f49f995f..25d69d7bb 100644
--- a/crates/aep/src/export/emit.rs
+++ b/crates/aep/src/export/emit.rs
@@ -930,8 +930,10 @@ mod tests {
         }
     }
 
-    /// Exports running at the same time on several threads, the first of them possibly building
-    /// the shared template, all give the single-threaded bytes.
+    /// Exports running at the same time on several threads all give the single-threaded bytes.
+    /// This checks concurrent exports from a template that is already built: other tests in this
+    /// binary usually fill the shared template first, so the race on the first build is not
+    /// reliably exercised here (the `static OnceLock` makes that race safe by construction).
     #[test]
     fn concurrent_exports_give_the_same_bytes() {
         let plans: Vec<ProjectPlan> = ["", " x", " y", " z"].iter().map(|t| plan_of(&varied(t))).collect();
diff --git a/crates/aep/src/export/template.rs b/crates/aep/src/export/template.rs
index 608fa75e1..f26be4c84 100644
--- a/crates/aep/src/export/template.rs
+++ b/crates/aep/src/export/template.rs
@@ -94,6 +94,7 @@ pub(crate) fn shared() -> R<&'static Template> {
     if let Some(t) = SHARED.get() {
         return Ok(t);
     }
+    // A failed build returns here, before `get_or_init`, so it is never kept.
     let t = Template::load()?;
     Ok(SHARED.get_or_init(|| t))
 }

From 32c79babc81b41bcdbc94ac2c4c79cfb7174b38e Mon Sep 17 00:00:00 2001
From: vangel76 <vangel1976@googlemail.com>
Date: Sun, 8 Nov 2026 03:27:12 +0100
Subject: [PATCH 06/30] aep: text documents are read without a String per
 token, defaults built once (#3276)

TextDocument::parse reads a borrowed tree: names, bare words and strings without
escapes point into the body, keys are borrowed when they are /names, numbers parse from
the borrowed bytes, and dictionaries and arrays are moved into vectors of their exact size
when they close. The style and paragraph defaults are built once instead of per document.
parse_text_dict keeps its public TextValue result (the borrowed tree turned owned).

The old owning parser stays as a test-only oracle: a differential test compares both on
40 000 generated bodies (every key form the owned keys canonicalise, non-UTF-8 names,
escapes, unclosed strings, non-finite numbers), every cut of a realistic document and
nesting around the depth limit.
---
 crates/aep/src/container/textdoc.rs | 822 +++++++++++++++++++++++-----
 1 file changed, 691 insertions(+), 131 deletions(-)

diff --git a/crates/aep/src/container/textdoc.rs b/crates/aep/src/container/textdoc.rs
index 51b15d7df..dc386611f 100644
--- a/crates/aep/src/container/textdoc.rs
+++ b/crates/aep/src/container/textdoc.rs
@@ -5,6 +5,9 @@
 //! as `(` + BOM `fe ff` + UTF-16BE + `)` with `\` escapes. [`parse_text_dict`] reads it (depth
 //! limited, never panics) and [`Layer::text_document`] pulls out the verified fields.
 
+use std::borrow::Cow;
+use std::sync::LazyLock;
+
 use crate::container::Chunk;
 use crate::container::bytes::{be_u32, text};
 use crate::container::typed::{Comp, Layer, Property};
@@ -73,15 +76,99 @@ impl TextValue {
             _ => None,
         }
     }
+}
 
-    fn key_text(&self) -> String {
+/// The text of a key the way the dictionary stores it: a `/name` as written, any other value in
+/// its canonical form (`06` and `+6` are `6`, `1.0` is `1`, a string its decoded text).
+fn owned_key(value: &V<'_>) -> String {
+    match value {
+        V::Name(s) | V::Token(s) => text(s),
+        V::Str(utf16) => decode_utf16be(utf16),
+        V::Int(i) => i.to_string(),
+        V::Float(f) => f.to_string(),
+        V::Bool(b) => b.to_string(),
+        V::Bytes(b) => text(b),
+        V::Dict(_) | V::Array(_) => String::new(),
+    }
+}
+
+/// A value of the text dictionary as [`TextDocument::parse`] reads it: it borrows names, bare
+/// words and strings from the body, so a document is read without a `String` per token. A key is
+/// borrowed when it is a `/name` (every key After Effects writes); its text is the same as the
+/// [`TextValue`] key's. [`V::into_owned`] gives the public [`TextValue`].
+#[derive(Debug, Clone)]
+enum V<'b> {
+    Dict(Vec<(Cow<'b, str>, V<'b>)>),
+    Array(Vec<V<'b>>),
+    /// A string that started with the byte order mark: the UTF-16BE bytes after it, unescaped.
+    Str(Cow<'b, [u8]>),
+    Bytes(Cow<'b, [u8]>),
+    Name(&'b [u8]),
+    Int(i64),
+    Float(f64),
+    Bool(bool),
+    Token(&'b [u8]),
+}
+
+impl<'b> V<'b> {
+    /// The value of a dictionary key (the last one when a key repeats).
+    fn get(&self, key: &str) -> Option<&V<'b>> {
         match self {
-            Self::Name(s) | Self::Str(s) | Self::Token(s) => s.clone(),
-            Self::Int(i) => i.to_string(),
-            Self::Float(f) => f.to_string(),
-            Self::Bool(b) => b.to_string(),
-            Self::Bytes(b) => text(b),
-            Self::Dict(_) | Self::Array(_) => String::new(),
+            Self::Dict(pairs) => pairs.iter().rev().find(|(k, _)| k == key).map(|(_, v)| v),
+            _ => None,
+        }
+    }
+
+    fn at(&self, index: usize) -> Option<&V<'b>> {
+        match self {
+            Self::Array(items) => items.get(index),
+            _ => None,
+        }
+    }
+
+    /// The decoded text of a string value.
+    fn string(&self) -> Option<String> {
+        match self {
+            Self::Str(utf16) => Some(decode_utf16be(utf16)),
+            _ => None,
+        }
+    }
+
+    fn as_f64(&self) -> Option<f64> {
+        match self {
+            Self::Int(i) => Some(*i as f64),
+            Self::Float(f) => Some(*f),
+            _ => None,
+        }
+    }
+
+    fn as_i64(&self) -> Option<i64> {
+        match self {
+            Self::Int(i) => Some(*i),
+            _ => None,
+        }
+    }
+
+    /// The key a value makes when it is written in a key position.
+    fn into_key(self) -> Cow<'b, str> {
+        match self {
+            Self::Name(s) => String::from_utf8_lossy(s),
+            other => Cow::Owned(owned_key(&other)),
+        }
+    }
+
+    /// The public form. Recursion is bounded: a parsed value nests at most [`MAX_DEPTH`] + 1 deep.
+    fn into_owned(self) -> TextValue {
+        match self {
+            Self::Dict(pairs) => TextValue::Dict(pairs.into_iter().map(|(k, v)| (k.into_owned(), v.into_owned())).collect()),
+            Self::Array(items) => TextValue::Array(items.into_iter().map(V::into_owned).collect()),
+            Self::Str(utf16) => TextValue::Str(decode_utf16be(&utf16)),
+            Self::Bytes(b) => TextValue::Bytes(b.into_owned()),
+            Self::Name(s) => TextValue::Name(text(s)),
+            Self::Int(i) => TextValue::Int(i),
+            Self::Float(f) => TextValue::Float(f),
+            Self::Bool(b) => TextValue::Bool(b),
+            Self::Token(s) => TextValue::Token(text(s)),
         }
     }
 }
@@ -89,6 +176,12 @@ impl TextValue {
 struct Parser<'b> {
     b: &'b [u8],
     i: usize,
+    /// The pairs of the dictionaries being read, innermost last: a dictionary's pairs are moved
+    /// into a vector of their exact size when it closes (one allocation per dictionary instead of
+    /// one per doubling).
+    pairs: Vec<(Cow<'b, str>, V<'b>)>,
+    /// The same for the items of arrays.
+    items: Vec<V<'b>>,
 }
 
 fn is_ws(c: u8) -> bool {
@@ -99,7 +192,7 @@ fn is_delimiter(c: u8) -> bool {
     is_ws(c) || matches!(c, b'/' | b'[' | b']' | b'<' | b'>' | b'(' | b')')
 }
 
-impl Parser<'_> {
+impl<'b> Parser<'b> {
     fn peek(&self) -> Option<u8> {
         self.b.get(self.i).copied()
     }
@@ -114,7 +207,7 @@ impl Parser<'_> {
         self.b.get(self.i..).is_some_and(|rest| rest.starts_with(s))
     }
 
-    fn word(&mut self) -> &[u8] {
+    fn word(&mut self) -> &'b [u8] {
         let start = self.i;
         while self.peek().is_some_and(|c| !is_delimiter(c)) {
             self.i = self.i.saturating_add(1);
@@ -122,79 +215,104 @@ impl Parser<'_> {
         self.b.get(start..self.i).unwrap_or(&[])
     }
 
-    fn parse(&mut self, depth: usize) -> Option<TextValue> {
+    /// The body of a `( ... )` string after the `(`, with `\` escapes resolved: borrowed when it
+    /// has none. `None` when the string or an escape is not closed.
+    fn string_body(&mut self) -> Option<Cow<'b, [u8]>> {
+        let rest = self.b.get(self.i..)?;
+        let stop = rest.iter().position(|c| matches!(c, b')' | b'\\'))?;
+        let head = rest.get(..stop)?;
+        self.i = self.i.saturating_add(stop);
+        if self.peek()? == b')' {
+            self.i = self.i.saturating_add(1);
+            return Some(Cow::Borrowed(head));
+        }
+        let mut out = head.to_vec();
+        loop {
+            let c = self.peek()?;
+            if c == b'\\' {
+                out.push(*self.b.get(self.i.saturating_add(1))?);
+                self.i = self.i.saturating_add(2);
+            } else if c == b')' {
+                self.i = self.i.saturating_add(1);
+                return Some(Cow::Owned(out));
+            } else {
+                out.push(c);
+                self.i = self.i.saturating_add(1);
+            }
+        }
+    }
+
+    fn parse(&mut self, depth: usize) -> Option<V<'b>> {
         self.skip_ws();
         if depth > MAX_DEPTH {
             return None;
         }
         if self.starts_with(b"<<") {
             self.i = self.i.saturating_add(2);
-            let mut pairs = Vec::new();
+            // On an error the pairs read so far stay on the stack: the error ends the whole parse.
+            let mark = self.pairs.len();
             loop {
                 self.skip_ws();
                 if self.starts_with(b">>") {
                     self.i = self.i.saturating_add(2);
-                    return Some(TextValue::Dict(pairs));
+                    return Some(V::Dict(self.pairs.drain(mark..).collect()));
                 }
                 let key = self.parse(depth.saturating_add(1))?;
                 let value = self.parse(depth.saturating_add(1))?;
-                pairs.push((key.key_text(), value));
+                self.pairs.push((key.into_key(), value));
             }
         }
         match self.peek()? {
             b'[' => {
                 self.i = self.i.saturating_add(1);
-                let mut items = Vec::new();
+                let mark = self.items.len();
                 loop {
                     self.skip_ws();
                     if self.peek()? == b']' {
                         self.i = self.i.saturating_add(1);
-                        return Some(TextValue::Array(items));
+                        return Some(V::Array(self.items.drain(mark..).collect()));
                     }
-                    items.push(self.parse(depth.saturating_add(1))?);
+                    let item = self.parse(depth.saturating_add(1))?;
+                    self.items.push(item);
                 }
             }
             b'(' => {
                 self.i = self.i.saturating_add(1);
-                let mut out = Vec::new();
-                loop {
-                    let c = self.peek()?;
-                    if c == b'\\' {
-                        out.push(*self.b.get(self.i.saturating_add(1))?);
-                        self.i = self.i.saturating_add(2);
-                    } else if c == b')' {
-                        self.i = self.i.saturating_add(1);
-                        break;
-                    } else {
-                        out.push(c);
-                        self.i = self.i.saturating_add(1);
-                    }
-                }
-                Some(match out.strip_prefix(&[0xfe, 0xff]) {
-                    Some(utf16) => TextValue::Str(decode_utf16be(utf16)),
-                    None => TextValue::Bytes(out),
+                let body = self.string_body()?;
+                Some(if body.starts_with(&[0xfe, 0xff]) {
+                    V::Str(match body {
+                        Cow::Borrowed(b) => Cow::Borrowed(b.get(2..).unwrap_or(&[])),
+                        Cow::Owned(mut v) => {
+                            v.drain(..2);
+                            Cow::Owned(v)
+                        }
+                    })
+                } else {
+                    V::Bytes(body)
                 })
             }
             b'/' => {
                 self.i = self.i.saturating_add(1);
-                Some(TextValue::Name(text(self.word())))
+                Some(V::Name(self.word()))
             }
             _ => {
                 let word = self.word();
                 if word.is_empty() {
                     return None;
                 }
-                let w = text(word);
-                Some(match w.as_str() {
-                    "true" => TextValue::Bool(true),
-                    "false" => TextValue::Bool(false),
+                // A word that is not UTF-8 reads as text with replacement characters, which is
+                // neither a boolean nor a number: a token.
+                let Ok(w) = std::str::from_utf8(word) else { return Some(V::Token(word)) };
+                Some(match w {
+                    "true" => V::Bool(true),
+                    "false" => V::Bool(false),
                     _ => match w.parse::<i64>() {
-                        Ok(i) => TextValue::Int(i),
+                        Ok(i) => V::Int(i),
                         // `parse` also takes `nan`, `inf` and overflowing exponents; those are not
                         // numbers a text document holds, so they stay tokens and read as missing.
                         Err(_) => match w.parse::<f64>() {
-                            Ok(f) if f.is_finite() => TextValue::Float(f),
-                            _ => TextValue::Token(w),
+                            Ok(f) if f.is_finite() => V::Float(f),
+                            _ => V::Token(word),
                         },
                     },
                 })
@@ -213,11 +331,9 @@ fn decode_utf16be(bytes: &[u8]) -> String {
     s
 }
 
-/// Parses the body of a `btdk` list into its top-level `key value` pairs (as a [`TextValue::Dict`]).
-/// Parsing stops silently at the first syntax error or at nesting deeper than 64 levels; what was
-/// read before is returned.
-pub fn parse_text_dict(body: &[u8]) -> TextValue {
-    let mut parser = Parser { b: body, i: 0 };
+/// The top-level `key value` pairs of a `btdk` body, borrowed (see [`parse_text_dict`]).
+fn parse_dict(body: &[u8]) -> V<'_> {
+    let mut parser = Parser { b: body, i: 0, pairs: Vec::new(), items: Vec::new() };
     let mut pairs = Vec::new();
     loop {
         parser.skip_ws();
@@ -226,13 +342,20 @@ pub fn parse_text_dict(body: &[u8]) -> TextValue {
         }
         let Some(key) = parser.parse(0) else { break };
         let Some(value) = parser.parse(0) else { break };
-        pairs.push((key.key_text(), value));
+        pairs.push((key.into_key(), value));
     }
-    TextValue::Dict(pairs)
+    V::Dict(pairs)
+}
+
+/// Parses the body of a `btdk` list into its top-level `key value` pairs (as a [`TextValue::Dict`]).
+/// Parsing stops silently at the first syntax error or at nesting deeper than 64 levels; what was
+/// read before is returned.
+pub fn parse_text_dict(body: &[u8]) -> TextValue {
+    parse_dict(body).into_owned()
 }
 
 /// The run style slots (`RUN/6/0[n]/0/0/6/<slot>`) that are decoded; every other slot is compared
-/// with its default (`style_defaults`) and listed in
+/// with its default (`STYLE_DEFAULTS`) and listed in
 /// [`TextDocument::undecoded_style_fields`] when it differs.
 pub const DECODED_STYLE_SLOTS: &[&str] =
     &["0", "1", "2", "3", "4", "5", "6", "7", "8", "9", "11", "12", "13", "18", "35", "36", "52", "53", "54", "56", "57", "58", "62", "63", "70"];
@@ -241,24 +364,25 @@ pub const DECODED_STYLE_SLOTS: &[&str] =
 pub const DECODED_PARAGRAPH_SLOTS: &[&str] = &["0", "1", "2", "3", "4", "5", "8", "9", "21", "29", "33"];
 
 /// A number slot.
-fn val(v: f64) -> TextValue {
-    TextValue::Float(v)
+fn val(v: f64) -> V<'static> {
+    V::Float(v)
 }
 
-fn dict(pairs: Vec<(&str, TextValue)>) -> TextValue {
-    TextValue::Dict(pairs.into_iter().map(|(k, v)| (k.to_string(), v)).collect())
+fn dict(pairs: Vec<(&'static str, V<'static>)>) -> V<'static> {
+    V::Dict(pairs.into_iter().map(|(k, v)| (Cow::Borrowed(k), v)).collect())
 }
 
-fn numbers(v: &[f64]) -> TextValue {
-    TextValue::Array(v.iter().map(|x| val(*x)).collect())
+fn numbers(v: &[f64]) -> V<'static> {
+    V::Array(v.iter().map(|x| val(*x)).collect())
 }
 
 /// The default of every run style slot that is not decoded and not neutral (zero, `false`,
 /// empty, `/nil`): the value an untouched point text holds in every sample (110, 243-245). A slot
 /// with a neutral default is left out; [`undecoded_fields`] treats a missing default as neutral.
-fn style_defaults() -> TextValue {
-    let paint = |a: f64| dict(vec![("99", TextValue::Name("SimplePaint".into())), ("0", dict(vec![("0", val(1.0)), ("1", numbers(&[1.0, 1.0, 1.0, a]))]))]);
-    let class = |name: &str| dict(vec![("99", TextValue::Name(name.into()))]);
+/// Built once.
+static STYLE_DEFAULTS: LazyLock<V<'static>> = LazyLock::new(|| {
+    let paint = |a: f64| dict(vec![("99", V::Name(b"SimplePaint")), ("0", dict(vec![("0", val(1.0)), ("1", numbers(&[1.0, 1.0, 1.0, a]))]))]);
+    let class = |name: &'static [u8]| dict(vec![("99", V::Name(name))]);
     dict(vec![
         ("37", val(2.0)),
         ("41", val(2.0)),
@@ -268,24 +392,24 @@ fn style_defaults() -> TextValue {
         ("46", val(7.0)),
         ("49", val(-1.0)),
         ("50", val(-1.0)),
-        ("55", class("SimpleBlender")),
+        ("55", class(b"SimpleBlender")),
         ("64", val(4.0)),
         ("71", val(4.0)),
-        ("77", TextValue::Bool(true)),
-        ("78", TextValue::Bool(true)),
+        ("77", V::Bool(true)),
+        ("78", V::Bool(true)),
         ("79", paint(0.0)),
         ("82", val(3.0)),
         ("83", val(3.0)),
-        ("86", class("SimpleCustomFeature")),
+        ("86", class(b"SimpleCustomFeature")),
         ("87", val(100.0)),
-        ("88", TextValue::Bool(true)),
+        ("88", V::Bool(true)),
         ("95", dict(vec![("0", val(0.0)), ("1", val(0.0))])),
-        ("96", TextValue::Bool(true)),
+        ("96", V::Bool(true)),
     ])
-}
+});
 
-/// The same for the paragraph slots (110, 243-245).
-fn paragraph_defaults() -> TextValue {
+/// The same for the paragraph slots (110, 243-245). Built once.
+static PARAGRAPH_DEFAULTS: LazyLock<V<'static>> = LazyLock::new(|| {
     dict(vec![
         ("6", val(1.0)),
         ("7", val(1.2)),
@@ -293,30 +417,35 @@ fn paragraph_defaults() -> TextValue {
         ("11", val(2.0)),
         ("12", val(2.0)),
         ("14", val(36.0)),
-        ("15", TextValue::Bool(true)),
+        ("15", V::Bool(true)),
         ("16", val(0.5)),
         ("17", numbers(&[0.8, 1.0, 1.33])),
         ("18", numbers(&[0.0, 0.0, 0.0])),
         ("19", numbers(&[1.0, 1.0, 1.0])),
         ("20", val(6.0)),
         ("22", val(1.0)),
-        ("23", TextValue::Bool(true)),
+        ("23", V::Bool(true)),
         ("24", val(1.0)),
-        ("26", TextValue::Bool(true)),
+        ("26", V::Bool(true)),
         ("31", val(36.0)),
         ("35", val(1.0)),
         ("40", val(2.0)),
     ])
-}
+});
 
-/// Equal values; numbers compare by value (`0` equals `0.0`).
-fn same(a: &TextValue, b: &TextValue) -> bool {
+/// Equal values; numbers compare by value (`0` equals `0.0`), names and words by their text,
+/// strings by their decoded text.
+fn same(a: &V<'_>, b: &V<'_>) -> bool {
     match (a, b) {
-        (TextValue::Dict(x), TextValue::Dict(y)) => x.len() == y.len() && x.iter().all(|(k, v)| y.iter().any(|(k2, v2)| k == k2 && same(v, v2))),
-        (TextValue::Array(x), TextValue::Array(y)) => x.len() == y.len() && x.iter().zip(y).all(|(p, q)| same(p, q)),
+        (V::Dict(x), V::Dict(y)) => x.len() == y.len() && x.iter().all(|(k, v)| y.iter().any(|(k2, v2)| k == k2 && same(v, v2))),
+        (V::Array(x), V::Array(y)) => x.len() == y.len() && x.iter().zip(y).all(|(p, q)| same(p, q)),
+        (V::Str(x), V::Str(y)) => x == y || decode_utf16be(x) == decode_utf16be(y),
+        (V::Bytes(x), V::Bytes(y)) => x == y,
+        (V::Name(x), V::Name(y)) | (V::Token(x), V::Token(y)) => x == y || text(x) == text(y),
+        (V::Bool(x), V::Bool(y)) => x == y,
         _ => match (a.as_f64(), b.as_f64()) {
             (Some(p), Some(q)) => p == q,
-            _ => a == b,
+            _ => false,
         },
     }
 }
@@ -325,12 +454,12 @@ fn same(a: &TextValue, b: &TextValue) -> bool {
 /// listed when it holds something else (a neutral value carries nothing that could be lost).
 /// `/nil` is how an untouched document stores a slot without a value (244: paragraph `/27`, `/28`,
 /// `/36`).
-fn is_neutral(v: &TextValue) -> bool {
+fn is_neutral(v: &V<'_>) -> bool {
     match v {
-        TextValue::Name(n) => n == "nil",
-        TextValue::Bool(b) => !b,
-        TextValue::Array(a) => a.is_empty(),
-        TextValue::Dict(d) => d.is_empty(),
+        V::Name(n) => *n == b"nil",
+        V::Bool(b) => !b,
+        V::Array(a) => a.is_empty(),
+        V::Dict(d) => d.is_empty(),
         other => other.as_f64() == Some(0.0),
     }
 }
@@ -355,13 +484,13 @@ pub const MAX_UNDECODED_FIELDS: usize = 64;
 
 /// Adds to `out` the slots of `actual` that are not decoded and differ from `sampled`, each once
 /// and at most [`MAX_UNDECODED_FIELDS`] in all.
-fn undecoded_fields(actual: &TextValue, sampled: Option<&TextValue>, decoded: &[&str], neutral: &[(&str, &[i64])], out: &mut Vec<String>) {
-    let TextValue::Dict(pairs) = actual else { return };
+fn undecoded_fields(actual: &V<'_>, sampled: Option<&V<'_>>, decoded: &[&str], neutral: &[(&str, &[i64])], out: &mut Vec<String>) {
+    let V::Dict(pairs) = actual else { return };
     for (key, value) in pairs {
         if out.len() >= MAX_UNDECODED_FIELDS {
             return;
         }
-        if decoded.contains(&key.as_str()) || out.contains(key) {
+        if decoded.contains(&key.as_ref()) || out.iter().any(|o| o == key) {
             continue;
         }
         if neutral.iter().any(|(slot, values)| slot == key && value.as_i64().is_some_and(|v| values.contains(&v))) {
@@ -372,7 +501,7 @@ fn undecoded_fields(actual: &TextValue, sampled: Option<&TextValue>, decoded: &[
             None => !is_neutral(value),
         };
         if differs {
-            out.push(key.clone());
+            out.push(key.to_string());
         }
     }
 }
@@ -432,13 +561,13 @@ pub struct KernRun {
 
 /// The manual kerning list of a text run dictionary (`RUN/8/0`): entries `<< /0 << /0 amount >> /1
 /// length >>` (554 kerns each of `HHHH` by 50; the closing `\r` has an entry without an amount).
-fn kern_runs(run: &TextValue) -> Vec<KernRun> {
-    let Some(TextValue::Array(items)) = run.get("8").and_then(|v| v.get("0")) else { return Vec::new() };
+fn kern_runs(run: &V<'_>) -> Vec<KernRun> {
+    let Some(V::Array(items)) = run.get("8").and_then(|v| v.get("0")) else { return Vec::new() };
     let runs: Vec<KernRun> = items
         .iter()
         .filter_map(|e| {
             let length = e.get("1").and_then(usize_of)?;
-            let amount = e.get("0").and_then(|v| v.get("0")).and_then(TextValue::as_f64).filter(|v| v.is_finite());
+            let amount = e.get("0").and_then(|v| v.get("0")).and_then(V::as_f64).filter(|v| v.is_finite());
             Some(KernRun { length, amount })
         })
         .collect();
@@ -644,24 +773,24 @@ pub struct TextBox {
     pub height: f64,
 }
 
-fn colour_of(style: &TextValue, slot: &str) -> Option<[f64; 4]> {
+fn colour_of(style: &V<'_>, slot: &str) -> Option<[f64; 4]> {
     let c = style.get(slot)?.get("0")?.get("1")?;
     Some([c.at(0)?.as_f64()?, c.at(1)?.as_f64()?, c.at(2)?.as_f64()?, c.at(3)?.as_f64()?])
 }
 
-fn usize_of(v: &TextValue) -> Option<usize> {
+fn usize_of(v: &V<'_>) -> Option<usize> {
     usize::try_from(v.as_i64()?).ok()
 }
 
 /// A finite number slot of a style, `default` when it is missing or not a finite number.
-fn num(style: &TextValue, slot: &str, default: f64) -> f64 {
-    style.get(slot).and_then(TextValue::as_f64).filter(|v| v.is_finite()).unwrap_or(default)
+fn num(style: &V<'_>, slot: &str, default: f64) -> f64 {
+    style.get(slot).and_then(V::as_f64).filter(|v| v.is_finite()).unwrap_or(default)
 }
 
 /// A boolean slot of a style, `default` when it is missing or not a boolean.
-fn flag(style: &TextValue, slot: &str, default: bool) -> bool {
+fn flag(style: &V<'_>, slot: &str, default: bool) -> bool {
     match style.get(slot) {
-        Some(TextValue::Bool(b)) => *b,
+        Some(V::Bool(b)) => *b,
         _ => default,
     }
 }
@@ -675,9 +804,9 @@ struct RunNotes {
 }
 
 /// The paragraph runs of a text run dictionary (`RUN/5/0`).
-fn paragraph_runs(run: &TextValue, notes: &mut RunNotes) -> Vec<ParagraphRun> {
-    let Some(TextValue::Array(items)) = run.get("5").and_then(|v| v.get("0")) else { return Vec::new() };
-    let sampled = Some(paragraph_defaults());
+fn paragraph_runs(run: &V<'_>, notes: &mut RunNotes) -> Vec<ParagraphRun> {
+    let Some(V::Array(items)) = run.get("5").and_then(|v| v.get("0")) else { return Vec::new() };
+    let sampled = Some(&*PARAGRAPH_DEFAULTS);
     let mut out: Vec<ParagraphRun> = Vec::with_capacity(items.len());
     for e in items {
         let Some(length) = e.get("1").and_then(usize_of) else {
@@ -685,7 +814,7 @@ fn paragraph_runs(run: &TextValue, notes: &mut RunNotes) -> Vec<ParagraphRun> {
             continue;
         };
         let para = e.get("0").and_then(|v| v.get("0")).and_then(|v| v.get("5"));
-        let justification = match para.and_then(|p| p.get("0")).and_then(TextValue::as_i64) {
+        let justification = match para.and_then(|p| p.get("0")).and_then(V::as_i64) {
             Some(0) => Justification::Left,
             Some(1) => Justification::Right,
             Some(2) => Justification::Center,
@@ -700,12 +829,12 @@ fn paragraph_runs(run: &TextValue, notes: &mut RunNotes) -> Vec<ParagraphRun> {
             }
         };
         if let Some(p) = para {
-            undecoded_fields(p, sampled.as_ref(), DECODED_PARAGRAPH_SLOTS, NEUTRAL_PARAGRAPH_VALUES, &mut notes.paragraph_fields);
+            undecoded_fields(p, sampled, DECODED_PARAGRAPH_SLOTS, NEUTRAL_PARAGRAPH_VALUES, &mut notes.paragraph_fields);
         }
-        let num = |slot: &str| para.and_then(|p| p.get(slot)).and_then(TextValue::as_f64).filter(|v| v.is_finite()).unwrap_or(0.0);
-        let int = |slot: &str, default: i64| para.and_then(|p| p.get(slot)).and_then(TextValue::as_i64).unwrap_or(default);
+        let num = |slot: &str| para.and_then(|p| p.get(slot)).and_then(V::as_f64).filter(|v| v.is_finite()).unwrap_or(0.0);
+        let int = |slot: &str, default: i64| para.and_then(|p| p.get(slot)).and_then(V::as_i64).unwrap_or(default);
         let flag = |slot: &str, default: bool| match para.and_then(|p| p.get(slot)) {
-            Some(TextValue::Bool(b)) => *b,
+            Some(V::Bool(b)) => *b,
             _ => default,
         };
         out.push(ParagraphRun {
@@ -727,9 +856,9 @@ fn paragraph_runs(run: &TextValue, notes: &mut RunNotes) -> Vec<ParagraphRun> {
 }
 
 /// The style runs of a text run dictionary (`RUN/6/0`).
-fn style_runs(run: &TextValue, notes: &mut RunNotes) -> Vec<StyleRun> {
-    let Some(TextValue::Array(items)) = run.get("6").and_then(|v| v.get("0")) else { return Vec::new() };
-    let sampled = Some(style_defaults());
+fn style_runs(run: &V<'_>, notes: &mut RunNotes) -> Vec<StyleRun> {
+    let Some(V::Array(items)) = run.get("6").and_then(|v| v.get("0")) else { return Vec::new() };
+    let sampled = Some(&*STYLE_DEFAULTS);
     let mut out: Vec<StyleRun> = Vec::with_capacity(items.len());
     for e in items {
         let Some(length) = e.get("1").and_then(usize_of) else {
@@ -742,31 +871,31 @@ fn style_runs(run: &TextValue, notes: &mut RunNotes) -> Vec<StyleRun> {
             out.push(StyleRun { length, ..prev });
             continue;
         };
-        let font_size = style.get("1").and_then(TextValue::as_f64);
+        let font_size = style.get("1").and_then(V::as_f64);
         let fill_argb = colour_of(style, "53");
         let font_index = style.get("0").and_then(usize_of);
         if font_size.is_none() || fill_argb.is_none() || font_index.is_none() {
             notes.incomplete = notes.incomplete.saturating_add(1);
         }
-        undecoded_fields(style, sampled.as_ref(), DECODED_STYLE_SLOTS, NEUTRAL_STYLE_VALUES, &mut notes.style_fields);
+        undecoded_fields(style, sampled, DECODED_STYLE_SLOTS, NEUTRAL_STYLE_VALUES, &mut notes.style_fields);
         out.push(StyleRun {
             length,
             font_size: font_size.unwrap_or(prev.font_size),
             fill_argb: fill_argb.unwrap_or(prev.fill_argb),
             stroke_argb: colour_of(style, "54"),
-            tracking: style.get("8").and_then(TextValue::as_f64).unwrap_or(0.0),
-            faux_bold: matches!(style.get("2"), Some(TextValue::Bool(true))),
-            faux_italic: matches!(style.get("3"), Some(TextValue::Bool(true))),
-            caps: match style.get("12").and_then(TextValue::as_i64) {
+            tracking: style.get("8").and_then(V::as_f64).unwrap_or(0.0),
+            faux_bold: matches!(style.get("2"), Some(V::Bool(true))),
+            faux_italic: matches!(style.get("3"), Some(V::Bool(true))),
+            caps: match style.get("12").and_then(V::as_i64) {
                 None | Some(0) => Caps::Normal,
                 Some(1) => Caps::Small,
                 Some(2) => Caps::All,
                 Some(other) => Caps::Other(other),
             },
-            auto_leading: matches!(style.get("4"), Some(TextValue::Bool(true))),
-            leading: style.get("5").and_then(TextValue::as_f64),
+            auto_leading: matches!(style.get("4"), Some(V::Bool(true))),
+            leading: style.get("5").and_then(V::as_f64),
             font_index: font_index.unwrap_or(prev.font_index),
-            baseline: match style.get("13").and_then(TextValue::as_i64) {
+            baseline: match style.get("13").and_then(V::as_i64) {
                 None | Some(0) => FontBaseline::Normal,
                 Some(1) => FontBaseline::Superscript,
                 Some(2) => FontBaseline::Subscript,
@@ -775,22 +904,22 @@ fn style_runs(run: &TextValue, notes: &mut RunNotes) -> Vec<StyleRun> {
             horizontal_scale: num(style, "6", 1.0),
             vertical_scale: num(style, "7", 1.0),
             baseline_shift: num(style, "9", 0.0),
-            auto_kern: match style.get("11").and_then(TextValue::as_i64) {
+            auto_kern: match style.get("11").and_then(V::as_i64) {
                 Some(0) => AutoKern::None,
                 None | Some(1) => AutoKern::Metrics,
                 Some(2) => AutoKern::Optical,
                 Some(other) => AutoKern::Other(other),
             },
             ligatures: flag(style, "18", false),
-            baseline_direction: style.get("35").and_then(TextValue::as_i64).unwrap_or(1),
+            baseline_direction: style.get("35").and_then(V::as_i64).unwrap_or(1),
             tsume: num(style, "36", 0.0),
             no_break: flag(style, "52", false),
             apply_fill: flag(style, "56", true),
             apply_stroke: flag(style, "57", false),
             stroke_over_fill: flag(style, "58", true),
-            line_join: style.get("62").and_then(TextValue::as_i64).unwrap_or(0),
+            line_join: style.get("62").and_then(V::as_i64).unwrap_or(0),
             stroke_width: num(style, "63", 1.0),
-            digit_set: style.get("70").and_then(TextValue::as_i64).unwrap_or(0),
+            digit_set: style.get("70").and_then(V::as_i64).unwrap_or(0),
         });
     }
     out
@@ -798,13 +927,13 @@ fn style_runs(run: &TextValue, notes: &mut RunNotes) -> Vec<StyleRun> {
 
 /// The box of paragraph text from the frame dictionary `/0/8/0[0]/0`: key `/1/0` holds 16 x, y pairs
 /// that trace the rectangle, and `/2/0` is 1; both keys are absent for point text.
-fn text_box(top: &TextValue) -> Option<TextBox> {
+fn text_box(top: &V<'_>) -> Option<TextBox> {
     let frame = top.get("0")?.get("8")?.get("0")?.at(0)?.get("0")?;
     if frame.get("2")?.get("0")?.as_i64()? != 1 {
         return None;
     }
-    let TextValue::Array(coords) = frame.get("1")?.get("0")? else { return None };
-    let numbers: Vec<f64> = coords.iter().map(TextValue::as_f64).collect::<Option<_>>()?;
+    let V::Array(coords) = frame.get("1")?.get("0")? else { return None };
+    let numbers: Vec<f64> = coords.iter().map(V::as_f64).collect::<Option<_>>()?;
     let (pairs, _) = numbers.as_chunks::<2>();
     if pairs.is_empty() {
         return None;
@@ -818,18 +947,15 @@ fn text_box(top: &TextValue) -> Option<TextBox> {
 impl TextDocument {
     /// Decodes the body of a `btdk` list.
     pub fn parse(body: &[u8]) -> Option<Self> {
-        let top = parse_text_dict(body);
+        let top = parse_dict(body);
         let run = top.get("1")?.get("1")?.at(0)?.get("0")?;
-        let raw_text = run.get("0")?.as_str()?.to_string();
+        let raw_text = run.get("0")?.string()?;
         let style = run.get("6")?.get("0")?.at(0)?.get("0")?.get("0")?.get("6")?;
         let fill_argb = colour_of(style, "53")?;
         let font_index = usize::try_from(style.get("0")?.as_i64()?).ok()?;
         let mut fonts = Vec::new();
-        if let Some(TextValue::Array(list)) = top.get("0").and_then(|v| v.get("1")).and_then(|v| v.get("0")) {
-            fonts = list
-                .iter()
-                .map(|f| f.get("0").and_then(|v| v.get("0")).and_then(|v| v.get("0")).and_then(TextValue::as_str).unwrap_or_default().to_string())
-                .collect();
+        if let Some(V::Array(list)) = top.get("0").and_then(|v| v.get("1")).and_then(|v| v.get("0")) {
+            fonts = list.iter().map(|f| f.get("0").and_then(|v| v.get("0")).and_then(|v| v.get("0")).and_then(V::string).unwrap_or_default()).collect();
         }
         let mut notes = RunNotes::default();
         let paragraphs = paragraph_runs(run, &mut notes);
@@ -857,7 +983,7 @@ impl TextDocument {
                 .and_then(|v| v.get("0"))
                 .and_then(|v| v.get("2"))
                 .and_then(|v| v.get("1"))
-                .and_then(TextValue::as_i64),
+                .and_then(V::as_i64),
         })
     }
 
@@ -1023,6 +1149,240 @@ impl<'f, 'a> Comp<'f, 'a> {
     }
 }
 
+/// The dictionary parser and the defaults as they were before they borrowed from the body (#3276),
+/// kept as the reference the differential tests compare with.
+#[cfg(test)]
+mod oracle {
+    use super::{MAX_DEPTH, TextValue};
+    use crate::container::bytes::text;
+
+    impl TextValue {
+        fn key_text(&self) -> String {
+            match self {
+                Self::Name(s) | Self::Str(s) | Self::Token(s) => s.clone(),
+                Self::Int(i) => i.to_string(),
+                Self::Float(f) => f.to_string(),
+                Self::Bool(b) => b.to_string(),
+                Self::Bytes(b) => text(b),
+                Self::Dict(_) | Self::Array(_) => String::new(),
+            }
+        }
+    }
+
+    struct Parser<'b> {
+        b: &'b [u8],
+        i: usize,
+    }
+
+    fn is_ws(c: u8) -> bool {
+        matches!(c, b' ' | b'\t' | b'\r' | b'\n')
+    }
+
+    fn is_delimiter(c: u8) -> bool {
+        is_ws(c) || matches!(c, b'/' | b'[' | b']' | b'<' | b'>' | b'(' | b')')
+    }
+
+    impl Parser<'_> {
+        fn peek(&self) -> Option<u8> {
+            self.b.get(self.i).copied()
+        }
+
+        fn skip_ws(&mut self) {
+            while self.peek().is_some_and(is_ws) {
+                self.i = self.i.saturating_add(1);
+            }
+        }
+
+        fn starts_with(&self, s: &[u8]) -> bool {
+            self.b.get(self.i..).is_some_and(|rest| rest.starts_with(s))
+        }
+
+        fn word(&mut self) -> &[u8] {
+            let start = self.i;
+            while self.peek().is_some_and(|c| !is_delimiter(c)) {
+                self.i = self.i.saturating_add(1);
+            }
+            self.b.get(start..self.i).unwrap_or(&[])
+        }
+
+        fn parse(&mut self, depth: usize) -> Option<TextValue> {
+            self.skip_ws();
+            if depth > MAX_DEPTH {
+                return None;
+            }
+            if self.starts_with(b"<<") {
+                self.i = self.i.saturating_add(2);
+                let mut pairs = Vec::new();
+                loop {
+                    self.skip_ws();
+                    if self.starts_with(b">>") {
+                        self.i = self.i.saturating_add(2);
+                        return Some(TextValue::Dict(pairs));
+                    }
+                    let key = self.parse(depth.saturating_add(1))?;
+                    let value = self.parse(depth.saturating_add(1))?;
+                    pairs.push((key.key_text(), value));
+                }
+            }
+            match self.peek()? {
+                b'[' => {
+                    self.i = self.i.saturating_add(1);
+                    let mut items = Vec::new();
+                    loop {
+                        self.skip_ws();
+                        if self.peek()? == b']' {
+                            self.i = self.i.saturating_add(1);
+                            return Some(TextValue::Array(items));
+                        }
+                        items.push(self.parse(depth.saturating_add(1))?);
+                    }
+                }
+                b'(' => {
+                    self.i = self.i.saturating_add(1);
+                    let mut out = Vec::new();
+                    loop {
+                        let c = self.peek()?;
+                        if c == b'\\' {
+                            out.push(*self.b.get(self.i.saturating_add(1))?);
+                            self.i = self.i.saturating_add(2);
+                        } else if c == b')' {
+                            self.i = self.i.saturating_add(1);
+                            break;
+                        } else {
+                            out.push(c);
+                            self.i = self.i.saturating_add(1);
+                        }
+                    }
+                    Some(match out.strip_prefix(&[0xfe, 0xff]) {
+                        Some(utf16) => TextValue::Str(decode_utf16be(utf16)),
+                        None => TextValue::Bytes(out),
+                    })
+                }
+                b'/' => {
+                    self.i = self.i.saturating_add(1);
+                    Some(TextValue::Name(text(self.word())))
+                }
+                _ => {
+                    let word = self.word();
+                    if word.is_empty() {
+                        return None;
+                    }
+                    let w = text(word);
+                    Some(match w.as_str() {
+                        "true" => TextValue::Bool(true),
+                        "false" => TextValue::Bool(false),
+                        _ => match w.parse::<i64>() {
+                            Ok(i) => TextValue::Int(i),
+                            // `parse` also takes `nan`, `inf` and overflowing exponents; those are not
+                            // numbers a text document holds, so they stay tokens and read as missing.
+                            Err(_) => match w.parse::<f64>() {
+                                Ok(f) if f.is_finite() => TextValue::Float(f),
+                                _ => TextValue::Token(w),
+                            },
+                        },
+                    })
+                }
+            }
+        }
+    }
+
+    fn decode_utf16be(bytes: &[u8]) -> String {
+        let (pairs, rest) = bytes.as_chunks::<2>();
+        let units = pairs.iter().map(|p| u16::from_be_bytes(*p));
+        let mut s: String = char::decode_utf16(units).map(|r| r.unwrap_or(char::REPLACEMENT_CHARACTER)).collect();
+        if !rest.is_empty() {
+            s.push(char::REPLACEMENT_CHARACTER);
+        }
+        s
+    }
+
+    /// Parses the body of a `btdk` list into its top-level `key value` pairs (as a [`TextValue::Dict`]).
+    /// Parsing stops silently at the first syntax error or at nesting deeper than 64 levels; what was
+    /// read before is returned.
+    pub(super) fn parse_text_dict(body: &[u8]) -> TextValue {
+        let mut parser = Parser { b: body, i: 0 };
+        let mut pairs = Vec::new();
+        loop {
+            parser.skip_ws();
+            if parser.i >= body.len() {
+                break;
+            }
+            let Some(key) = parser.parse(0) else { break };
+            let Some(value) = parser.parse(0) else { break };
+            pairs.push((key.key_text(), value));
+        }
+        TextValue::Dict(pairs)
+    }
+
+    fn val(v: f64) -> TextValue {
+        TextValue::Float(v)
+    }
+
+    fn dict(pairs: Vec<(&str, TextValue)>) -> TextValue {
+        TextValue::Dict(pairs.into_iter().map(|(k, v)| (k.to_string(), v)).collect())
+    }
+
+    fn numbers(v: &[f64]) -> TextValue {
+        TextValue::Array(v.iter().map(|x| val(*x)).collect())
+    }
+
+    /// The default of every run style slot that is not decoded and not neutral (zero, `false`,
+    /// empty, `/nil`): the value an untouched point text holds in every sample (110, 243-245). A slot
+    /// with a neutral default is left out; [`undecoded_fields`] treats a missing default as neutral.
+    pub(super) fn style_defaults() -> TextValue {
+        let paint = |a: f64| dict(vec![("99", TextValue::Name("SimplePaint".into())), ("0", dict(vec![("0", val(1.0)), ("1", numbers(&[1.0, 1.0, 1.0, a]))]))]);
+        let class = |name: &str| dict(vec![("99", TextValue::Name(name.into()))]);
+        dict(vec![
+            ("37", val(2.0)),
+            ("41", val(2.0)),
+            ("43", dict(vec![("0", val(0.5))])),
+            ("44", val(2.0)),
+            ("45", val(2.0)),
+            ("46", val(7.0)),
+            ("49", val(-1.0)),
+            ("50", val(-1.0)),
+            ("55", class("SimpleBlender")),
+            ("64", val(4.0)),
+            ("71", val(4.0)),
+            ("77", TextValue::Bool(true)),
+            ("78", TextValue::Bool(true)),
+            ("79", paint(0.0)),
+            ("82", val(3.0)),
+            ("83", val(3.0)),
+            ("86", class("SimpleCustomFeature")),
+            ("87", val(100.0)),
+            ("88", TextValue::Bool(true)),
+            ("95", dict(vec![("0", val(0.0)), ("1", val(0.0))])),
+            ("96", TextValue::Bool(true)),
+        ])
+    }
+
+    /// The same for the paragraph slots (110, 243-245).
+    pub(super) fn paragraph_defaults() -> TextValue {
+        dict(vec![
+            ("6", val(1.0)),
+            ("7", val(1.2)),
+            ("10", val(6.0)),
+            ("11", val(2.0)),
+            ("12", val(2.0)),
+            ("14", val(36.0)),
+            ("15", TextValue::Bool(true)),
+            ("16", val(0.5)),
+            ("17", numbers(&[0.8, 1.0, 1.33])),
+            ("18", numbers(&[0.0, 0.0, 0.0])),
+            ("19", numbers(&[1.0, 1.0, 1.0])),
+            ("20", val(6.0)),
+            ("22", val(1.0)),
+            ("23", TextValue::Bool(true)),
+            ("24", val(1.0)),
+            ("26", TextValue::Bool(true)),
+            ("31", val(36.0)),
+            ("35", val(1.0)),
+            ("40", val(2.0)),
+        ])
+    }
+}
+
 #[cfg(test)]
 mod tests {
     use super::*;
@@ -1031,6 +1391,206 @@ mod tests {
         Chunk::list(*t, kids)
     }
 
+    /// A document with every kind of value, close to what After Effects writes: names, numbers,
+    /// a UTF-16 string with escapes, a plain string, nested dictionaries and arrays, an undecoded
+    /// style slot, a font list and a box frame.
+    const DOC: &[u8] = b"/0 << /1 << /0 [ << /0 << /0 << /0 (\xfe\xff\0M\0y\0r) >> /1 1 >> >> << /0 << /0 << /0 (\xfe\xff\0A\0\\)\0b) >> >> >> ] >> \
+        /8 << /0 [ << /0 << /1 << /0 [ 0 0 10 0 10 5 0 5 ] >> /2 << /0 1 /1 2 >> >> >> ] >> >> \
+        /1 << /1 [ << /0 << /0 (\xfe\xff\0H\0i\0\r) /5 << /0 [ << /0 << /0 << /5 << /0 2 /9 false /24 0 /34 7 /17 [ .8 1.0 1.33 ] >> >> >> /1 3 >> ] >> \
+        /6 << /0 [ << /0 << /0 << /6 << /0 1 /1 36.5 /53 << /0 << /0 1 /1 [ 1 0.5 0 1 ] >> >> /79 << /99 /SimplePaint /0 << /0 1 /1 [ 1 1 1 0 ] >> >> /68 1 /90 /x /91 (plain) /92 word >> >> >> /1 3 >> ] >> \
+        /8 << /0 [ << /0 << /0 50 >> /1 2 >> << /1 1 >> ] >> >> >> ] >>";
+
+    /// A deterministic xorshift generator: the tests need varied input, not a dependency.
+    struct Rng(u64);
+
+    impl Rng {
+        fn next(&mut self) -> u64 {
+            self.0 ^= self.0 << 13;
+            self.0 ^= self.0 >> 7;
+            self.0 ^= self.0 << 17;
+            self.0
+        }
+
+        fn below(&mut self, n: usize) -> usize {
+            usize::try_from(self.next() % (n as u64)).unwrap_or(0)
+        }
+    }
+
+    #[test]
+    fn the_borrowing_parser_reads_what_the_owning_one_read() {
+        // Every key form the owned keys canonicalise (`06`, `+6`, `-0`, `1.0`, `1e2`, strings,
+        // booleans, containers), names that are not UTF-8, escapes, unclosed strings and escapes,
+        // non-finite numbers, and bare words.
+        let parts: &[&[u8]] = &[
+            b"<<",
+            b">>",
+            b"[",
+            b"]",
+            b"/0",
+            b"/1",
+            b"/nil",
+            b"/SimplePaint",
+            b"/\xff\xfe",
+            b"/\xc3\xa9",
+            b"/",
+            b"06",
+            b"+6",
+            b"-0",
+            b"1.0",
+            b"1.50",
+            b"1e2",
+            b"-2.5",
+            b".8",
+            b"inf",
+            b"nan",
+            b"1e999",
+            b"9223372036854775808",
+            b"true",
+            b"false",
+            b"(abc)",
+            b"(\xfe\xff\0A\0B)",
+            b"(\xfe\xff\0A\0)",
+            b"(a\\)b)",
+            b"(\\",
+            b"(\xfe\xff\\)\0)",
+            b"(\\\xfe\xff\0C)",
+            b"()",
+            b"(\xfe\xff)",
+            b"(unclosed",
+            b"word",
+            b"\xc3\x28",
+            b"\xff",
+            b" ",
+            b"\n",
+            b"\t\r",
+            b"<",
+            b">",
+            b")",
+        ];
+        // A value: mostly well formed, with a random part in its place now and then.
+        fn value(rng: &mut Rng, parts: &[&[u8]], depth: usize, out: &mut Vec<u8>) {
+            let pick = |rng: &mut Rng| parts.get(rng.below(parts.len())).copied().unwrap_or_default();
+            match rng.below(if depth > 6 { 5 } else { 10 }) {
+                0 => out.extend_from_slice(pick(rng)),
+                1..=4 => out.extend_from_slice([&b"/0"[..], b"1", b"(\xfe\xff\0z)", b"0.5", b"/nil"].get(rng.below(5)).copied().unwrap_or_default()),
+                5..=7 => {
+                    out.extend_from_slice(b"<< ");
+                    for _ in 0..rng.below(5) {
+                        let key = if rng.below(4) == 0 { pick(rng) } else { [&b"/0"[..], b"/1", b"/6", b"/53"].get(rng.below(4)).copied().unwrap_or_default() };
+                        out.extend_from_slice(key);
+                        out.push(b' ');
+                        value(rng, parts, depth + 1, out);
+                        out.push(b' ');
+                    }
+                    if rng.below(20) != 0 {
+                        out.extend_from_slice(b">>");
+                    }
+                }
+                _ => {
+                    out.extend_from_slice(b"[ ");
+                    for _ in 0..rng.below(5) {
+                        value(rng, parts, depth + 1, out);
+                        out.push(b' ');
+                    }
+                    if rng.below(20) != 0 {
+                        out.push(b']');
+                    }
+                }
+            }
+        }
+        let mut rng = Rng(0x9e37_79b9_7f4a_7c15);
+        let (mut read, mut nested) = (0, 0);
+        for case in 0..40_000 {
+            let mut body = Vec::new();
+            if case % 2 == 0 {
+                for _ in 0..rng.below(60) {
+                    body.extend_from_slice(parts.get(rng.below(parts.len())).copied().unwrap_or_default());
+                    if rng.below(3) != 0 {
+                        body.push(b' ');
+                    }
+                }
+            } else {
+                for _ in 0..1 + rng.below(4) {
+                    body.extend_from_slice(b"/0 ");
+                    value(&mut rng, parts, 0, &mut body);
+                    body.push(b'\n');
+                }
+            }
+            let parsed = parse_text_dict(&body);
+            assert_eq!(parsed, oracle::parse_text_dict(&body), "case {case}: {}", String::from_utf8_lossy(&body));
+            let _ = TextDocument::parse(&body);
+            if let TextValue::Dict(pairs) = &parsed {
+                read += usize::from(!pairs.is_empty());
+                nested += usize::from(pairs.iter().any(|(_, v)| matches!(v, TextValue::Dict(d) if !d.is_empty())));
+            }
+        }
+        // The input is not all rejected at the first token.
+        assert!(read > 25_000 && nested > 3_000, "{read} cases read something, {nested} a dictionary");
+        // Every cut of a realistic document, and nesting past the limit.
+        for end in 0..=DOC.len() {
+            let body = DOC.get(..end).unwrap_or_default();
+            assert_eq!(parse_text_dict(body), oracle::parse_text_dict(body), "cut at {end}");
+            let _ = TextDocument::parse(body);
+        }
+        for depth in [63, 64, 65, 66, 200] {
+            let body = [b"/k ".repeat(1), b"<< /a ".repeat(depth), b"1".to_vec(), b" >>".repeat(depth), b" /z 2".to_vec()].concat();
+            assert_eq!(parse_text_dict(&body), oracle::parse_text_dict(&body), "depth {depth}");
+            let body = [b"/k ".repeat(1), b"[ ".repeat(depth), b"]".repeat(depth)].concat();
+            assert_eq!(parse_text_dict(&body), oracle::parse_text_dict(&body), "array depth {depth}");
+        }
+    }
+
+    #[test]
+    fn a_realistic_document_is_read_in_full() {
+        let doc = TextDocument::parse(DOC).expect("a document");
+        assert_eq!((doc.text.as_str(), doc.font_size, doc.fill_argb, doc.font.as_deref()), ("Hi", 36.5, [1.0, 0.5, 0.0, 1.0], Some("A)b")));
+        assert_eq!(doc.fonts, ["Myr", "A)b"]);
+        assert_eq!(doc.paragraphs.first().map(|p| (p.length, p.justification, p.auto_hyphenate)), Some((3, Justification::Center, false)));
+        // `/68 1` and `/34 7` are neutral; `/90 /x`, `/91 (plain)` and `/92 word` differ from the
+        // (missing, neutral) default; `/79` equals its default.
+        assert_eq!(doc.undecoded_style_fields, ["90", "91", "92"]);
+        assert!(doc.undecoded_paragraph_fields.is_empty());
+        assert_eq!(doc.kerning, [KernRun { length: 2, amount: Some(50.0) }, KernRun { length: 1, amount: None }]);
+        assert_eq!(doc.text_box, Some(TextBox { x: 0.0, y: 0.0, width: 10.0, height: 5.0 }));
+        assert_eq!(doc.line_orientation, Some(2));
+    }
+
+    #[test]
+    fn the_defaults_are_the_sampled_ones_and_built_once() {
+        assert_eq!(STYLE_DEFAULTS.clone().into_owned(), oracle::style_defaults());
+        assert_eq!(PARAGRAPH_DEFAULTS.clone().into_owned(), oracle::paragraph_defaults());
+        assert!(std::ptr::eq(&*STYLE_DEFAULTS, &*STYLE_DEFAULTS));
+    }
+
+    #[test]
+    fn names_keys_and_strings_are_borrowed_from_the_body() {
+        let V::Dict(pairs) = parse_dict(b"/a /b /c (\xfe\xff\0x) /d (plain) /e word /f 1.5 /g (\\(esc) 07 1") else { panic!("a dict") };
+        // Every `/name` key, name, string without escapes and bare word points into the body.
+        assert!(pairs.iter().take(6).all(|(k, _)| matches!(k, Cow::Borrowed(_))));
+        assert!(matches!(pairs.first().map(|p| &p.1), Some(V::Name(b"b"))));
+        assert!(matches!(pairs.get(1).map(|p| &p.1), Some(V::Str(Cow::Borrowed(b"\0x")))));
+        assert!(matches!(pairs.get(2).map(|p| &p.1), Some(V::Bytes(Cow::Borrowed(b"plain")))));
+        assert!(matches!(pairs.get(3).map(|p| &p.1), Some(V::Token(b"word"))));
+        // An escaped string is copied; a number key is written in its canonical form.
+        assert!(matches!(pairs.get(5).map(|p| &p.1), Some(V::Bytes(Cow::Owned(b))) if b == b"(esc"));
+        assert_eq!(pairs.get(6).map(|p| p.0.as_ref()), Some("7"));
+        // Containers are sized to what they hold.
+        let V::Dict(outer) = parse_dict(b"/0 << /a 1 /b 2 /c 3 /d 4 /e 5 >> /1 [ 1 2 3 4 5 6 7 8 9 ]") else { panic!("a dict") };
+        assert!(matches!(outer.first().map(|p| &p.1), Some(V::Dict(d)) if d.len() == 5 && d.capacity() == 5));
+        assert!(matches!(outer.get(1).map(|p| &p.1), Some(V::Array(a)) if a.len() == 9 && a.capacity() == 9));
+    }
+
+    #[test]
+    fn values_compare_by_their_text() {
+        // Two names that are not UTF-8 read as the same text with replacement characters, as the
+        // owned values did.
+        assert!(same(&V::Name(b"\xff"), &V::Name(b"\xfe")));
+        assert!(!same(&V::Name(b"a"), &V::Name(b"b")));
+        assert!(same(&V::Str(Cow::Borrowed(b"\xd8\x00")), &V::Str(Cow::Owned(b"\xd8\x01".to_vec()))));
+        assert!(same(&V::Int(0), &V::Float(0.0)) && !same(&V::Int(0), &V::Bool(false)) && !same(&V::Name(b"x"), &V::Token(b"x")));
+        assert!(is_neutral(&V::Name(b"nil")) && !is_neutral(&V::Token(b"nil")) && is_neutral(&V::Float(0.0)) && !is_neutral(&V::Str(Cow::Borrowed(b""))));
+    }
+
     #[test]
     fn a_layers_marker_list_is_the_one_in_its_root_group() {
         let marked = |tag: u8| list(b"mrst", vec![Chunk::data(*b"test", vec![tag])]);
@@ -1076,13 +1636,13 @@ mod tests {
     fn undecoded_fields_are_capped_and_linear() {
         // 300 000 distinct undecoded slots that differ from a sampled default: before, each was
         // checked against every slot recorded so far (4.5e10 compares) and all were listed.
-        let actual = TextValue::Dict((0..300_000).map(|i| (format!("{}", 9000 + i), TextValue::Int(1))).collect());
+        let actual = V::Dict((0..300_000).map(|i| (Cow::Owned(format!("{}", 9000 + i)), V::Int(1))).collect());
         let mut out = Vec::new();
         undecoded_fields(&actual, None, &["0"], &[], &mut out);
         assert_eq!(out.len(), MAX_UNDECODED_FIELDS);
         assert_eq!(out.first().map(String::as_str), Some("9000"));
         // A slot listed once is not listed again.
-        let again = TextValue::Dict(vec![("9000".into(), TextValue::Int(1))]);
+        let again = V::Dict(vec![(Cow::Borrowed("9000"), V::Int(1))]);
         let mut short = vec!["9000".to_string()];
         undecoded_fields(&again, None, &[], &[], &mut short);
         assert_eq!(short, ["9000"]);

From 34715bbd860fe570ef6bccabe39e57c7e8252694 Mon Sep 17 00:00:00 2001
From: vangel76 <vangel1976@googlemail.com>
Date: Sun, 8 Nov 2026 03:37:19 +0100
Subject: [PATCH 07/30] aep: text-dict test builds its prefix without repeat(1)
 (#3276)

---
 crates/aep/src/container/textdoc.rs | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/crates/aep/src/container/textdoc.rs b/crates/aep/src/container/textdoc.rs
index dc386611f..f8421c590 100644
--- a/crates/aep/src/container/textdoc.rs
+++ b/crates/aep/src/container/textdoc.rs
@@ -1533,9 +1533,9 @@ mod tests {
             let _ = TextDocument::parse(body);
         }
         for depth in [63, 64, 65, 66, 200] {
-            let body = [b"/k ".repeat(1), b"<< /a ".repeat(depth), b"1".to_vec(), b" >>".repeat(depth), b" /z 2".to_vec()].concat();
+            let body = [b"/k ".to_vec(), b"<< /a ".repeat(depth), b"1".to_vec(), b" >>".repeat(depth), b" /z 2".to_vec()].concat();
             assert_eq!(parse_text_dict(&body), oracle::parse_text_dict(&body), "depth {depth}");
-            let body = [b"/k ".repeat(1), b"[ ".repeat(depth), b"]".repeat(depth)].concat();
+            let body = [b"/k ".to_vec(), b"[ ".repeat(depth), b"]".repeat(depth)].concat();
             assert_eq!(parse_text_dict(&body), oracle::parse_text_dict(&body), "array depth {depth}");
         }
     }

From 6c84c81060b55e1393d15ce598c7109c5f3e5e8c Mon Sep 17 00:00:00 2001
From: vangel76 <vangel1976@googlemail.com>
Date: Sun, 8 Nov 2026 03:42:48 +0100
Subject: [PATCH 08/30] aep: an escaped text string drops its byte order mark
 without a range drain (#3276)

---
 crates/aep/src/container/textdoc.rs | 5 +----
 1 file changed, 1 insertion(+), 4 deletions(-)

diff --git a/crates/aep/src/container/textdoc.rs b/crates/aep/src/container/textdoc.rs
index f8421c590..765490557 100644
--- a/crates/aep/src/container/textdoc.rs
+++ b/crates/aep/src/container/textdoc.rs
@@ -282,10 +282,7 @@ impl<'b> Parser<'b> {
                 Some(if body.starts_with(&[0xfe, 0xff]) {
                     V::Str(match body {
                         Cow::Borrowed(b) => Cow::Borrowed(b.get(2..).unwrap_or(&[])),
-                        Cow::Owned(mut v) => {
-                            v.drain(..2);
-                            Cow::Owned(v)
-                        }
+                        Cow::Owned(v) => Cow::Owned(v.get(2..).map(<[u8]>::to_vec).unwrap_or_default()),
                     })
                 } else {
                     V::Bytes(body)

From 5f37f781174f7b785252afc4d582163e59bba6d3 Mon Sep 17 00:00:00 2001
From: vangel76 <vangel1976@googlemail.com>
Date: Sun, 8 Nov 2026 03:43:01 +0100
Subject: [PATCH 09/30] aep export: one key-time loop, key-list rewrite, tdmn
 decoder and byte writer for the listed modules (#3278)

In masks, shapes, styles, synth, fxsynth, base, camlight, skeleton,
textanim and tree (effects.rs, plan.rs and emit.rs keep their copies for
the follow-up work):
- New export/keys.rs: the key-time loop (timed_keys), the key-list rewrite
  (fill_key_list, set_key_list, replace_cdat) and the spatial key record,
  shared by masks, shapes and styles.
- One tdmn decoder (synth::tdmn_name, lossy UTF-8 up to the first NUL, as the
  importer reads it) and one encoder (synth::tdmn) instead of the copies in
  masks, styles, shapes, textanim, camlight and skeleton.
- One byte writer: tree::put, which errors. base::bytes, synth::tdb4,
  synth::key_list, fxsynth::pard, masks::shph and the keyed path records write
  through it; their fixed layouts keep the infallible signatures behind
  tree::fixed, which logs, and a test builds every layout and requires no error.
- camlight::put_group uses the shared group split (tree::split_group), which
  errors on a match name without a node instead of stopping quietly.

Export output is byte-identical on the corpus and the synthetic fixtures.
---
 Cargo.lock                        |   1 +
 crates/aep/Cargo.toml             |   1 +
 crates/aep/src/export.rs          |   1 +
 crates/aep/src/export/base.rs     |  60 ++++++-------
 crates/aep/src/export/camlight.rs |  39 ++-------
 crates/aep/src/export/fxsynth.rs  |  97 ++++++++++++---------
 crates/aep/src/export/keys.rs     | 139 ++++++++++++++++++++++++++++++
 crates/aep/src/export/masks.rs    | 120 ++++++++------------------
 crates/aep/src/export/shapes.rs   |  89 +++----------------
 crates/aep/src/export/skeleton.rs |  12 +--
 crates/aep/src/export/styles.rs   |  49 ++---------
 crates/aep/src/export/synth.rs    | 103 ++++++++++++++++------
 crates/aep/src/export/textanim.rs |  13 +--
 crates/aep/src/export/tree.rs     | 102 ++++++++++++++++++++--
 14 files changed, 476 insertions(+), 350 deletions(-)
 create mode 100644 crates/aep/src/export/keys.rs

diff --git a/Cargo.lock b/Cargo.lock
index f897737db..8e06b3afe 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -1453,6 +1453,7 @@ dependencies = [
  "effectcraft-keyframe",
  "effectcraft-project",
  "effectcraft-time",
+ "log",
  "serde",
  "serde_json",
  "thiserror 2.0.21",
diff --git a/crates/aep/Cargo.toml b/crates/aep/Cargo.toml
index b1bf3f9fe..d1fbc4a3a 100644
--- a/crates/aep/Cargo.toml
+++ b/crates/aep/Cargo.toml
@@ -17,6 +17,7 @@ effectcraft-project = { workspace = true }
 effectcraft-effects = { workspace = true }
 serde = { workspace = true }
 thiserror = { workspace = true }
+log = { workspace = true }
 
 [dev-dependencies]
 serde_json = { workspace = true }
diff --git a/crates/aep/src/export.rs b/crates/aep/src/export.rs
index 12f10aa0c..992dfecb3 100644
--- a/crates/aep/src/export.rs
+++ b/crates/aep/src/export.rs
@@ -26,6 +26,7 @@ mod footage;
 mod fx_defs;
 mod fxsynth;
 pub(crate) mod icc;
+mod keys;
 mod markers;
 mod masks;
 mod plan;
diff --git a/crates/aep/src/export/base.rs b/crates/aep/src/export/base.rs
index d483cefb7..3e2b043ff 100644
--- a/crates/aep/src/export/base.rs
+++ b/crates/aep/src/export/base.rs
@@ -6,17 +6,21 @@
 //! (read-backs t-no<id>, t-zcdta, u-zsspc, u-noclrs, u-noftgi, u-nofrec, u-nocdrp).
 
 use crate::Chunk;
-use crate::export::synth::{tdmn, tdsn};
+use crate::export::synth::{GROUP_END, tdmn, tdsn};
+use crate::export::tree::{R, fixed, put};
 
-/// A zero buffer of `len` bytes with `fields` (offset, bytes) written into it.
+/// A zero buffer of `len` bytes with `fields` (offset, bytes) written into it. The layouts are
+/// fixed in code ([`fixed`]).
 pub(crate) fn bytes(len: usize, fields: &[(usize, &[u8])]) -> Vec<u8> {
+    fixed("a record", try_bytes(len, fields), || vec![0u8; len])
+}
+
+fn try_bytes(len: usize, fields: &[(usize, &[u8])]) -> R<Vec<u8>> {
     let mut b = vec![0u8; len];
     for (at, v) in fields {
-        if let Some(dst) = b.get_mut(*at..at.saturating_add(v.len())) {
-            dst.copy_from_slice(v);
-        }
+        put(&mut b, *at, v)?;
     }
-    b
+    Ok(b)
 }
 
 pub(crate) fn utf8(text: &str) -> Chunk<'static> {
@@ -52,12 +56,8 @@ pub(crate) fn project_chunks() -> Vec<Chunk<'static>> {
     // colour depth (2: 32 bits); the save noise after the code page is left zero.
     let nhed = bytes(32, &[(7, &[5]), (9, &[1]), (12, &[0x1e, 16, 2, 2]), (18, &UTF8_CODE_PAGE)]);
     let nnhd = bytes(40, &[(7, &[5]), (9, &[1]), (15, &[0x1e]), (19, &[16, 2]), (24, &[2]), (26, &UTF8_CODE_PAGE)]);
-    let mut lhd3 = bytes(52, &[(0, &0x00d0_0bee_u32.to_be_bytes()), (12, &1u32.to_be_bytes()), (16, &RQ_ITEM_LEN.to_be_bytes())]);
-    for at in [20, 24, 28] {
-        if let Some(dst) = lhd3.get_mut(at..at + 4) {
-            dst.copy_from_slice(&1u32.to_be_bytes());
-        }
-    }
+    let one = 1u32.to_be_bytes();
+    let lhd3 = bytes(52, &[(0, &0x00d0_0bee_u32.to_be_bytes()), (12, &one), (16, &RQ_ITEM_LEN.to_be_bytes()), (20, &one), (24, &one), (28, &one)]);
     let wsnm: Vec<u8> = "Default".encode_utf16().flat_map(u16::to_be_bytes).collect();
     vec![
         Chunk::data(*b"svap", VERSION.to_vec()),
@@ -157,30 +157,17 @@ fn view_layer(ty: &[u8; 4], name: &str, label: u8, kind: u8) -> Vec<Chunk<'stati
     let markers = kind == 4;
     let mut name_copy = name.as_bytes().to_vec();
     name_copy.truncate(31);
-    let mut ldta = bytes(
-        164,
-        &[
-            (8, &1u32.to_be_bytes()),
-            (16, &600u32.to_be_bytes()),
-            (24, &25_600u32.to_be_bytes()),
-            (28, &VIEW_OUT.to_be_bytes()),
-            (32, &25_600u32.to_be_bytes()),
-            (61, &[label]),
-            (64, &name_copy),
-            (108, &1u32.to_be_bytes()),
-            (128, &u32::from(kind).to_be_bytes()),
-        ],
-    );
     // Byte 38: 3D and auto-orient on the cameras; byte 39: the video switch (and on the markers
     // layer also effects, locked and collapse); quality Draft and blend mode Normal on the
     // markers layer.
-    let flags: &[(usize, u8)] = if markers { &[(5, 2), (39, 0x87), (99, 2)] } else { &[(38, 0x44), (39, 1)] };
-    for (at, v) in flags {
-        if let Some(b) = ldta.get_mut(*at) {
-            *b = *v;
-        }
-    }
-    let root = vec![Chunk::data(*b"tdsb", 1u32.to_be_bytes().to_vec()), tdsn(""), tdmn("ADBE Group End")];
+    let flags: &[(usize, &[u8])] = if markers { &[(5, &[2]), (39, &[0x87]), (99, &[2])] } else { &[(38, &[0x44]), (39, &[1])] };
+    let (one, scale, kind_word) = (1u32.to_be_bytes(), 25_600u32.to_be_bytes(), u32::from(kind).to_be_bytes());
+    let (base, out, label) = (600u32.to_be_bytes(), VIEW_OUT.to_be_bytes(), [label]);
+    let mut fields: Vec<(usize, &[u8])> =
+        vec![(8, &one), (16, &base), (24, &scale), (28, &out), (32, &scale), (61, &label), (64, &name_copy), (108, &one), (128, &kind_word)];
+    fields.extend_from_slice(flags);
+    let ldta = bytes(164, &fields);
+    let root = vec![Chunk::data(*b"tdsb", 1u32.to_be_bytes().to_vec()), tdsn(""), tdmn(GROUP_END)];
     let layer = Chunk::list(*ty, vec![Chunk::data(*b"ldta", ldta), utf8(name), Chunk::list(*b"tdgp", root), guides()]);
     let mut out = vec![layer, Chunk::list(*b"Ewst", Vec::new())];
     out.extend(crate::export::skeleton::f_records());
@@ -293,6 +280,13 @@ pub(crate) fn solid_item() -> Chunk<'static> {
 mod tests {
     use super::*;
 
+    #[test]
+    fn a_field_out_of_range_is_an_error() {
+        assert_eq!(try_bytes(4, &[(0, &[1]), (3, &[2])]).ok(), Some(vec![1, 0, 0, 2]));
+        assert!(try_bytes(4, &[(3, &[1, 2])]).is_err());
+        assert!(try_bytes(4, &[(usize::MAX, &[1])]).is_err());
+    }
+
     /// The chunks After Effects refuses a file without, or crashes on (aep-export.md, "What After
     /// Effects needs").
     #[test]
diff --git a/crates/aep/src/export/camlight.rs b/crates/aep/src/export/camlight.rs
index 597bf800a..a8958025f 100644
--- a/crates/aep/src/export/camlight.rs
+++ b/crates/aep/src/export/camlight.rs
@@ -13,7 +13,8 @@ use effectcraft_keyframe::Value;
 use effectcraft_project::{Layer, LightKind};
 
 use crate::export::report::{Collector, LossCategory};
-use crate::export::tree::{R, child_data, kids_mut, list_mut, put_f64, tpl};
+use crate::export::synth::{GROUP_END, is_tdmn, tdmn};
+use crate::export::tree::{R, child_data, kids_mut, list_mut, put_f64, split_group, tpl};
 
 /// A camera's options in the file's units (pixels, percent, a switch).
 #[derive(Clone, Debug, PartialEq)]
@@ -183,50 +184,24 @@ const LIGHT_ORDER: &[&str] = &[
     "ADBE Casts Shadows",
 ];
 
-pub(crate) fn tdmn_chunk(name: &str) -> Chunk<'static> {
-    let mut b = vec![0u8; 40];
-    for (i, c) in name.bytes().take(39).enumerate() {
-        b[i] = c;
-    }
-    Chunk::data(*b"tdmn", b)
-}
-
-fn tdmn_name(c: &Chunk<'_>) -> Option<String> {
-    let b = c.bytes()?;
-    let end = b.iter().position(|x| *x == 0).unwrap_or(b.len());
-    std::str::from_utf8(b.get(..end)?).ok().map(str::to_string)
-}
-
 /// Sets (or inserts) the records of an options group (`tdmn` named `group`) of a layer.
 fn put_group(layr: &mut Chunk<'static>, group: &str, order: &[&str], set: Vec<(&str, Chunk<'static>)>, remove: &[&str]) -> R<()> {
     let root = list_mut(layr, b"tdgp")?;
     let kids = kids_mut(root)?;
-    let at = kids.iter().position(|c| c.is(b"tdmn") && tdmn_name(c).as_deref() == Some(group)).ok_or_else(|| tpl("options group missing"))?;
+    let at = kids.iter().position(|c| is_tdmn(c, group)).ok_or_else(|| tpl("options group missing"))?;
     let g = kids.get_mut(at + 1).ok_or_else(|| tpl("options group without a list"))?;
     let gk = kids_mut(g)?;
-    let first = gk.iter().position(|c| c.is(b"tdmn")).unwrap_or(gk.len());
-    let header: Vec<Chunk<'static>> = gk.drain(..first).collect();
-    let mut pairs: Vec<(String, Vec<Chunk<'static>>)> = Vec::new();
-    let mut it = std::mem::take(gk).into_iter();
-    while let Some(m) = it.next() {
-        let name = tdmn_name(&m).unwrap_or_default();
-        if name == "ADBE Group End" {
-            pairs.push((name, vec![m]));
-            continue;
-        }
-        let Some(node) = it.next() else { break };
-        // An atom group (Light Env Atom) carries its own Group End inside the list.
-        pairs.push((name, vec![m, node]));
-    }
+    // An atom group (Light Env Atom) carries its own Group End inside its list.
+    let (header, mut pairs) = split_group(gk)?;
     pairs.retain(|(n, _)| !remove.contains(&n.as_str()));
     for (name, rec) in set {
-        let entry = vec![tdmn_chunk(name), rec];
+        let entry = vec![tdmn(name), rec];
         match pairs.iter_mut().find(|(n, _)| n == name) {
             Some(slot) => slot.1 = entry,
             None => pairs.push((name.to_string(), entry)),
         }
     }
-    let rank = |n: &str| if n == "ADBE Group End" { usize::MAX } else { order.iter().position(|g| *g == n).unwrap_or(order.len()) };
+    let rank = |n: &str| if n == GROUP_END { usize::MAX } else { order.iter().position(|g| *g == n).unwrap_or(order.len()) };
     pairs.sort_by_key(|(n, _)| rank(n));
     gk.extend(header);
     gk.extend(pairs.into_iter().flat_map(|(_, v)| v));
diff --git a/crates/aep/src/export/fxsynth.rs b/crates/aep/src/export/fxsynth.rs
index 4fa02f0c5..e4bf002b9 100644
--- a/crates/aep/src/export/fxsynth.rs
+++ b/crates/aep/src/export/fxsynth.rs
@@ -11,7 +11,8 @@
 use crate::Chunk;
 use crate::effect_map::{Conv, by_match_name};
 use crate::export::fx_defs::{BUILT_IN, FxDef, PDef};
-use crate::export::synth::{KeyTemplate, NO_NAME, RecSpec, class, tdmn, tdsn};
+use crate::export::synth::{GROUP_END, KeyTemplate, NO_NAME, RecSpec, class, tdmn, tdsn, utf8_in};
+use crate::export::tree::{R, fixed as fixed_layout, put};
 use crate::{CURVE_IDENTITY, CurvesData, MeshData};
 
 /// The layer a prototype's layer parameters name when their default is the owning layer; the
@@ -37,12 +38,6 @@ pub(crate) fn value_spec(code: u8, range: Option<(f64, f64)>) -> Option<RecSpec>
     })
 }
 
-fn put(b: &mut [u8], at: usize, bytes: &[u8]) {
-    if let Some(dst) = b.get_mut(at..at + bytes.len()) {
-        dst.copy_from_slice(bytes);
-    }
-}
-
 fn fixed(v: f64) -> [u8; 4] {
     ((v * 65536.0).round().clamp(f64::from(i32::MIN), f64::from(i32::MAX)) as i32).to_be_bytes()
 }
@@ -53,87 +48,91 @@ fn fixed(v: f64) -> [u8; 4] {
 /// display 124; fixed and integer: 124 / 128 / 132 / 136, default 140, display 144). Every other
 /// byte is zero (the switches at 48 are not needed: s12-e2-nofl).
 pub(crate) fn pard(p: &PDef, popup_items: Option<u16>) -> Vec<u8> {
+    fixed_layout("pard", try_pard(p, popup_items), || vec![0u8; 148])
+}
+
+fn try_pard(p: &PDef, popup_items: Option<u16>) -> R<Vec<u8>> {
     let mut b = vec![0u8; 148];
-    put(&mut b, 12, &u32::from(p.code).to_be_bytes());
+    put(&mut b, 12, &u32::from(p.code).to_be_bytes())?;
     let d = |i: usize| p.default.get(i).copied().unwrap_or(0.0);
     // After Effects takes the default of a parameter without a value record from here (s8-e1:
     // the copies below are the ones it reads).
     match p.code {
         10 => {
-            put(&mut b, 56, &d(0).to_be_bytes());
+            put(&mut b, 56, &d(0).to_be_bytes())?;
             // The default again as `f32` at 120, the display word (decimals) at 124.
-            put(&mut b, 120, &(d(0) as f32).to_be_bytes());
-            put(&mut b, 124, &p.display.to_be_bytes());
+            put(&mut b, 120, &(d(0) as f32).to_be_bytes())?;
+            put(&mut b, 124, &p.display.to_be_bytes())?;
         }
-        2 => put(&mut b, 56, &fixed(d(0))),
+        2 => put(&mut b, 56, &fixed(d(0)))?,
         // An angle: the default again at 60.
         3 => {
-            put(&mut b, 56, &fixed(d(0)));
-            put(&mut b, 60, &fixed(d(0)));
+            put(&mut b, 56, &fixed(d(0)))?;
+            put(&mut b, 60, &fixed(d(0)))?;
         }
-        1 => put(&mut b, 56, &(d(0).round() as i32).to_be_bytes()),
+        1 => put(&mut b, 56, &(d(0).round() as i32).to_be_bytes())?,
         // A checkbox: the default again as a byte at 60.
         4 => {
-            put(&mut b, 56, &(d(0).round().max(0.0) as u32).to_be_bytes());
-            put(&mut b, 60, &[u8::from(d(0) != 0.0)]);
+            put(&mut b, 56, &(d(0).round().max(0.0) as u32).to_be_bytes())?;
+            put(&mut b, 60, &[u8::from(d(0) != 0.0)])?;
         }
         // A popup: the default again as `u16` at 62 (the item count is at 60).
         7 => {
             let sel = d(0).round().clamp(0.0, f64::from(u16::MAX));
-            put(&mut b, 56, &(sel as u32).to_be_bytes());
-            put(&mut b, 62, &(sel as u16).to_be_bytes());
+            put(&mut b, 56, &(sel as u32).to_be_bytes())?;
+            put(&mut b, 62, &(sel as u16).to_be_bytes())?;
         }
         6 => {
             // Fractions of the layer at 56 / 60 and the same in percent at 68 / 72.
-            put(&mut b, 56, &fixed(d(0)));
-            put(&mut b, 60, &fixed(d(1)));
-            put(&mut b, 68, &fixed(d(0) * 100.0));
-            put(&mut b, 72, &fixed(d(1) * 100.0));
+            put(&mut b, 56, &fixed(d(0)))?;
+            put(&mut b, 60, &fixed(d(1)))?;
+            put(&mut b, 68, &fixed(d(0) * 100.0))?;
+            put(&mut b, 72, &fixed(d(1) * 100.0))?;
         }
         5 => {
             // ARGB at 56 and the same at 60.
             let c: Vec<u8> = (0..4).map(|i| d(i).round().clamp(0.0, 255.0) as u8).collect();
-            put(&mut b, 56, &c);
-            put(&mut b, 60, &c);
+            put(&mut b, 56, &c)?;
+            put(&mut b, 60, &c)?;
         }
         _ => {}
     }
     if p.code == 7 {
         let n = popup_items.unwrap_or_else(|| u16::try_from(p.display).unwrap_or(0));
-        put(&mut b, 60, &n.to_be_bytes());
+        put(&mut b, 60, &n.to_be_bytes())?;
     }
     match p.code {
         10 => {
             if let Some(m) = p.valid_min {
-                put(&mut b, 104, &(m as f32).to_be_bytes());
+                put(&mut b, 104, &(m as f32).to_be_bytes())?;
             }
             if let Some(m) = p.valid_max {
-                put(&mut b, 108, &(m as f32).to_be_bytes());
+                put(&mut b, 108, &(m as f32).to_be_bytes())?;
             }
             if let Some((lo, hi)) = p.range {
-                put(&mut b, 112, &(lo as f32).to_be_bytes());
-                put(&mut b, 116, &(hi as f32).to_be_bytes());
+                put(&mut b, 112, &(lo as f32).to_be_bytes())?;
+                put(&mut b, 116, &(hi as f32).to_be_bytes())?;
             }
         }
         1 | 2 => {
             let enc = |v: f64| if p.code == 2 { fixed(v) } else { (v.round() as i32).to_be_bytes() };
             if let Some(m) = p.valid_min {
-                put(&mut b, 124, &enc(m));
+                put(&mut b, 124, &enc(m))?;
             }
             if let Some(m) = p.valid_max {
-                put(&mut b, 128, &enc(m));
+                put(&mut b, 128, &enc(m))?;
             }
             if let Some((lo, hi)) = p.range {
-                put(&mut b, 132, &enc(lo));
-                put(&mut b, 136, &enc(hi));
+                put(&mut b, 132, &enc(lo))?;
+                put(&mut b, 136, &enc(hi))?;
             }
             // The default again at 140, the display word (decimals, percent) at 144.
-            put(&mut b, 140, &enc(d(0)));
-            put(&mut b, 144, &p.display.to_be_bytes());
+            put(&mut b, 140, &enc(d(0)))?;
+            put(&mut b, 144, &p.display.to_be_bytes())?;
         }
         _ => {}
     }
-    b
+    Ok(b)
 }
 
 /// The default arbitrary data of an effect (its type-11 parameter), from the decoded layouts
@@ -224,7 +223,7 @@ fn data_record(data: Vec<u8>) -> [Chunk<'static>; 2] {
 /// group (records only for layer parameters, groups, buttons and arbitrary data, the built-in
 /// group) and `pgui` (zero).
 pub(crate) fn default_sspc(fx: &FxDef) -> Chunk<'static> {
-    let fnam = Chunk { id: *b"fnam", body: crate::Body::Chunks(vec![Chunk::data(*b"Utf8", fx.name.as_bytes().to_vec())]), pad: None };
+    let fnam = utf8_in(*b"fnam", fx.name);
     let count = u32::try_from(fx.params.len()).unwrap_or(u32::MAX);
     let mut part = vec![Chunk::data(*b"parn", count.to_be_bytes().to_vec())];
     let mut values = vec![Chunk::data(*b"tdsb", 1u32.to_be_bytes().to_vec()), tdsn(NO_NAME)];
@@ -235,11 +234,11 @@ pub(crate) fn default_sspc(fx: &FxDef) -> Chunk<'static> {
         if matches!(p.code, 4 | 7 | 15) {
             // Checkboxes, popups and buttons have a `pdnm` (their label or items); its text may
             // be empty.
-            part.push(Chunk { id: *b"pdnm", body: crate::Body::Chunks(vec![Chunk::data(*b"Utf8", Vec::new())]), pad: None });
+            part.push(utf8_in(*b"pdnm", ""));
         }
         if p.id == BUILT_IN {
             values.push(tdmn(&record));
-            values.push(Chunk::list(*b"tdgp", vec![Chunk::data(*b"tdsb", 1u32.to_be_bytes().to_vec()), tdsn(NO_NAME), tdmn("ADBE Group End")]));
+            values.push(Chunk::list(*b"tdgp", vec![Chunk::data(*b"tdsb", 1u32.to_be_bytes().to_vec()), tdsn(NO_NAME), tdmn(GROUP_END)]));
             continue;
         }
         match p.code {
@@ -265,6 +264,22 @@ pub(crate) fn default_sspc(fx: &FxDef) -> Chunk<'static> {
             _ => {}
         }
     }
-    values.push(tdmn("ADBE Group End"));
+    values.push(tdmn(GROUP_END));
     Chunk::list(*b"sspc", vec![fnam, Chunk::list(*b"parT", part), Chunk::list(*b"tdgp", values), Chunk::data(*b"pgui", vec![0u8; 16])])
 }
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use crate::export::fx_defs::FX_DEFS;
+
+    /// The `pard` of every parameter of the effect table fits its 148 bytes.
+    #[test]
+    fn every_parameter_definition_fits() {
+        for fx in FX_DEFS {
+            for (i, p) in fx.params.iter().enumerate() {
+                assert_eq!(try_pard(p, popup_items(fx, i)).map(|b| b.len()).ok(), Some(148), "{} {}", fx.match_name, i);
+            }
+        }
+    }
+}
diff --git a/crates/aep/src/export/keys.rs b/crates/aep/src/export/keys.rs
new file mode 100644
index 000000000..fdcad87c2
--- /dev/null
+++ b/crates/aep/src/export/keys.rs
@@ -0,0 +1,139 @@
+//! Key lists shared by the exporters: the times of a property's keys in the file's units, the
+//! spatial key record, and the rewrite of a key list (`LIST list`: `lhd3` + `ldat`, aep-format.md
+//! 3.5).
+
+use effectcraft_keyframe::Keyframe;
+
+use crate::Chunk;
+use crate::export::plan::KeyPlan;
+use crate::export::report::{Collector, LossCategory};
+use crate::export::timebase::TimeBase;
+use crate::export::tree::{R, child_data, kids_mut, list_mut, put, put_f64, put_u8, put_u16, put_u32, tpl};
+
+/// The keys of a property at their times in the file's units, in time order. A key that does not
+/// fall on the time base is reported as moved; keys that end up at the same time are merged (the
+/// first one is kept) and reported once. `noun` names the key in the report ("key", "path key").
+pub(crate) fn timed_keys<'k>(keys: &'k [Keyframe], tb: &TimeBase, what: &str, noun: &str, col: &mut Collector) -> Vec<(i64, &'k Keyframe)> {
+    let mut timed: Vec<(i64, &Keyframe)> = Vec::with_capacity(keys.len());
+    for k in keys {
+        let (u, inexact) = tb.units(k.time);
+        if inexact {
+            col.lose(LossCategory::RoundedTimes, format!("{what}: {noun} at {:.4} s moved to the time base", k.time.seconds()));
+        }
+        timed.push((u, k));
+    }
+    timed.sort_by_key(|(u, _)| *u);
+    let before = timed.len();
+    timed.dedup_by_key(|(u, _)| *u);
+    if timed.len() != before {
+        col.lose(LossCategory::ApproximatedKeyframes, format!("{what}: {noun}s at the same time were merged"));
+    }
+    timed
+}
+
+/// A key of a point (flags `0x0007`, `u32@8` the automatic tangent switch; the spatial layout of
+/// a 2D Position, 853) or a colour (flags `0x0001`, 854): the temporal ease of a point at 24..55,
+/// then the `n` values at 56 and, for a point, the spatial in and out tangents after them.
+pub(crate) fn spatial_record(k: &KeyPlan, n: usize, point: bool, size: usize) -> R<Vec<u8>> {
+    let mut r = vec![0u8; size];
+    put(&mut r, 0, &k.time.to_be_bytes())?;
+    put_u8(&mut r, 4, k.in_interp)?;
+    put_u8(&mut r, 5, k.out_interp)?;
+    let base: u16 = if point { 0x0007 } else { 0x0001 };
+    put_u16(&mut r, 6, base | (u16::from(k.label) << 6))?;
+    if point {
+        put_u32(&mut r, 8, u32::from(k.spatial_auto))?;
+        let (i, o) = (k.in_ease.first().copied().unwrap_or_default(), k.out_ease.first().copied().unwrap_or_default());
+        put_f64(&mut r, 24, i.speed)?;
+        put_f64(&mut r, 32, i.influence)?;
+        put_f64(&mut r, 40, o.speed)?;
+        put_f64(&mut r, 48, o.influence)?;
+    }
+    for j in 0..n {
+        put_f64(&mut r, 56 + 8 * j, k.value.get(j).copied().unwrap_or(0.0))?;
+        if point {
+            put_f64(&mut r, 56 + 8 * n + 8 * j, k.spatial_in.get(j).copied().unwrap_or(0.0))?;
+            put_f64(&mut r, 56 + 16 * n + 8 * j, k.spatial_out.get(j).copied().unwrap_or(0.0))?;
+        }
+    }
+    Ok(r)
+}
+
+/// Fills a key list (`LIST list`) with `count` records of `size` bytes: the count words of `lhd3`
+/// and `ldat` (added when the list has none).
+pub(crate) fn fill_key_list(list: &mut Chunk<'static>, records: Vec<u8>, count: usize, size: usize) -> R<()> {
+    let n = u32::try_from(count).map_err(|_| tpl("too many keys"))?;
+    let size = u32::try_from(size).map_err(|_| tpl("record size"))?;
+    crate::export::synth::put_key_counts(child_data(list, b"lhd3")?, n, size)?;
+    let kids = kids_mut(list)?;
+    match kids.iter_mut().find(|c| c.is(b"ldat")) {
+        Some(c) => *c = Chunk::data(*b"ldat", records),
+        None => kids.push(Chunk::data(*b"ldat", records)),
+    }
+    Ok(())
+}
+
+/// Rewrites the key list of a keyed property record (`LIST tdbs`), see [`fill_key_list`].
+pub(crate) fn set_key_list(tdbs: &mut Chunk<'static>, records: Vec<u8>, count: usize, size: usize) -> R<()> {
+    fill_key_list(list_mut(tdbs, b"list")?, records, count, size)
+}
+
+/// Puts the key list `list` in the place of the static value (`cdat`) of a property record.
+pub(crate) fn replace_cdat(tdbs: &mut Chunk<'static>, list: Chunk<'static>) -> R<()> {
+    let slot = kids_mut(tdbs)?.iter_mut().find(|c| c.is(b"cdat")).ok_or_else(|| tpl("record without cdat"))?;
+    *slot = list;
+    Ok(())
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use crate::export::synth::key_list;
+
+    #[test]
+    fn a_key_list_is_filled_and_replaces_the_value() {
+        let mut list = Chunk::list(*b"list", vec![Chunk::data(*b"lhd3", vec![0; 52])]);
+        fill_key_list(&mut list, vec![7; 96], 2, 48).unwrap();
+        let h = list.child(b"lhd3").and_then(|c| c.bytes()).unwrap();
+        assert_eq!((h[11], h[19]), (2, 48));
+        assert_eq!(list.child(b"ldat").and_then(|c| c.bytes()).map(<[u8]>::len), Some(96));
+        // A second fill replaces the records instead of adding a second `ldat`.
+        fill_key_list(&mut list, vec![1; 48], 1, 48).unwrap();
+        assert_eq!(list.children().iter().filter(|c| c.is(b"ldat")).count(), 1);
+
+        let mut rec = Chunk::list(*b"tdbs", vec![Chunk::data(*b"tdb4", vec![0; 124]), Chunk::data(*b"cdat", vec![0; 8])]);
+        replace_cdat(&mut rec, key_list(48, 0, Vec::new())).unwrap();
+        assert!(rec.child(b"cdat").is_none() && rec.child_list(b"list").is_some());
+        // A record without a value is an error, not a quiet no-op.
+        assert!(replace_cdat(&mut rec, key_list(48, 0, Vec::new())).is_err());
+        set_key_list(&mut rec, vec![0; 48], 1, 48).unwrap();
+        assert!(set_key_list(&mut Chunk::list(*b"tdbs", Vec::new()), Vec::new(), 0, 48).is_err());
+    }
+
+    #[test]
+    fn a_spatial_record_holds_the_point_layout() {
+        let k = KeyPlan {
+            time: 5,
+            value: vec![1.0, 2.0],
+            in_interp: 2,
+            out_interp: 1,
+            in_ease: Vec::new(),
+            out_ease: Vec::new(),
+            spatial_in: [3.0; 3],
+            spatial_out: [4.0; 3],
+            spatial_auto: true,
+            roving: false,
+            label: 1,
+        };
+        let r = spatial_record(&k, 2, true, 56 + 24 * 2).unwrap();
+        assert_eq!(&r[..12], &[0, 0, 0, 5, 2, 1, 0, 0x47, 0, 0, 0, 1]);
+        assert_eq!(&r[64..72], &2.0f64.to_be_bytes());
+        assert_eq!(&r[96..104], &4.0f64.to_be_bytes());
+        // A colour has no tangents and flags 0x0001.
+        let c = spatial_record(&k, 2, false, 56 + 24 * 2).unwrap();
+        assert_eq!((c[7], c[11]), (0x41, 0));
+        assert!(c[72..].iter().all(|b| *b == 0));
+        // A record shorter than its layout is an error.
+        assert!(spatial_record(&k, 2, true, 64).is_err());
+    }
+}
diff --git a/crates/aep/src/export/masks.rs b/crates/aep/src/export/masks.rs
index 61d8634c4..eb61b0a09 100644
--- a/crates/aep/src/export/masks.rs
+++ b/crates/aep/src/export/masks.rs
@@ -17,9 +17,11 @@ use crate::Chunk;
 use effectcraft_keyframe::{Ease, Interp, ShapePath, Value};
 use effectcraft_project::{FeatherFalloff, GroupKind, Layer, MaskMode, MaskMotionBlur, PropGroup};
 
+use crate::export::keys::{set_key_list, timed_keys};
 use crate::export::plan::{CompPlan, EaseSlot, KeyPlan, LIMIT, cut_name};
 use crate::export::report::{Collector, LossCategory};
-use crate::export::tree::{R, child_data, child_mut, kids_mut, list_mut, put_f32, put_f64, put_i32, put_u8, put_u16, put_u32, tpl};
+use crate::export::synth::GROUP_END;
+use crate::export::tree::{R, child_data, child_mut, fixed, kids_mut, list_mut, put, put_f32, put_f64, put_i32, put_u8, put_u16, put_u32, split_group, tpl};
 
 /// The most vertices one mask path may have (as the importer).
 pub(crate) const MAX_VERTICES: usize = 65_536;
@@ -179,20 +181,7 @@ fn plan_mask(g: &PropGroup, size: (u32, u32), cp: &CompPlan, what: &str, col: &m
     }
     // The path and its keys.
     let mut path_keys: Vec<PathKeyPlan> = Vec::new();
-    let mut keys: Vec<(i64, &effectcraft_keyframe::Keyframe)> = Vec::new();
-    for k in &path_prop.keys {
-        let (u, inexact) = cp.tb.units(k.time);
-        if inexact {
-            col.lose(LossCategory::RoundedTimes, format!("{what}: path key at {:.4} s moved to the time base", k.time.seconds()));
-        }
-        keys.push((u, k));
-    }
-    keys.sort_by_key(|(u, _)| *u);
-    let before = keys.len();
-    keys.dedup_by_key(|(u, _)| *u);
-    if keys.len() != before {
-        col.lose(LossCategory::ApproximatedKeyframes, format!("{what}: path keys at the same time were merged"));
-    }
+    let keys = timed_keys(&path_prop.keys, &cp.tb, what, "path key", col);
     let side = |i: Interp| -> u8 {
         match i {
             Interp::Linear => 1,
@@ -288,20 +277,7 @@ fn plan_mask(g: &PropGroup, size: (u32, u32), cp: &CompPlan, what: &str, col: &m
 
 /// Feather keys (plain template, two components, speed in pixels per second).
 fn plan_feather_keys(src: &[effectcraft_keyframe::Keyframe], cp: &CompPlan, what: &str, col: &mut Collector) -> Vec<KeyPlan> {
-    let mut keys: Vec<(i64, &effectcraft_keyframe::Keyframe)> = Vec::with_capacity(src.len());
-    for k in src {
-        let (u, inexact) = cp.tb.units(k.time);
-        if inexact {
-            col.lose(LossCategory::RoundedTimes, format!("{what}: feather key at {:.4} s moved to the time base", k.time.seconds()));
-        }
-        keys.push((u, k));
-    }
-    keys.sort_by_key(|(u, _)| *u);
-    let before = keys.len();
-    keys.dedup_by_key(|(u, _)| *u);
-    if keys.len() != before {
-        col.lose(LossCategory::ApproximatedKeyframes, format!("{what}: feather keys at the same time were merged"));
-    }
+    let keys = timed_keys(src, &cp.tb, what, "feather key", col);
     let mut out = Vec::with_capacity(keys.len());
     let beyond = std::cell::Cell::new(false);
     for (u, k) in &keys {
@@ -381,11 +357,6 @@ pub(crate) struct MaskProtos {
     pub keyed_feather: Chunk<'static>,
 }
 
-pub(crate) fn tdmn_name(c: &Chunk<'_>) -> Option<String> {
-    let d = c.bytes()?;
-    Some(d.iter().take_while(|b| **b != 0).map(|b| char::from(*b)).collect())
-}
-
 /// The limit of a mask's feather and expansion (`tduM` 32 000, 091).
 const MASK_LIMIT: f64 = 32_000.0;
 
@@ -394,10 +365,26 @@ const MASK_LIMIT: f64 = 32_000.0;
 /// s13-m1), byte 3 `0x01` (`0x09` once the path is open), the box at 4..19 (written per shape),
 /// byte 20 1.
 pub(crate) fn shph() -> Vec<u8> {
+    fixed("shph", try_shph(), || vec![0u8; 24])
+}
+
+fn try_shph() -> R<Vec<u8>> {
     let mut b = vec![0u8; 24];
-    let _ = crate::export::tree::put(&mut b, 0, &[0xb3, 0xde, 0x02, 0x01]);
-    let _ = put_u8(&mut b, 20, 1);
-    b
+    put(&mut b, 0, &[0xb3, 0xde, 0x02, 0x01])?;
+    put_u8(&mut b, 20, 1)?;
+    Ok(b)
+}
+
+/// The two prototype records of a keyed path (093): 64 bytes each, flags `0x0001`, the `f64` at
+/// 16 1 in the first (the rest is zero: its last bytes were uninitialised).
+fn path_key_records() -> R<Vec<u8>> {
+    let mut first = vec![0u8; 64];
+    let mut later = vec![0u8; 64];
+    for r in [&mut first, &mut later] {
+        put_u16(r, 6, 0x0001)?;
+    }
+    put_f64(&mut first, 16, 1.0)?;
+    Ok([first, later].concat())
 }
 
 impl MaskProtos {
@@ -413,15 +400,7 @@ impl MaskProtos {
         let path_rec = |keyed: bool| {
             let mut kids = vec![state(), tdsn(NO_NAME), Chunk::data(*b"tdb4", tdb4(&path, keyed, 25_600))];
             if keyed {
-                // Path keys are 64-byte records: flags `0x0001`, the `f64` at 16 1 on the first
-                // key (093; the rest of the record is zero: its last bytes were uninitialised).
-                let mut first = vec![0u8; 64];
-                let mut later = vec![0u8; 64];
-                for r in [&mut first, &mut later] {
-                    let _ = put_u16(r, 6, 0x0001);
-                }
-                let _ = put_f64(&mut first, 16, 1.0);
-                kids.push(key_list(64, 2, [first, later].concat()));
+                kids.push(key_list(64, 2, fixed("keyed path", path_key_records(), || vec![0u8; 128])));
             } else {
                 kids.push(Chunk::data(*b"cdat", vec![0u8; 4]));
             }
@@ -444,7 +423,7 @@ impl MaskProtos {
                 tdbs(&opacity, false, 25_600),
                 tdmn("ADBE Mask Offset"),
                 tdbs(&offset, false, 25_600),
-                tdmn("ADBE Group End"),
+                tdmn(GROUP_END),
             ],
         );
         MaskProtos {
@@ -453,7 +432,7 @@ impl MaskProtos {
             atom_name: tdmn("ADBE Mask Atom"),
             mkif: Chunk::data(*b"mkif", vec![0u8; 48]),
             atom,
-            group_end: tdmn("ADBE Group End"),
+            group_end: tdmn(GROUP_END),
             keyed_path: path_rec(true),
             keyed_feather: tdbs(&feather, true, 25_600),
         }
@@ -485,24 +464,16 @@ fn build_atom(t: &MaskProtos, m: &MaskPlan, size: (u32, u32)) -> R<Chunk<'static
         let tdsn = child_mut(&mut atom, b"tdsn")?;
         crate::export::tree::set_utf8(tdsn, &m.name)?;
     }
-    let kids = kids_mut(&mut atom)?;
-    let first = kids.iter().position(|c| c.is(b"tdmn")).ok_or_else(|| tpl("empty mask atom"))?;
-    let header: Vec<Chunk<'static>> = kids.drain(..first).collect();
-    let mut pairs: Vec<(String, [Chunk<'static>; 2])> = Vec::new();
-    let mut end: Option<Chunk<'static>> = None;
-    let mut it = std::mem::take(kids).into_iter();
-    while let Some(c) = it.next() {
-        let name = tdmn_name(&c).unwrap_or_default();
-        if name == "ADBE Group End" {
-            end = Some(c);
-            continue;
-        }
-        let node = it.next().ok_or_else(|| tpl("mask match name without a node"))?;
-        pairs.push((name, [c, node]));
-    }
-    let end = end.ok_or_else(|| tpl("mask atom without its end"))?;
-    let mut out = header;
-    for (name, [tdmn, mut node]) in pairs {
+    let (mut out, entries) = split_group(kids_mut(&mut atom)?)?;
+    for (name, entry) in entries {
+        // The closing Group End (no node) is kept as it is.
+        let [tdmn, mut node]: [Chunk<'static>; 2] = match entry.try_into() {
+            Ok(pair) => pair,
+            Err(end) => {
+                out.extend(end);
+                continue;
+            }
+        };
         let keep = match name.as_str() {
             "ADBE Mask Shape" => {
                 build_shape(t, &mut node, m, size)?;
@@ -540,7 +511,6 @@ fn build_atom(t: &MaskProtos, m: &MaskPlan, size: (u32, u32)) -> R<Chunk<'static
             out.push(node);
         }
     }
-    out.push(end);
     *kids_mut(&mut atom)? = out;
     Ok(atom)
 }
@@ -554,22 +524,6 @@ fn set_cdat(tdbs: &mut Chunk<'static>, values: &[f64]) -> R<()> {
     Ok(())
 }
 
-/// Rewrites a key list (`lhd3` count words and `ldat`).
-fn set_key_list(tdbs: &mut Chunk<'static>, records: Vec<u8>, count: usize, size: usize) -> R<()> {
-    let list = list_mut(tdbs, b"list")?;
-    let n = u32::try_from(count).map_err(|_| tpl("too many keys"))?;
-    {
-        let lhd3 = child_data(list, b"lhd3")?;
-        crate::export::synth::put_key_counts(lhd3, n, u32::try_from(size).map_err(|_| tpl("record size"))?)?;
-    }
-    let ld = kids_mut(list)?;
-    match ld.iter_mut().find(|c| c.is(b"ldat")) {
-        Some(c) => *c = Chunk::data(*b"ldat", records),
-        None => ld.push(Chunk::data(*b"ldat", records)),
-    }
-    Ok(())
-}
-
 fn keyed_feather(t: &MaskProtos, keys: &[KeyPlan]) -> R<Chunk<'static>> {
     let mut tdbs = t.keyed_feather.clone();
     // The plain template with two components (208): 8 + 40 * 2 bytes.
diff --git a/crates/aep/src/export/shapes.rs b/crates/aep/src/export/shapes.rs
index 74cd49d5b..981286604 100644
--- a/crates/aep/src/export/shapes.rs
+++ b/crates/aep/src/export/shapes.rs
@@ -24,10 +24,12 @@ use crate::Chunk;
 use effectcraft_keyframe::{Gradient, Interp, Keyframe, Value};
 use effectcraft_project::{Node, PropGroup, Property};
 
+use crate::export::keys::{fill_key_list, replace_cdat, spatial_record, timed_keys};
 use crate::export::masks::ShapePlan;
 use crate::export::plan::{CompPlan, EaseSlot, KeyPlan};
 use crate::export::report::{Collector, LossCategory};
-use crate::export::tree::{R, child_data, kids_mut, list_mut, put, put_f64, put_u8, put_u16, put_u32, set_utf8, tpl};
+use crate::export::synth::{GROUP_END, is_tdmn, tdmn};
+use crate::export::tree::{R, child_data, kids_mut, list_mut, put_f64, put_u8, set_utf8, tpl};
 
 /// The deepest group nesting written.
 const MAX_DEPTH: usize = 16;
@@ -192,7 +194,7 @@ impl ShapeProtos {
             put_f64(child_data(&mut node, b"tdum")?, 0, lo)?;
             put_f64(child_data(&mut node, b"tduM")?, 0, hi)?;
         }
-        Ok([crate::export::camlight::tdmn_chunk(name), node])
+        Ok([tdmn(name), node])
     }
 }
 
@@ -267,20 +269,7 @@ pub(crate) struct ShCx<'a> {
 
 /// The keys of `p` in the file's units.
 fn plan_keys(p: &Property, conv: Conv, layout: Layout, what: &str, cx: &mut ShCx<'_>) -> Vec<KeyPlan> {
-    let mut timed: Vec<(i64, &Keyframe)> = Vec::with_capacity(p.keys.len());
-    for k in &p.keys {
-        let (u, inexact) = cx.cp.tb.units(k.time);
-        if inexact {
-            cx.col.lose(LossCategory::RoundedTimes, format!("{what}: key at {:.4} s moved to the time base", k.time.seconds()));
-        }
-        timed.push((u, k));
-    }
-    timed.sort_by_key(|(u, _)| *u);
-    let before = timed.len();
-    timed.dedup_by_key(|(u, _)| *u);
-    if timed.len() != before {
-        cx.col.lose(LossCategory::ApproximatedKeyframes, format!("{what}: keys at the same time were merged"));
-    }
+    let timed = timed_keys(&p.keys, &cx.cp.tb, what, "key", cx.col);
     let all: Vec<Keyframe> = timed.iter().map(|(_, k)| (*k).clone()).collect();
     let mut out = Vec::with_capacity(timed.len());
     let beyond = std::cell::Cell::new(false);
@@ -618,38 +607,6 @@ pub(crate) fn plan_contents(contents: &PropGroup, what: &str, depth: usize, cx:
     out
 }
 
-fn tdmn_name(c: &Chunk<'_>) -> Option<String> {
-    let b = c.bytes()?;
-    let end = b.iter().position(|x| *x == 0).unwrap_or(b.len());
-    std::str::from_utf8(b.get(..end)?).ok().map(str::to_string)
-}
-
-/// A key of a point (the spatial layout of a 2D Position, 853) or a colour (854).
-fn spatial_key(k: &KeyPlan, n: usize, point: bool, size: usize) -> R<Vec<u8>> {
-    let mut r = vec![0u8; size];
-    put(&mut r, 0, &k.time.to_be_bytes())?;
-    put_u8(&mut r, 4, k.in_interp)?;
-    put_u8(&mut r, 5, k.out_interp)?;
-    let base: u16 = if point { 0x0007 } else { 0x0001 };
-    put_u16(&mut r, 6, base | (u16::from(k.label) << 6))?;
-    if point {
-        put_u32(&mut r, 8, u32::from(k.spatial_auto))?;
-        let (i, o) = (k.in_ease.first().copied().unwrap_or_default(), k.out_ease.first().copied().unwrap_or_default());
-        put_f64(&mut r, 24, i.speed)?;
-        put_f64(&mut r, 32, i.influence)?;
-        put_f64(&mut r, 40, o.speed)?;
-        put_f64(&mut r, 48, o.influence)?;
-    }
-    for j in 0..n {
-        put_f64(&mut r, 56 + 8 * j, k.value.get(j).copied().unwrap_or(0.0))?;
-        if point {
-            put_f64(&mut r, 56 + 8 * n + 8 * j, k.spatial_in.get(j).copied().unwrap_or(0.0))?;
-            put_f64(&mut r, 56 + 16 * n + 8 * j, k.spatial_out.get(j).copied().unwrap_or(0.0))?;
-        }
-    }
-    Ok(r)
-}
-
 /// The value record of `name` holding `v`.
 fn value_record(t: &ShapeProtos, name: &'static str, v: &RecVal) -> R<[Chunk<'static>; 2]> {
     let [m, node] = t.record(name)?;
@@ -681,32 +638,17 @@ pub(crate) fn build_record(m: Chunk<'static>, mut node: Chunk<'static>, layout:
                 put_u8(tdb4, 79, 0)?;
             }
         }
-        let mut list = key_list.clone();
-        let count = u32::try_from(v.keys.len()).map_err(|_| tpl("too many keys"))?;
-        {
-            let lhd3 = child_data(&mut list, b"lhd3")?;
-            crate::export::synth::put_key_counts(lhd3, count, u32::try_from(size).map_err(|_| tpl("record size"))?)?;
-        }
         let mut ldat = Vec::with_capacity(size * v.keys.len());
         for k in &v.keys {
             ldat.extend(match layout {
-                Layout::Point => spatial_key(k, n, true, size)?,
-                Layout::Color => spatial_key(k, n, false, size)?,
+                Layout::Point => spatial_record(k, n, true, size)?,
+                Layout::Color => spatial_record(k, n, false, size)?,
                 _ => crate::export::emit::plain_record(n, k, size)?,
             });
         }
-        {
-            let lk = kids_mut(&mut list)?;
-            match lk.iter_mut().find(|c| c.is(b"ldat")) {
-                Some(c) => *c = Chunk::data(*b"ldat", ldat),
-                None => lk.push(Chunk::data(*b"ldat", ldat)),
-            }
-        }
-        let kids = kids_mut(&mut node)?;
-        let at = kids.iter().position(|c| c.is(b"cdat")).ok_or_else(|| tpl("shape record without cdat"))?;
-        if let Some(slot) = kids.get_mut(at) {
-            *slot = list;
-        }
+        let mut list = key_list.clone();
+        fill_key_list(&mut list, ldat, v.keys.len(), size)?;
+        replace_cdat(&mut node, list)?;
     }
     if let Some((text, enabled)) = &v.expr {
         // As on the Transform properties (R15; 856).
@@ -746,7 +688,7 @@ pub(crate) fn build_items(t: &ShapeProtos, items: &[ShItem], depth: usize) -> R<
     if depth > MAX_DEPTH {
         return Ok(out);
     }
-    let pos = |kids: &[Chunk<'static>], n: &str| kids.iter().position(|c| c.is(b"tdmn") && tdmn_name(c).as_deref() == Some(n));
+    let pos = |kids: &[Chunk<'static>], n: &str| kids.iter().position(|c| is_tdmn(c, n));
     for item in items {
         match item {
             ShItem::Off(inner) => {
@@ -766,7 +708,7 @@ pub(crate) fn build_items(t: &ShapeProtos, items: &[ShItem], depth: usize) -> R<
                 let vg = pos(kids, "ADBE Vectors Group").ok_or_else(|| tpl("group prototype without contents"))?;
                 let contents = kids.get_mut(vg + 1).ok_or_else(|| tpl("group prototype without contents"))?;
                 let ck = kids_mut(contents)?;
-                let end = ck.iter().position(|c| c.is(b"tdmn") && tdmn_name(c).as_deref() == Some("ADBE Group End")).unwrap_or(ck.len());
+                let end = ck.iter().position(|c| is_tdmn(c, GROUP_END)).unwrap_or(ck.len());
                 ck.splice(end..end, children);
                 let tg = pos(kids, "ADBE Vector Transform Group").ok_or_else(|| tpl("group prototype without transform"))?;
                 let tnode = kids.get_mut(tg + 1).ok_or_else(|| tpl("group prototype without transform"))?;
@@ -815,13 +757,10 @@ pub(crate) fn put_contents(layr: &mut Chunk<'static>, t: &ShapeProtos, items: &[
     let built = build_items(t, items, 0)?;
     let root = list_mut(layr, b"tdgp")?;
     let kids = kids_mut(root)?;
-    let at = kids
-        .iter()
-        .position(|c| c.is(b"tdmn") && tdmn_name(c).as_deref() == Some("ADBE Root Vectors Group"))
-        .ok_or_else(|| tpl("shape layer without contents"))?;
+    let at = kids.iter().position(|c| is_tdmn(c, "ADBE Root Vectors Group")).ok_or_else(|| tpl("shape layer without contents"))?;
     let rv = kids.get_mut(at + 1).ok_or_else(|| tpl("shape layer without contents"))?;
     let rk = kids_mut(rv)?;
-    let end = rk.iter().position(|c| c.is(b"tdmn") && tdmn_name(c).as_deref() == Some("ADBE Group End")).unwrap_or(rk.len());
+    let end = rk.iter().position(|c| is_tdmn(c, GROUP_END)).unwrap_or(rk.len());
     rk.splice(end..end, built);
     Ok(())
 }
diff --git a/crates/aep/src/export/skeleton.rs b/crates/aep/src/export/skeleton.rs
index 037b4d865..38a2c17ab 100644
--- a/crates/aep/src/export/skeleton.rs
+++ b/crates/aep/src/export/skeleton.rs
@@ -4,14 +4,14 @@
 //! e1-sparse).
 
 use crate::Chunk;
-use crate::export::synth::{KeyTemplate, NO_NAME, RecSpec, class, tdbs, tdmn, tdsn};
+use crate::export::synth::{GROUP_END, KeyTemplate, NO_NAME, RecSpec, class, tdbs, tdmn, tdmn_name, tdsn};
 
 /// A group: its match name and a `tdgp` with the state `state` (`tdsb`), no user name, `kids` and
 /// the closing `ADBE Group End`.
 pub(crate) fn group(name: &str, state: u32, kids: Vec<Chunk<'static>>) -> [Chunk<'static>; 2] {
     let mut body = vec![Chunk::data(*b"tdsb", state.to_be_bytes().to_vec()), tdsn(NO_NAME)];
     body.extend(kids);
-    body.push(tdmn("ADBE Group End"));
+    body.push(tdmn(GROUP_END));
     [tdmn(name), Chunk::list(*b"tdgp", body)]
 }
 
@@ -61,7 +61,7 @@ pub(crate) fn av_layer() -> Vec<Chunk<'static>> {
     let mut root = vec![Chunk::data(*b"tdsb", 1u32.to_be_bytes().to_vec()), tdsn(""), tdmn("ADBE Time Remapping"), time_remap()];
     root.extend(group("ADBE Transform Group", 1, crate::export::tree_spec::build(crate::export::tree_defs::AV_TRANSFORM)));
     root.extend(layer_styles());
-    root.push(tdmn("ADBE Group End"));
+    root.push(tdmn(GROUP_END));
     let layr = Chunk::list(
         *b"Layr",
         vec![Chunk::data(*b"ldta", vec![0; 164]), Chunk::data(*b"Utf8", Vec::new()), Chunk::list(*b"tdgp", root), crate::export::base::guides()],
@@ -78,7 +78,7 @@ pub(crate) fn av_layer() -> Vec<Chunk<'static>> {
 pub(crate) fn layer_block(nodes: &[crate::export::tree_spec::Node]) -> Vec<Chunk<'static>> {
     let mut root = vec![Chunk::data(*b"tdsb", 1u32.to_be_bytes().to_vec()), tdsn("")];
     root.extend(crate::export::tree_spec::build(nodes));
-    root.push(tdmn("ADBE Group End"));
+    root.push(tdmn(GROUP_END));
     let layr = Chunk::list(
         *b"Layr",
         vec![Chunk::data(*b"ldta", vec![0; 164]), Chunk::data(*b"Utf8", Vec::new()), Chunk::list(*b"tdgp", root), crate::export::base::guides()],
@@ -125,7 +125,7 @@ pub(crate) fn text_layer(doc: &[u8]) -> Vec<Chunk<'static>> {
     root.extend(group("ADBE Text Properties", 1, props));
     root.extend(group("ADBE Transform Group", 1, crate::export::tree_spec::build(crate::export::tree_defs::AV_TRANSFORM)));
     root.extend(layer_styles());
-    root.push(tdmn("ADBE Group End"));
+    root.push(tdmn(GROUP_END));
     let layr = Chunk::list(
         *b"Layr",
         vec![Chunk::data(*b"ldta", vec![0; 164]), Chunk::data(*b"Utf8", Vec::new()), Chunk::list(*b"tdgp", root), crate::export::base::guides()],
@@ -141,7 +141,7 @@ pub(crate) fn pairs(nodes: &[crate::export::tree_spec::Node]) -> Vec<(String, [C
     let mut out = Vec::new();
     let mut it = crate::export::tree_spec::build(nodes).into_iter();
     while let (Some(m), Some(n)) = (it.next(), it.next()) {
-        let name = String::from_utf8_lossy(m.bytes().unwrap_or_default().split(|b| *b == 0).next().unwrap_or_default()).into_owned();
+        let name = tdmn_name(&m).unwrap_or_default();
         out.push((name, [m, n]));
     }
     out
diff --git a/crates/aep/src/export/styles.rs b/crates/aep/src/export/styles.rs
index 4b8cb51f1..1533de7b9 100644
--- a/crates/aep/src/export/styles.rs
+++ b/crates/aep/src/export/styles.rs
@@ -23,8 +23,10 @@ use effectcraft_project::build::Ids;
 use effectcraft_project::styles::{self as st, STYLE_BLEND_MODES};
 use effectcraft_project::{Comp, Layer, PropGroup, Property};
 
+use crate::export::keys::{fill_key_list, replace_cdat, timed_keys};
 use crate::export::plan::{CompPlan, EaseSlot, KeyPlan};
 use crate::export::report::{Collector, LossCategory};
+use crate::export::synth::{GROUP_END, is_tdmn};
 use crate::export::tree::{R, child_data, kids_mut, put_f64, put_u8, put_u32, tpl};
 
 /// A record's value.
@@ -128,20 +130,7 @@ fn plan_record(spec: &StyleParam, full: String, prop: &Property, cp: &CompPlan,
 /// The keys of a scalar in the layer's time base: linear, hold and bezier sides with the ease in
 /// stored units per second (the plain template of 976).
 fn plan_number_keys(prop: &Property, cp: &CompPlan, what: &str, col: &mut Collector) -> Vec<KeyPlan> {
-    let mut timed: Vec<(i64, &effectcraft_keyframe::Keyframe)> = Vec::with_capacity(prop.keys.len());
-    for k in &prop.keys {
-        let (u, inexact) = cp.tb.units(k.time);
-        if inexact {
-            col.lose(LossCategory::RoundedTimes, format!("{what}: key at {:.4} s moved to the time base", k.time.seconds()));
-        }
-        timed.push((u, k));
-    }
-    timed.sort_by_key(|(u, _)| *u);
-    let before = timed.len();
-    timed.dedup_by_key(|(u, _)| *u);
-    if timed.len() != before {
-        col.lose(LossCategory::ApproximatedKeyframes, format!("{what}: keys at the same time were merged"));
-    }
+    let timed = timed_keys(&prop.keys, &cp.tb, what, "key", col);
     let mut out = Vec::with_capacity(timed.len());
     let beyond = std::cell::Cell::new(false);
     for (u, k) in timed {
@@ -279,11 +268,6 @@ pub(crate) struct StyleProtos {
     keyed: Chunk<'static>,
 }
 
-fn tdmn_name(c: &Chunk<'_>) -> Option<String> {
-    let d = c.bytes()?;
-    Some(d.iter().take_while(|b| **b != 0).map(|b| char::from(*b)).collect())
-}
-
 impl StyleProtos {
     /// The records built in code from the style table (`style_defs`); the keyed form of a scalar
     /// takes `tdb4` bytes 5, 68 and 79 and the key list of a keyed one-component record.
@@ -322,28 +306,13 @@ impl StyleProtos {
                     }
                 }
                 let mut list = self.keyed.child_list(b"list").cloned().ok_or_else(|| tpl("keyed style prototype without keys"))?;
-                let n = u32::try_from(keys.len()).map_err(|_| tpl("too many keys"))?;
                 let size = 48usize;
-                {
-                    let lhd3 = child_data(&mut list, b"lhd3")?;
-                    crate::export::synth::put_key_counts(lhd3, n, 48)?;
-                }
                 let mut ldat = Vec::with_capacity(size * keys.len());
                 for k in keys {
                     ldat.extend(crate::export::emit::plain_record(1, k, size)?);
                 }
-                {
-                    let lk = kids_mut(&mut list)?;
-                    match lk.iter_mut().find(|c| c.is(b"ldat")) {
-                        Some(c) => *c = Chunk::data(*b"ldat", ldat),
-                        None => lk.push(Chunk::data(*b"ldat", ldat)),
-                    }
-                }
-                let kids = kids_mut(&mut rec)?;
-                let at = kids.iter().position(|c| c.is(b"cdat")).ok_or_else(|| tpl("style record without cdat"))?;
-                if let Some(slot) = kids.get_mut(at) {
-                    *slot = list;
-                }
+                fill_key_list(&mut list, ldat, keys.len(), size)?;
+                replace_cdat(&mut rec, list)?;
             }
         }
         if let Some((text, enabled)) = &r.expr {
@@ -362,7 +331,7 @@ impl StyleProtos {
 
 /// The node after the `tdmn` named `name` among `kids`.
 fn named_mut<'a>(kids: &'a mut [Chunk<'static>], name: &str) -> R<&'a mut Chunk<'static>> {
-    let i = kids.iter().position(|c| c.is(b"tdmn") && tdmn_name(c).as_deref() == Some(name)).ok_or_else(|| tpl("layer styles group incomplete"))?;
+    let i = kids.iter().position(|c| is_tdmn(c, name)).ok_or_else(|| tpl("layer styles group incomplete"))?;
     kids.get_mut(i + 1).ok_or_else(|| tpl("layer styles group incomplete"))
 }
 
@@ -377,7 +346,7 @@ fn insert_records(protos: &StyleProtos, g: &mut Chunk<'static>, recs: &[Record],
         built.extend(protos.build(r)?);
     }
     let kids = kids_mut(g)?;
-    let at = kids.iter().position(|c| c.is(b"tdmn") && tdmn_name(c).as_deref() == Some(before)).ok_or_else(|| tpl("layer styles group incomplete"))?;
+    let at = kids.iter().position(|c| is_tdmn(c, before)).ok_or_else(|| tpl("layer styles group incomplete"))?;
     kids.splice(at..at, built);
     Ok(())
 }
@@ -392,12 +361,12 @@ pub(crate) fn put_styles(protos: &StyleProtos, layr: &mut Chunk<'static>, plan:
         set_flags(bo, sm::FLAGS_ON)?;
         insert_records(protos, bo, &plan.global, sm::ADV_BLEND)?;
         let adv = named_mut(kids_mut(bo)?, sm::ADV_BLEND)?;
-        insert_records(protos, adv, &plan.adv, "ADBE Group End")?;
+        insert_records(protos, adv, &plan.adv, GROUP_END)?;
     }
     for (prefix, recs, on) in &plan.styles {
         let g = named_mut(kids_mut(ls)?, &format!("{prefix}/enabled"))?;
         set_flags(g, if *on { sm::FLAGS_ON } else { sm::FLAGS_OFF })?;
-        insert_records(protos, g, recs, "ADBE Group End")?;
+        insert_records(protos, g, recs, GROUP_END)?;
     }
     Ok(())
 }
diff --git a/crates/aep/src/export/synth.rs b/crates/aep/src/export/synth.rs
index 07d75c194..3517c41d2 100644
--- a/crates/aep/src/export/synth.rs
+++ b/crates/aep/src/export/synth.rs
@@ -4,9 +4,10 @@
 //! evidence, or zero where After Effects was shown to accept zero (the read-backs listed in
 //! `docs/aep-export.md`, "Built in code").
 
+use crate::export::tree::{R, fixed, put, put_u32};
 use crate::{Body, Chunk};
 
-/// `tdmn`: a match name padded to 40 bytes.
+/// `tdmn`: a match name padded to 40 bytes (at most 39 bytes of the name, so that a NUL remains).
 pub(crate) fn tdmn(name: &str) -> Chunk<'static> {
     let mut b = vec![0u8; 40];
     for (slot, c) in b.iter_mut().zip(name.bytes().take(39)) {
@@ -15,12 +16,34 @@ pub(crate) fn tdmn(name: &str) -> Chunk<'static> {
     Chunk::data(*b"tdmn", b)
 }
 
+/// The match name that closes a property group.
+pub(crate) const GROUP_END: &str = "ADBE Group End";
+
+/// The match name in a `tdmn`: the bytes up to the first NUL as UTF-8, invalid sequences
+/// replaced, as the importer reads it (`container::typed`). After Effects writes ASCII here
+/// (aep-format.md 3.4; every `tdmn` of the corpus is ASCII); `None` when `c` is not a data chunk.
+pub(crate) fn tdmn_name(c: &Chunk<'_>) -> Option<String> {
+    let b = c.bytes()?;
+    let end = b.iter().position(|x| *x == 0).unwrap_or(b.len());
+    Some(String::from_utf8_lossy(b.get(..end)?).into_owned())
+}
+
+/// Whether `c` is a `tdmn` naming `name`.
+pub(crate) fn is_tdmn(c: &Chunk<'_>, name: &str) -> bool {
+    c.is(b"tdmn") && tdmn_name(c).as_deref() == Some(name)
+}
+
 /// The user name of a property that has none (`-_0_/-`, aep-format.md 3.4).
 pub(crate) const NO_NAME: &str = "-_0_/-";
 
 /// `tdsn`: the user name, a nested chunk holding one `Utf8`.
 pub(crate) fn tdsn(name: &str) -> Chunk<'static> {
-    Chunk { id: *b"tdsn", body: Body::Chunks(vec![Chunk::data(*b"Utf8", name.as_bytes().to_vec())]), pad: None }
+    utf8_in(*b"tdsn", name)
+}
+
+/// A nested chunk `id` holding one `Utf8` with `text` (`tdsn`, `fnam`, `pdnm`).
+pub(crate) fn utf8_in(id: [u8; 4], text: &str) -> Chunk<'static> {
+    Chunk { id, body: Body::Chunks(vec![Chunk::data(*b"Utf8", text.as_bytes().to_vec())]), pad: None }
 }
 
 /// How a property's keys are stored (`tdb4` byte 7, aep-format.md 3.5).
@@ -100,13 +123,12 @@ impl RecSpec {
 /// word and the constant doubles at 16..56 are written; After Effects reads the other bytes as
 /// zero (read-back e1-ztdb4d).
 pub(crate) fn tdb4(spec: &RecSpec, keyed: bool, time_scale: u32) -> Vec<u8> {
+    fixed("tdb4", try_tdb4(spec, keyed, time_scale), || vec![0u8; 124])
+}
+
+fn try_tdb4(spec: &RecSpec, keyed: bool, time_scale: u32) -> R<Vec<u8>> {
     let mut b = vec![0u8; 124];
-    let set = |b: &mut Vec<u8>, at: usize, bytes: &[u8]| {
-        if let Some(dst) = b.get_mut(at..at + bytes.len()) {
-            dst.copy_from_slice(bytes);
-        }
-    };
-    set(&mut b, 0, &[0xdb, 0x99, 0x00, spec.dims]);
+    put(&mut b, 0, &[0xdb, 0x99, 0x00, spec.dims])?;
     let spatial = match spec.template {
         KeyTemplate::Plain => 0,
         KeyTemplate::Spatial(t) => t,
@@ -115,36 +137,40 @@ pub(crate) fn tdb4(spec: &RecSpec, keyed: bool, time_scale: u32) -> Vec<u8> {
         Some(b) => (b & !0x01) | u8::from(!keyed),
         None => (if spatial == 0 { 0 } else { spatial_byte5(spatial) }) | u8::from(!keyed),
     };
-    set(&mut b, 5, &[byte5]);
-    set(&mut b, 7, &[spatial]);
-    set(&mut b, 8, &spec.class.to_be_bytes());
-    set(&mut b, 12, &time_scale.to_be_bytes());
+    put(&mut b, 5, &[byte5])?;
+    put(&mut b, 7, &[spatial])?;
+    put(&mut b, 8, &spec.class.to_be_bytes())?;
+    put(&mut b, 12, &time_scale.to_be_bytes())?;
     // Every record After Effects writes carries 0.0001 and four 1.0 here; without them a roving
     // key reads back at time zero instead of its retimed place (read-back s14-re-keyframes).
-    set(&mut b, 16, &1e-4f64.to_be_bytes());
+    put(&mut b, 16, &1e-4f64.to_be_bytes())?;
     for at in [24, 32, 40, 48] {
-        set(&mut b, at, &1.0f64.to_be_bytes());
+        put(&mut b, at, &1.0f64.to_be_bytes())?;
     }
-    set(&mut b, 68, &[u8::from(keyed)]);
+    put(&mut b, 68, &[u8::from(keyed)])?;
     // Set on a static spatial property, cleared once it is keyed (aep-format.md 3.4, byte 79).
-    set(&mut b, 79, &[u8::from(spatial != 0 && !keyed)]);
-    b
+    put(&mut b, 79, &[u8::from(spatial != 0 && !keyed)])?;
+    Ok(b)
 }
 
 /// A key list (`LIST list`: `lhd3` + `ldat`) of `count` records of `size` bytes (aep-format.md
 /// 3.5): word 0 `0x00d00bee`, word 2 the count, word 3 the blocks of four (at least one), word 4
 /// the size, words 5 and 7 the capacity (the count rounded up to four, at least two), word 6 one.
 pub(crate) fn key_list(size: u32, count: u32, records: Vec<u8>) -> Chunk<'static> {
-    let mut lhd3 = vec![0u8; 52];
-    // Cannot fail: the header is 52 bytes.
-    let _ = crate::export::tree::put_u32(&mut lhd3, 0, 0x00d0_0bee);
-    let _ = crate::export::tree::put_u32(&mut lhd3, 24, 1);
-    let _ = put_key_counts(&mut lhd3, count, size);
+    let lhd3 = fixed("lhd3", key_list_header(size, count), || vec![0u8; 52]);
     Chunk::list(*b"list", vec![Chunk::data(*b"lhd3", lhd3), Chunk::data(*b"ldat", records)])
 }
 
+fn key_list_header(size: u32, count: u32) -> R<Vec<u8>> {
+    let mut lhd3 = vec![0u8; 52];
+    put_u32(&mut lhd3, 0, 0x00d0_0bee)?;
+    put_u32(&mut lhd3, 24, 1)?;
+    put_key_counts(&mut lhd3, count, size)?;
+    Ok(lhd3)
+}
+
 /// Sets the count words of a key list header for `count` keys of `size` bytes.
-pub(crate) fn put_key_counts(lhd3: &mut [u8], count: u32, size: u32) -> crate::export::tree::R<()> {
+pub(crate) fn put_key_counts(lhd3: &mut [u8], count: u32, size: u32) -> R<()> {
     let capacity = count.div_ceil(4).saturating_mul(4).max(2);
     put_counts(lhd3, count, count.div_ceil(4).max(1), size, capacity, capacity)
 }
@@ -153,8 +179,7 @@ pub(crate) fn put_key_counts(lhd3: &mut [u8], count: u32, size: u32) -> crate::e
 /// record size, word 5 `w5`, word 7 the capacity. A key list has `w5` = the capacity; a path
 /// list counts vertices: `blocks` = `w5` = the vertex count, the capacity four times it (090:
 /// 12 points, 4, 4 and 16; aep-format.md 3.5).
-pub(crate) fn put_counts(lhd3: &mut [u8], count: u32, blocks: u32, size: u32, w5: u32, capacity: u32) -> crate::export::tree::R<()> {
-    use crate::export::tree::put_u32;
+pub(crate) fn put_counts(lhd3: &mut [u8], count: u32, blocks: u32, size: u32, w5: u32, capacity: u32) -> R<()> {
     put_u32(lhd3, 8, count)?;
     put_u32(lhd3, 12, blocks)?;
     put_u32(lhd3, 16, size)?;
@@ -204,6 +229,34 @@ mod tests {
         assert_eq!(rec.child(b"cdat").and_then(|c| c.bytes()).map(<[u8]>::len), Some(40));
     }
 
+    #[test]
+    fn every_record_header_fits() {
+        for dims in 0..=u8::MAX {
+            for template in [KeyTemplate::Plain, KeyTemplate::Spatial(1), KeyTemplate::Spatial(3), KeyTemplate::Spatial(u8::MAX)] {
+                for byte5 in [None, Some(0xff)] {
+                    let spec = RecSpec { dims, template, class: u32::MAX, limits: None, byte5 };
+                    assert!(try_tdb4(&spec, false, u32::MAX).is_ok() && try_tdb4(&spec, true, 0).is_ok());
+                }
+            }
+        }
+        for (size, count) in [(0, 0), (u32::MAX, u32::MAX), (48, 5)] {
+            assert_eq!(key_list_header(size, count).map(|h| h.len()).ok(), Some(52));
+        }
+    }
+
+    #[test]
+    fn a_match_name_reads_as_the_importer_reads_it() {
+        let m = tdmn("ADBE Group End");
+        assert_eq!(tdmn_name(&m).as_deref(), Some(GROUP_END));
+        assert!(is_tdmn(&m, GROUP_END) && !is_tdmn(&m, "ADBE Group") && !is_tdmn(&tdsn(GROUP_END), GROUP_END));
+        // At most 39 bytes, so that a NUL remains.
+        let long = "x".repeat(50);
+        assert_eq!(tdmn_name(&tdmn(&long)).map(|n| n.len()), Some(39));
+        // Not ASCII (After Effects writes ASCII): UTF-8, invalid bytes replaced, as on import.
+        let odd = Chunk::data(*b"tdmn", vec![b'A', 0xc3, 0xa9, 0xff, 0, b'B']);
+        assert_eq!(tdmn_name(&odd).as_deref(), Some("A\u{e9}\u{fffd}"));
+    }
+
     #[test]
     fn a_key_list_header_counts_and_rounds() {
         let l = key_list(48, 5, vec![0; 240]);
diff --git a/crates/aep/src/export/textanim.rs b/crates/aep/src/export/textanim.rs
index 760217cb8..1ceb869e4 100644
--- a/crates/aep/src/export/textanim.rs
+++ b/crates/aep/src/export/textanim.rs
@@ -21,6 +21,7 @@ use effectcraft_project::{Layer, Node, PropGroup};
 use crate::export::plan::CompPlan;
 use crate::export::report::{Collector, LossCategory};
 use crate::export::shapes::{Conv, Layout, RecVal, ShCx, build_record, c_color, c_popup, c_scalar, rec_value};
+use crate::export::synth::{GROUP_END, is_tdmn};
 use crate::export::tree::{R, kids_mut, set_utf8, tpl};
 
 /// More animators or selectors than this on one layer are not written (and reported).
@@ -219,14 +220,8 @@ fn plan_selector(s: &PropGroup, animator: &str, cx: &mut ShCx<'_>) -> SelPlan {
     SelPlan { name: crate::export::plan::cut_name(&s.name, 255, &here, cx.col), records, advanced }
 }
 
-fn tdmn_name(c: &Chunk<'_>) -> Option<String> {
-    let b = c.bytes()?;
-    let end = b.iter().position(|x| *x == 0).unwrap_or(b.len());
-    std::str::from_utf8(b.get(..end)?).ok().map(str::to_string)
-}
-
 fn pos(kids: &[Chunk<'static>], n: &str) -> Option<usize> {
-    kids.iter().position(|c| c.is(b"tdmn") && tdmn_name(c).as_deref() == Some(n))
+    kids.iter().position(|c| is_tdmn(c, n))
 }
 
 /// The item's user name (`tdsn/Utf8`).
@@ -296,7 +291,7 @@ pub(crate) fn put_animators(layr: &mut Chunk<'static>, t: &AnimProtos, anims: &[
     }
     {
         let gk = kids_mut(&mut group)?;
-        let end = pos(gk, "ADBE Group End").unwrap_or(gk.len());
+        let end = pos(gk, GROUP_END).unwrap_or(gk.len());
         gk.splice(end..end, built);
     }
     // Into the layer's `ADBE Text Properties`, before its Group End.
@@ -305,7 +300,7 @@ pub(crate) fn put_animators(layr: &mut Chunk<'static>, t: &AnimProtos, anims: &[
     let ti = pos(rk, "ADBE Text Properties").ok_or_else(|| tpl("text layer without text properties"))?;
     let tp = rk.get_mut(ti + 1).ok_or_else(|| tpl("text layer without text properties"))?;
     let tk = kids_mut(tp)?;
-    let end = pos(tk, "ADBE Group End").unwrap_or(tk.len());
+    let end = pos(tk, GROUP_END).unwrap_or(tk.len());
     tk.splice(end..end, [gm, group]);
     Ok(())
 }
diff --git a/crates/aep/src/export/tree.rs b/crates/aep/src/export/tree.rs
index 275d2a82f..4c2a28b75 100644
--- a/crates/aep/src/export/tree.rs
+++ b/crates/aep/src/export/tree.rs
@@ -40,6 +40,7 @@ pub(crate) fn child_data<'a>(c: &'a mut Chunk<'static>, id: &[u8; 4]) -> R<&'a m
     data_mut(child_mut(c, id)?)
 }
 
+/// The one byte writer of the exporter: `bytes` at `at`, or an error when they do not fit.
 pub(crate) fn put(d: &mut [u8], at: usize, bytes: &[u8]) -> R<()> {
     let end = at.checked_add(bytes.len()).ok_or_else(|| tpl("offset overflow"))?;
     let dst = d.get_mut(at..end).ok_or_else(|| tpl("chunk shorter than its layout"))?;
@@ -90,20 +91,109 @@ pub(crate) fn put_cstr(d: &mut [u8], at: usize, len: usize, text: &str) -> R<()>
             break;
         }
         let mut buf = [0u8; 4];
-        let enc = ch.encode_utf8(&mut buf);
-        for (i, b) in enc.as_bytes().iter().enumerate() {
-            if let Some(slot) = dst.get_mut(n + i) {
-                *slot = *b;
-            }
-        }
+        put(dst, n, ch.encode_utf8(&mut buf).as_bytes())?;
         n += l;
     }
     Ok(())
 }
 
+/// How many fixed layouts did not fit their buffer (see [`fixed`]); the tests keep it at zero.
+static FIXED_LAYOUT_ERRORS: std::sync::atomic::AtomicUsize = std::sync::atomic::AtomicUsize::new(0);
+
+/// The result of a builder whose layout is fixed in code (constant sizes and offsets, no input):
+/// its writes go through [`put`], which errors when one does not fit. Such an error is a bug in
+/// the layout, never something a project can cause, and the tests build every one of these
+/// layouts and require no error. The builders keep their infallible signatures because files
+/// outside this module call them without a `Result`; if a layout ever broke, `fallback` is used
+/// and the error goes to the log.
+pub(crate) fn fixed<T>(builder: &'static str, built: R<T>, fallback: impl FnOnce() -> T) -> T {
+    built.unwrap_or_else(|e| {
+        FIXED_LAYOUT_ERRORS.fetch_add(1, std::sync::atomic::Ordering::Relaxed);
+        log::error!("aep export: the fixed layout of {builder} does not fit: {e}");
+        fallback()
+    })
+}
+
+/// How many fixed layouts have failed in this process (for the tests).
+#[cfg(test)]
+pub(crate) fn fixed_layout_errors() -> usize {
+    FIXED_LAYOUT_ERRORS.load(std::sync::atomic::Ordering::Relaxed)
+}
+
+/// The entries of a property group by match name (see [`split_group`]).
+pub(crate) type Entries = Vec<(String, Vec<Chunk<'static>>)>;
+
+/// Splits the children of a property group into the header (up to the first `tdmn`) and its
+/// entries by match name: `[tdmn, node]`, or `[tdmn]` for the closing `ADBE Group End`. A match
+/// name without a node is an error.
+pub(crate) fn split_group(kids: &mut Vec<Chunk<'static>>) -> R<(Vec<Chunk<'static>>, Entries)> {
+    let first = kids.iter().position(|c| c.is(b"tdmn")).unwrap_or(kids.len());
+    let header: Vec<Chunk<'static>> = kids.drain(..first).collect();
+    let mut entries = Entries::new();
+    let mut it = std::mem::take(kids).into_iter();
+    while let Some(m) = it.next() {
+        let name = crate::export::synth::tdmn_name(&m).unwrap_or_default();
+        if name == crate::export::synth::GROUP_END {
+            entries.push((name, vec![m]));
+            continue;
+        }
+        let node = it.next().ok_or_else(|| tpl("match name without a node"))?;
+        entries.push((name, vec![m, node]));
+    }
+    Ok((header, entries))
+}
+
 /// Replaces the `Utf8` child of an item or layer with `text`.
 pub(crate) fn set_utf8(c: &mut Chunk<'static>, text: &str) -> R<()> {
     let k = child_mut(c, b"Utf8")?;
     *k = Chunk::data(*b"Utf8", text.as_bytes().to_vec());
     Ok(())
 }
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn the_writer_errors_instead_of_dropping() {
+        let mut d = [0u8; 4];
+        assert!(put(&mut d, 2, &[1, 2]).is_ok());
+        assert_eq!(d, [0, 0, 1, 2]);
+        // Out of range, partly or wholly, and an offset that overflows: an error, nothing written.
+        assert!(put(&mut d, 3, &[9, 9]).is_err());
+        assert!(put(&mut d, 8, &[9]).is_err());
+        assert!(put(&mut d, usize::MAX, &[9]).is_err());
+        assert_eq!(d, [0, 0, 1, 2]);
+    }
+
+    #[test]
+    fn a_cut_string_keeps_a_nul_and_whole_characters() {
+        let mut d = [0xffu8; 6];
+        put_cstr(&mut d, 0, 6, "ab\u{e9}\u{e9}").unwrap();
+        assert_eq!(d, [b'a', b'b', 0xc3, 0xa9, 0, 0]);
+        assert!(put_cstr(&mut d, 4, 6, "x").is_err());
+    }
+
+    /// Every layout fixed in code fits its buffer: the prototypes of every export (the project
+    /// skeleton, layers, Transform, masks, effects of the whole table, footage of every kind,
+    /// text, cameras, lights, shapes, styles) are built and no write went out of range.
+    #[test]
+    fn every_fixed_layout_fits() {
+        assert!(crate::export::template::Template::load().is_ok());
+        assert_eq!(fixed_layout_errors(), 0);
+    }
+
+    #[test]
+    fn a_group_splits_into_header_and_entries() {
+        use crate::export::synth::{tdmn, tdsn};
+        let rec = || Chunk::list(*b"tdbs", Vec::new());
+        let mut kids = vec![tdsn("h"), tdmn("A"), rec(), tdmn("ADBE Group End")];
+        let (header, entries) = split_group(&mut kids).unwrap();
+        assert_eq!(header.len(), 1);
+        let names: Vec<(&str, usize)> = entries.iter().map(|(n, v)| (n.as_str(), v.len())).collect();
+        assert_eq!(names, [("A", 2), ("ADBE Group End", 1)]);
+        // A match name without its node is an error, not a quiet stop.
+        let mut broken = vec![tdmn("A")];
+        assert!(split_group(&mut broken).is_err());
+    }
+}

From a4f9a975250a75f7b87ce3f7be764578dc651aa1 Mon Sep 17 00:00:00 2001
From: vangel76 <vangel1976@googlemail.com>
Date: Sun, 8 Nov 2026 03:32:08 +0100
Subject: [PATCH 10/30] aep export: pin the key-time loop's report, name the
 layout in the base::bytes log (#3278)

---
 crates/aep/src/export/base.rs |  6 +++++-
 crates/aep/src/export/keys.rs | 32 ++++++++++++++++++++++++++++++++
 2 files changed, 37 insertions(+), 1 deletion(-)

diff --git a/crates/aep/src/export/base.rs b/crates/aep/src/export/base.rs
index 3e2b043ff..9da1db2ba 100644
--- a/crates/aep/src/export/base.rs
+++ b/crates/aep/src/export/base.rs
@@ -12,7 +12,11 @@ use crate::export::tree::{R, fixed, put};
 /// A zero buffer of `len` bytes with `fields` (offset, bytes) written into it. The layouts are
 /// fixed in code ([`fixed`]).
 pub(crate) fn bytes(len: usize, fields: &[(usize, &[u8])]) -> Vec<u8> {
-    fixed("a record", try_bytes(len, fields), || vec![0u8; len])
+    fixed("base::bytes", try_bytes(len, fields), || {
+        // Which layout: its length and fields (the builders are named in the comments above).
+        log::error!("aep export: base::bytes layout of {len} bytes, fields at {:?}", fields.iter().map(|(at, v)| (*at, v.len())).collect::<Vec<_>>());
+        vec![0u8; len]
+    })
 }
 
 fn try_bytes(len: usize, fields: &[(usize, &[u8])]) -> R<Vec<u8>> {
diff --git a/crates/aep/src/export/keys.rs b/crates/aep/src/export/keys.rs
index fdcad87c2..b3cd1158c 100644
--- a/crates/aep/src/export/keys.rs
+++ b/crates/aep/src/export/keys.rs
@@ -90,6 +90,38 @@ mod tests {
     use super::*;
     use crate::export::synth::key_list;
 
+    #[test]
+    fn keys_are_timed_sorted_merged_and_reported() {
+        use effectcraft_keyframe::Value;
+        use effectcraft_time::{TICKS_PER_SECOND, Tick};
+        let tb = TimeBase { frame_duration: 1024, timescale: 25600 };
+        // Out of order; 1/3 s is not on the time base; two keys meet at 1 s (the first one kept).
+        let keys = [
+            Keyframe::new(Tick(TICKS_PER_SECOND), Value::Scalar(1.0)),
+            Keyframe::new(Tick(TICKS_PER_SECOND / 3), Value::Scalar(2.0)),
+            Keyframe::new(Tick(0), Value::Scalar(3.0)),
+            Keyframe::new(Tick(TICKS_PER_SECOND), Value::Scalar(4.0)),
+        ];
+        let mut col = Collector::default();
+        let timed = timed_keys(&keys, &tb, "L", "path key", &mut col);
+        let got: Vec<(i64, f64)> = timed.iter().map(|(u, k)| (*u, if let Value::Scalar(v) = k.value { v } else { f64::NAN })).collect();
+        assert_eq!(got, [(0, 3.0), (8533, 2.0), (25600, 1.0)]);
+        // The report lists its categories in a fixed order; one merge report for the pair.
+        let report = col.finish();
+        let lines: Vec<(LossCategory, &str)> = report.losses.iter().flat_map(|l| l.details.iter().map(move |d| (l.category, d.as_str()))).collect();
+        assert_eq!(
+            lines,
+            [
+                (LossCategory::ApproximatedKeyframes, "L: path keys at the same time were merged"),
+                (LossCategory::RoundedTimes, "L: path key at 0.3333 s moved to the time base"),
+            ]
+        );
+        // No keys, no report.
+        let mut col = Collector::default();
+        assert!(timed_keys(&[], &tb, "L", "key", &mut col).is_empty());
+        assert!(col.finish().losses.is_empty());
+    }
+
     #[test]
     fn a_key_list_is_filled_and_replaces_the_value() {
         let mut list = Chunk::list(*b"list", vec![Chunk::data(*b"lhd3", vec![0; 52])]);

From 9e82a5e7049af1c6c118e966a5c7bce56a3b43be Mon Sep 17 00:00:00 2001
From: vangel76 <vangel1976@googlemail.com>
Date: Sun, 8 Nov 2026 03:56:50 +0100
Subject: [PATCH 11/30] aep export: review fixes for #3278

- tree::Fixed replaces tree::fixed: a fixed layout writes every field that
  fits (as the old code did) and keeps the first error; finish() logs it
  once with the layout's description and counts it per thread, so the
  every-layout test cannot race with other tests.
- base::bytes logs one line naming its length and fields.
- masks::build_atom errors when the prototype has no Mask Shape instead of
  dropping the path of every mask quietly.
- log sorted into the dependency list.
---
 crates/aep/Cargo.toml            |  2 +-
 crates/aep/src/export/base.rs    | 26 +++++-----
 crates/aep/src/export/fxsynth.rs | 72 ++++++++++++++--------------
 crates/aep/src/export/masks.rs   | 67 ++++++++++++++++++++------
 crates/aep/src/export/synth.rs   | 48 ++++++++++---------
 crates/aep/src/export/tree.rs    | 81 +++++++++++++++++++++++++-------
 6 files changed, 191 insertions(+), 105 deletions(-)

diff --git a/crates/aep/Cargo.toml b/crates/aep/Cargo.toml
index d1fbc4a3a..3deb09de2 100644
--- a/crates/aep/Cargo.toml
+++ b/crates/aep/Cargo.toml
@@ -15,9 +15,9 @@ effectcraft-color = { workspace = true }
 effectcraft-keyframe = { workspace = true }
 effectcraft-project = { workspace = true }
 effectcraft-effects = { workspace = true }
+log = { workspace = true }
 serde = { workspace = true }
 thiserror = { workspace = true }
-log = { workspace = true }
 
 [dev-dependencies]
 serde_json = { workspace = true }
diff --git a/crates/aep/src/export/base.rs b/crates/aep/src/export/base.rs
index 9da1db2ba..dfaca7321 100644
--- a/crates/aep/src/export/base.rs
+++ b/crates/aep/src/export/base.rs
@@ -7,24 +7,20 @@
 
 use crate::Chunk;
 use crate::export::synth::{GROUP_END, tdmn, tdsn};
-use crate::export::tree::{R, fixed, put};
+use crate::export::tree::Fixed;
 
 /// A zero buffer of `len` bytes with `fields` (offset, bytes) written into it. The layouts are
-/// fixed in code ([`fixed`]).
+/// fixed in code ([`Fixed`]).
 pub(crate) fn bytes(len: usize, fields: &[(usize, &[u8])]) -> Vec<u8> {
-    fixed("base::bytes", try_bytes(len, fields), || {
-        // Which layout: its length and fields (the builders are named in the comments above).
-        log::error!("aep export: base::bytes layout of {len} bytes, fields at {:?}", fields.iter().map(|(at, v)| (*at, v.len())).collect::<Vec<_>>());
-        vec![0u8; len]
-    })
+    layout(len, fields).finish(|| format!("base::bytes ({len} bytes, fields at {:?})", fields.iter().map(|(at, v)| (*at, v.len())).collect::<Vec<_>>()))
 }
 
-fn try_bytes(len: usize, fields: &[(usize, &[u8])]) -> R<Vec<u8>> {
-    let mut b = vec![0u8; len];
+fn layout(len: usize, fields: &[(usize, &[u8])]) -> Fixed {
+    let mut b = Fixed::zeroed(len);
     for (at, v) in fields {
-        put(&mut b, *at, v)?;
+        b.put(*at, v);
     }
-    Ok(b)
+    b
 }
 
 pub(crate) fn utf8(text: &str) -> Chunk<'static> {
@@ -286,9 +282,11 @@ mod tests {
 
     #[test]
     fn a_field_out_of_range_is_an_error() {
-        assert_eq!(try_bytes(4, &[(0, &[1]), (3, &[2])]).ok(), Some(vec![1, 0, 0, 2]));
-        assert!(try_bytes(4, &[(3, &[1, 2])]).is_err());
-        assert!(try_bytes(4, &[(usize::MAX, &[1])]).is_err());
+        let ok = layout(4, &[(0, &[1]), (3, &[2])]);
+        assert!(ok.error().is_none());
+        assert_eq!(ok.finish(String::new), [1, 0, 0, 2]);
+        assert!(layout(4, &[(3, &[1, 2])]).error().is_some());
+        assert!(layout(4, &[(usize::MAX, &[1])]).error().is_some());
     }
 
     /// The chunks After Effects refuses a file without, or crashes on (aep-export.md, "What After
diff --git a/crates/aep/src/export/fxsynth.rs b/crates/aep/src/export/fxsynth.rs
index e4bf002b9..cce25b6f2 100644
--- a/crates/aep/src/export/fxsynth.rs
+++ b/crates/aep/src/export/fxsynth.rs
@@ -12,7 +12,7 @@ use crate::Chunk;
 use crate::effect_map::{Conv, by_match_name};
 use crate::export::fx_defs::{BUILT_IN, FxDef, PDef};
 use crate::export::synth::{GROUP_END, KeyTemplate, NO_NAME, RecSpec, class, tdmn, tdsn, utf8_in};
-use crate::export::tree::{R, fixed as fixed_layout, put};
+use crate::export::tree::Fixed;
 use crate::{CURVE_IDENTITY, CurvesData, MeshData};
 
 /// The layer a prototype's layer parameters name when their default is the owning layer; the
@@ -48,91 +48,91 @@ fn fixed(v: f64) -> [u8; 4] {
 /// display 124; fixed and integer: 124 / 128 / 132 / 136, default 140, display 144). Every other
 /// byte is zero (the switches at 48 are not needed: s12-e2-nofl).
 pub(crate) fn pard(p: &PDef, popup_items: Option<u16>) -> Vec<u8> {
-    fixed_layout("pard", try_pard(p, popup_items), || vec![0u8; 148])
+    pard_layout(p, popup_items).finish(|| format!("pard (type {})", p.code))
 }
 
-fn try_pard(p: &PDef, popup_items: Option<u16>) -> R<Vec<u8>> {
-    let mut b = vec![0u8; 148];
-    put(&mut b, 12, &u32::from(p.code).to_be_bytes())?;
+fn pard_layout(p: &PDef, popup_items: Option<u16>) -> Fixed {
+    let mut b = Fixed::zeroed(148);
+    b.put(12, &u32::from(p.code).to_be_bytes());
     let d = |i: usize| p.default.get(i).copied().unwrap_or(0.0);
     // After Effects takes the default of a parameter without a value record from here (s8-e1:
     // the copies below are the ones it reads).
     match p.code {
         10 => {
-            put(&mut b, 56, &d(0).to_be_bytes())?;
+            b.put(56, &d(0).to_be_bytes());
             // The default again as `f32` at 120, the display word (decimals) at 124.
-            put(&mut b, 120, &(d(0) as f32).to_be_bytes())?;
-            put(&mut b, 124, &p.display.to_be_bytes())?;
+            b.put(120, &(d(0) as f32).to_be_bytes());
+            b.put(124, &p.display.to_be_bytes());
         }
-        2 => put(&mut b, 56, &fixed(d(0)))?,
+        2 => b.put(56, &fixed(d(0))),
         // An angle: the default again at 60.
         3 => {
-            put(&mut b, 56, &fixed(d(0)))?;
-            put(&mut b, 60, &fixed(d(0)))?;
+            b.put(56, &fixed(d(0)));
+            b.put(60, &fixed(d(0)));
         }
-        1 => put(&mut b, 56, &(d(0).round() as i32).to_be_bytes())?,
+        1 => b.put(56, &(d(0).round() as i32).to_be_bytes()),
         // A checkbox: the default again as a byte at 60.
         4 => {
-            put(&mut b, 56, &(d(0).round().max(0.0) as u32).to_be_bytes())?;
-            put(&mut b, 60, &[u8::from(d(0) != 0.0)])?;
+            b.put(56, &(d(0).round().max(0.0) as u32).to_be_bytes());
+            b.put(60, &[u8::from(d(0) != 0.0)]);
         }
         // A popup: the default again as `u16` at 62 (the item count is at 60).
         7 => {
             let sel = d(0).round().clamp(0.0, f64::from(u16::MAX));
-            put(&mut b, 56, &(sel as u32).to_be_bytes())?;
-            put(&mut b, 62, &(sel as u16).to_be_bytes())?;
+            b.put(56, &(sel as u32).to_be_bytes());
+            b.put(62, &(sel as u16).to_be_bytes());
         }
         6 => {
             // Fractions of the layer at 56 / 60 and the same in percent at 68 / 72.
-            put(&mut b, 56, &fixed(d(0)))?;
-            put(&mut b, 60, &fixed(d(1)))?;
-            put(&mut b, 68, &fixed(d(0) * 100.0))?;
-            put(&mut b, 72, &fixed(d(1) * 100.0))?;
+            b.put(56, &fixed(d(0)));
+            b.put(60, &fixed(d(1)));
+            b.put(68, &fixed(d(0) * 100.0));
+            b.put(72, &fixed(d(1) * 100.0));
         }
         5 => {
             // ARGB at 56 and the same at 60.
             let c: Vec<u8> = (0..4).map(|i| d(i).round().clamp(0.0, 255.0) as u8).collect();
-            put(&mut b, 56, &c)?;
-            put(&mut b, 60, &c)?;
+            b.put(56, &c);
+            b.put(60, &c);
         }
         _ => {}
     }
     if p.code == 7 {
         let n = popup_items.unwrap_or_else(|| u16::try_from(p.display).unwrap_or(0));
-        put(&mut b, 60, &n.to_be_bytes())?;
+        b.put(60, &n.to_be_bytes());
     }
     match p.code {
         10 => {
             if let Some(m) = p.valid_min {
-                put(&mut b, 104, &(m as f32).to_be_bytes())?;
+                b.put(104, &(m as f32).to_be_bytes());
             }
             if let Some(m) = p.valid_max {
-                put(&mut b, 108, &(m as f32).to_be_bytes())?;
+                b.put(108, &(m as f32).to_be_bytes());
             }
             if let Some((lo, hi)) = p.range {
-                put(&mut b, 112, &(lo as f32).to_be_bytes())?;
-                put(&mut b, 116, &(hi as f32).to_be_bytes())?;
+                b.put(112, &(lo as f32).to_be_bytes());
+                b.put(116, &(hi as f32).to_be_bytes());
             }
         }
         1 | 2 => {
             let enc = |v: f64| if p.code == 2 { fixed(v) } else { (v.round() as i32).to_be_bytes() };
             if let Some(m) = p.valid_min {
-                put(&mut b, 124, &enc(m))?;
+                b.put(124, &enc(m));
             }
             if let Some(m) = p.valid_max {
-                put(&mut b, 128, &enc(m))?;
+                b.put(128, &enc(m));
             }
             if let Some((lo, hi)) = p.range {
-                put(&mut b, 132, &enc(lo))?;
-                put(&mut b, 136, &enc(hi))?;
+                b.put(132, &enc(lo));
+                b.put(136, &enc(hi));
             }
             // The default again at 140, the display word (decimals, percent) at 144.
-            put(&mut b, 140, &enc(d(0)))?;
-            put(&mut b, 144, &p.display.to_be_bytes())?;
+            b.put(140, &enc(d(0)));
+            b.put(144, &p.display.to_be_bytes());
         }
         _ => {}
     }
-    Ok(b)
+    b
 }
 
 /// The default arbitrary data of an effect (its type-11 parameter), from the decoded layouts
@@ -278,7 +278,9 @@ mod tests {
     fn every_parameter_definition_fits() {
         for fx in FX_DEFS {
             for (i, p) in fx.params.iter().enumerate() {
-                assert_eq!(try_pard(p, popup_items(fx, i)).map(|b| b.len()).ok(), Some(148), "{} {}", fx.match_name, i);
+                let b = pard_layout(p, popup_items(fx, i));
+                assert!(b.error().is_none(), "{} {}", fx.match_name, i);
+                assert_eq!(b.finish(String::new).len(), 148);
             }
         }
     }
diff --git a/crates/aep/src/export/masks.rs b/crates/aep/src/export/masks.rs
index eb61b0a09..b46811500 100644
--- a/crates/aep/src/export/masks.rs
+++ b/crates/aep/src/export/masks.rs
@@ -21,7 +21,7 @@ use crate::export::keys::{set_key_list, timed_keys};
 use crate::export::plan::{CompPlan, EaseSlot, KeyPlan, LIMIT, cut_name};
 use crate::export::report::{Collector, LossCategory};
 use crate::export::synth::GROUP_END;
-use crate::export::tree::{R, child_data, child_mut, fixed, kids_mut, list_mut, put, put_f32, put_f64, put_i32, put_u8, put_u16, put_u32, split_group, tpl};
+use crate::export::tree::{Fixed, R, child_data, child_mut, kids_mut, list_mut, put_f32, put_f64, put_i32, put_u8, put_u16, put_u32, split_group, tpl};
 
 /// The most vertices one mask path may have (as the importer).
 pub(crate) const MAX_VERTICES: usize = 65_536;
@@ -365,26 +365,25 @@ const MASK_LIMIT: f64 = 32_000.0;
 /// s13-m1), byte 3 `0x01` (`0x09` once the path is open), the box at 4..19 (written per shape),
 /// byte 20 1.
 pub(crate) fn shph() -> Vec<u8> {
-    fixed("shph", try_shph(), || vec![0u8; 24])
+    shph_layout().finish(|| "shph".to_string())
 }
 
-fn try_shph() -> R<Vec<u8>> {
-    let mut b = vec![0u8; 24];
-    put(&mut b, 0, &[0xb3, 0xde, 0x02, 0x01])?;
-    put_u8(&mut b, 20, 1)?;
-    Ok(b)
+fn shph_layout() -> Fixed {
+    let mut b = Fixed::zeroed(24);
+    b.put(0, &[0xb3, 0xde, 0x02, 0x01]);
+    b.put(20, &[1]);
+    b
 }
 
 /// The two prototype records of a keyed path (093): 64 bytes each, flags `0x0001`, the `f64` at
 /// 16 1 in the first (the rest is zero: its last bytes were uninitialised).
-fn path_key_records() -> R<Vec<u8>> {
-    let mut first = vec![0u8; 64];
-    let mut later = vec![0u8; 64];
-    for r in [&mut first, &mut later] {
-        put_u16(r, 6, 0x0001)?;
+fn path_key_records() -> Fixed {
+    let mut b = Fixed::zeroed(128);
+    for at in [6, 64 + 6] {
+        b.put(at, &0x0001u16.to_be_bytes());
     }
-    put_f64(&mut first, 16, 1.0)?;
-    Ok([first, later].concat())
+    b.put(16, &1.0f64.to_be_bytes());
+    b
 }
 
 impl MaskProtos {
@@ -400,7 +399,7 @@ impl MaskProtos {
         let path_rec = |keyed: bool| {
             let mut kids = vec![state(), tdsn(NO_NAME), Chunk::data(*b"tdb4", tdb4(&path, keyed, 25_600))];
             if keyed {
-                kids.push(key_list(64, 2, fixed("keyed path", path_key_records(), || vec![0u8; 128])));
+                kids.push(key_list(64, 2, path_key_records().finish(|| "the keyed path records".to_string())));
             } else {
                 kids.push(Chunk::data(*b"cdat", vec![0u8; 4]));
             }
@@ -465,6 +464,7 @@ fn build_atom(t: &MaskProtos, m: &MaskPlan, size: (u32, u32)) -> R<Chunk<'static
         crate::export::tree::set_utf8(tdsn, &m.name)?;
     }
     let (mut out, entries) = split_group(kids_mut(&mut atom)?)?;
+    let mut has_shape = false;
     for (name, entry) in entries {
         // The closing Group End (no node) is kept as it is.
         let [tdmn, mut node]: [Chunk<'static>; 2] = match entry.try_into() {
@@ -477,6 +477,7 @@ fn build_atom(t: &MaskProtos, m: &MaskPlan, size: (u32, u32)) -> R<Chunk<'static
         let keep = match name.as_str() {
             "ADBE Mask Shape" => {
                 build_shape(t, &mut node, m, size)?;
+                has_shape = true;
                 true
             }
             "ADBE Mask Feather" => {
@@ -511,6 +512,10 @@ fn build_atom(t: &MaskProtos, m: &MaskPlan, size: (u32, u32)) -> R<Chunk<'static
             out.push(node);
         }
     }
+    // A prototype without the path would drop every mask's shape.
+    if !has_shape {
+        return Err(tpl("mask atom without its path"));
+    }
     *kids_mut(&mut atom)? = out;
     Ok(atom)
 }
@@ -623,3 +628,35 @@ pub(crate) fn build_shap(proto: &Chunk<'static>, s: &ShapePlan) -> R<Chunk<'stat
     }
     Ok(shap)
 }
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use crate::export::synth::is_tdmn;
+
+    fn mask() -> MaskPlan {
+        let shape = ShapePlan { bbox: [0.0, 0.0, 1.0, 1.0], open: false, points: vec![[0.0, 0.0]; 3] };
+        MaskPlan {
+            name: "M".into(),
+            mode: 1,
+            inverted: false,
+            shape,
+            path_keys: Vec::new(),
+            feather: None,
+            feather_keys: Vec::new(),
+            opacity: None,
+            expansion: None,
+        }
+    }
+
+    #[test]
+    fn an_atom_without_its_path_is_an_error() {
+        let mut t = MaskProtos::build();
+        assert!(build_atom(&t, &mask(), (100, 100)).is_ok());
+        // Without the Mask Shape pair the path of every mask would be dropped quietly.
+        let kids = kids_mut(&mut t.atom).unwrap();
+        let at = kids.iter().position(|c| is_tdmn(c, "ADBE Mask Shape")).unwrap();
+        kids.drain(at..at + 2);
+        assert!(build_atom(&t, &mask(), (100, 100)).is_err());
+    }
+}
diff --git a/crates/aep/src/export/synth.rs b/crates/aep/src/export/synth.rs
index 3517c41d2..80678baa3 100644
--- a/crates/aep/src/export/synth.rs
+++ b/crates/aep/src/export/synth.rs
@@ -4,7 +4,7 @@
 //! evidence, or zero where After Effects was shown to accept zero (the read-backs listed in
 //! `docs/aep-export.md`, "Built in code").
 
-use crate::export::tree::{R, fixed, put, put_u32};
+use crate::export::tree::{Fixed, R, put_u32};
 use crate::{Body, Chunk};
 
 /// `tdmn`: a match name padded to 40 bytes (at most 39 bytes of the name, so that a NUL remains).
@@ -123,12 +123,12 @@ impl RecSpec {
 /// word and the constant doubles at 16..56 are written; After Effects reads the other bytes as
 /// zero (read-back e1-ztdb4d).
 pub(crate) fn tdb4(spec: &RecSpec, keyed: bool, time_scale: u32) -> Vec<u8> {
-    fixed("tdb4", try_tdb4(spec, keyed, time_scale), || vec![0u8; 124])
+    tdb4_layout(spec, keyed, time_scale).finish(|| "tdb4".to_string())
 }
 
-fn try_tdb4(spec: &RecSpec, keyed: bool, time_scale: u32) -> R<Vec<u8>> {
-    let mut b = vec![0u8; 124];
-    put(&mut b, 0, &[0xdb, 0x99, 0x00, spec.dims])?;
+fn tdb4_layout(spec: &RecSpec, keyed: bool, time_scale: u32) -> Fixed {
+    let mut b = Fixed::zeroed(124);
+    b.put(0, &[0xdb, 0x99, 0x00, spec.dims]);
     let spatial = match spec.template {
         KeyTemplate::Plain => 0,
         KeyTemplate::Spatial(t) => t,
@@ -137,36 +137,36 @@ fn try_tdb4(spec: &RecSpec, keyed: bool, time_scale: u32) -> R<Vec<u8>> {
         Some(b) => (b & !0x01) | u8::from(!keyed),
         None => (if spatial == 0 { 0 } else { spatial_byte5(spatial) }) | u8::from(!keyed),
     };
-    put(&mut b, 5, &[byte5])?;
-    put(&mut b, 7, &[spatial])?;
-    put(&mut b, 8, &spec.class.to_be_bytes())?;
-    put(&mut b, 12, &time_scale.to_be_bytes())?;
+    b.put(5, &[byte5]);
+    b.put(7, &[spatial]);
+    b.put(8, &spec.class.to_be_bytes());
+    b.put(12, &time_scale.to_be_bytes());
     // Every record After Effects writes carries 0.0001 and four 1.0 here; without them a roving
     // key reads back at time zero instead of its retimed place (read-back s14-re-keyframes).
-    put(&mut b, 16, &1e-4f64.to_be_bytes())?;
+    b.put(16, &1e-4f64.to_be_bytes());
     for at in [24, 32, 40, 48] {
-        put(&mut b, at, &1.0f64.to_be_bytes())?;
+        b.put(at, &1.0f64.to_be_bytes());
     }
-    put(&mut b, 68, &[u8::from(keyed)])?;
+    b.put(68, &[u8::from(keyed)]);
     // Set on a static spatial property, cleared once it is keyed (aep-format.md 3.4, byte 79).
-    put(&mut b, 79, &[u8::from(spatial != 0 && !keyed)])?;
-    Ok(b)
+    b.put(79, &[u8::from(spatial != 0 && !keyed)]);
+    b
 }
 
 /// A key list (`LIST list`: `lhd3` + `ldat`) of `count` records of `size` bytes (aep-format.md
 /// 3.5): word 0 `0x00d00bee`, word 2 the count, word 3 the blocks of four (at least one), word 4
 /// the size, words 5 and 7 the capacity (the count rounded up to four, at least two), word 6 one.
 pub(crate) fn key_list(size: u32, count: u32, records: Vec<u8>) -> Chunk<'static> {
-    let lhd3 = fixed("lhd3", key_list_header(size, count), || vec![0u8; 52]);
+    let lhd3 = key_list_header(size, count).finish(|| "lhd3".to_string());
     Chunk::list(*b"list", vec![Chunk::data(*b"lhd3", lhd3), Chunk::data(*b"ldat", records)])
 }
 
-fn key_list_header(size: u32, count: u32) -> R<Vec<u8>> {
-    let mut lhd3 = vec![0u8; 52];
-    put_u32(&mut lhd3, 0, 0x00d0_0bee)?;
-    put_u32(&mut lhd3, 24, 1)?;
-    put_key_counts(&mut lhd3, count, size)?;
-    Ok(lhd3)
+fn key_list_header(size: u32, count: u32) -> Fixed {
+    let mut lhd3 = Fixed::zeroed(52);
+    lhd3.put(0, &0x00d0_0bee_u32.to_be_bytes());
+    lhd3.put(24, &1u32.to_be_bytes());
+    lhd3.apply(|d| put_key_counts(d, count, size));
+    lhd3
 }
 
 /// Sets the count words of a key list header for `count` keys of `size` bytes.
@@ -235,12 +235,14 @@ mod tests {
             for template in [KeyTemplate::Plain, KeyTemplate::Spatial(1), KeyTemplate::Spatial(3), KeyTemplate::Spatial(u8::MAX)] {
                 for byte5 in [None, Some(0xff)] {
                     let spec = RecSpec { dims, template, class: u32::MAX, limits: None, byte5 };
-                    assert!(try_tdb4(&spec, false, u32::MAX).is_ok() && try_tdb4(&spec, true, 0).is_ok());
+                    assert!(tdb4_layout(&spec, false, u32::MAX).error().is_none() && tdb4_layout(&spec, true, 0).error().is_none());
                 }
             }
         }
         for (size, count) in [(0, 0), (u32::MAX, u32::MAX), (48, 5)] {
-            assert_eq!(key_list_header(size, count).map(|h| h.len()).ok(), Some(52));
+            let h = key_list_header(size, count);
+            assert!(h.error().is_none());
+            assert_eq!(h.finish(String::new).len(), 52);
         }
     }
 
diff --git a/crates/aep/src/export/tree.rs b/crates/aep/src/export/tree.rs
index 4c2a28b75..f975e1668 100644
--- a/crates/aep/src/export/tree.rs
+++ b/crates/aep/src/export/tree.rs
@@ -97,27 +97,61 @@ pub(crate) fn put_cstr(d: &mut [u8], at: usize, len: usize, text: &str) -> R<()>
     Ok(())
 }
 
-/// How many fixed layouts did not fit their buffer (see [`fixed`]); the tests keep it at zero.
-static FIXED_LAYOUT_ERRORS: std::sync::atomic::AtomicUsize = std::sync::atomic::AtomicUsize::new(0);
-
-/// The result of a builder whose layout is fixed in code (constant sizes and offsets, no input):
-/// its writes go through [`put`], which errors when one does not fit. Such an error is a bug in
-/// the layout, never something a project can cause, and the tests build every one of these
-/// layouts and require no error. The builders keep their infallible signatures because files
-/// outside this module call them without a `Result`; if a layout ever broke, `fallback` is used
-/// and the error goes to the log.
-pub(crate) fn fixed<T>(builder: &'static str, built: R<T>, fallback: impl FnOnce() -> T) -> T {
-    built.unwrap_or_else(|e| {
-        FIXED_LAYOUT_ERRORS.fetch_add(1, std::sync::atomic::Ordering::Relaxed);
-        log::error!("aep export: the fixed layout of {builder} does not fit: {e}");
-        fallback()
-    })
+thread_local! {
+    /// How many fixed layouts on this thread did not fit their buffer (see [`Fixed`]); the tests
+    /// keep it at zero.
+    static FIXED_LAYOUT_ERRORS: std::cell::Cell<usize> = const { std::cell::Cell::new(0) };
 }
 
-/// How many fixed layouts have failed in this process (for the tests).
+/// A buffer whose layout is fixed in code (constant size and offsets, no input from a project).
+/// Every write goes through [`put`]; a write that does not fit is skipped and its error kept, the
+/// others are written. Such an error is a bug in the layout, never something a project can cause:
+/// the tests build every one of these layouts and require no error. The builders keep their
+/// infallible signatures because files outside this module call them without a `Result`; if a
+/// layout ever broke, [`Fixed::finish`] logs it once and returns what fit.
+pub(crate) struct Fixed {
+    bytes: Vec<u8>,
+    error: Option<AepExportError>,
+}
+
+impl Fixed {
+    /// `len` zero bytes.
+    pub(crate) fn zeroed(len: usize) -> Fixed {
+        Fixed { bytes: vec![0u8; len], error: None }
+    }
+
+    /// Writes `bytes` at `at`, or keeps the error (the first one) when they do not fit.
+    pub(crate) fn put(&mut self, at: usize, bytes: &[u8]) {
+        self.apply(|d| put(d, at, bytes));
+    }
+
+    /// Runs a writer on the buffer, keeping its error (the first one).
+    pub(crate) fn apply(&mut self, write: impl FnOnce(&mut [u8]) -> R<()>) {
+        if let Err(e) = write(&mut self.bytes) {
+            self.error.get_or_insert(e);
+        }
+    }
+
+    /// The error of the first write that did not fit (for the tests).
+    #[cfg(test)]
+    pub(crate) fn error(&self) -> Option<&AepExportError> {
+        self.error.as_ref()
+    }
+
+    /// The bytes; a write that did not fit is logged once, with what `layout` says.
+    pub(crate) fn finish(self, layout: impl FnOnce() -> String) -> Vec<u8> {
+        if let Some(e) = self.error {
+            FIXED_LAYOUT_ERRORS.with(|n| n.set(n.get().saturating_add(1)));
+            log::error!("aep export: the fixed layout of {} does not fit: {e}", layout());
+        }
+        self.bytes
+    }
+}
+
+/// How many fixed layouts have failed on this thread (for the tests).
 #[cfg(test)]
 pub(crate) fn fixed_layout_errors() -> usize {
-    FIXED_LAYOUT_ERRORS.load(std::sync::atomic::Ordering::Relaxed)
+    FIXED_LAYOUT_ERRORS.with(std::cell::Cell::get)
 }
 
 /// The entries of a property group by match name (see [`split_group`]).
@@ -179,10 +213,23 @@ mod tests {
     /// text, cameras, lights, shapes, styles) are built and no write went out of range.
     #[test]
     fn every_fixed_layout_fits() {
+        assert_eq!(fixed_layout_errors(), 0);
         assert!(crate::export::template::Template::load().is_ok());
         assert_eq!(fixed_layout_errors(), 0);
     }
 
+    #[test]
+    fn a_broken_fixed_layout_writes_what_fits_and_is_counted() {
+        let before = fixed_layout_errors();
+        let mut b = Fixed::zeroed(4);
+        b.put(0, &[1]);
+        b.put(3, &[2, 2]);
+        b.put(2, &[3]);
+        assert!(b.error().is_some());
+        assert_eq!(b.finish(|| "a test layout".to_string()), [1, 0, 3, 0]);
+        assert_eq!(fixed_layout_errors(), before + 1);
+    }
+
     #[test]
     fn a_group_splits_into_header_and_entries() {
         use crate::export::synth::{tdmn, tdsn};

From 30a6e571c953b05d79a961489e500f50b99f806c Mon Sep 17 00:00:00 2001
From: vangel76 <vangel1976@googlemail.com>
Date: Sun, 8 Nov 2026 03:58:10 +0100
Subject: [PATCH 12/30] aep: review fixes for #3276 text documents and markers

text_document reads the first btdk in the Source Text record, the documents
text_document_count counts. The old slot checks (same, is_neutral, undecoded_fields)
join the test oracle and are compared on 20 000 generated slot dictionaries; mixed
dictionary/array chains and a document left open at the depth limit join the parser
differential. An escaped string's byte order mark is drained without a copy.
---
 crates/aep/src/container/textdoc.rs | 156 +++++++++++++++++++++++++---
 1 file changed, 144 insertions(+), 12 deletions(-)

diff --git a/crates/aep/src/container/textdoc.rs b/crates/aep/src/container/textdoc.rs
index 765490557..28e581909 100644
--- a/crates/aep/src/container/textdoc.rs
+++ b/crates/aep/src/container/textdoc.rs
@@ -282,7 +282,11 @@ impl<'b> Parser<'b> {
                 Some(if body.starts_with(&[0xfe, 0xff]) {
                     V::Str(match body {
                         Cow::Borrowed(b) => Cow::Borrowed(b.get(2..).unwrap_or(&[])),
-                        Cow::Owned(v) => Cow::Owned(v.get(2..).map(<[u8]>::to_vec).unwrap_or_default()),
+                        Cow::Owned(mut v) => {
+                            let n = v.len().min(2);
+                            v.drain(..n);
+                            Cow::Owned(v)
+                        }
                     })
                 } else {
                     V::Bytes(body)
@@ -1006,16 +1010,17 @@ impl TextDocument {
 impl<'f, 'a> Layer<'f, 'a> {
     /// The Source Text record `LIST btds` (`ADBE Text Document`). It is a direct child of the
     /// `ADBE Text Properties` group, which is a direct child of the layer's root `tdgp`
-    /// (`Layr/tdgp/tdgp/btds`, in every sample), so only that level is searched rather than the
-    /// whole layer.
+    /// (`Layr/tdgp/tdgp/btds` in every sample, and where the exporter writes it), so only that
+    /// level is searched rather than the whole layer.
     fn source_text_record(&self) -> Option<&'f Chunk<'a>> {
         let root = self.chunk.child_list(b"tdgp")?;
         root.children().iter().filter(|g| g.is_list(b"tdgp")).find_map(|g| g.child_list(b"btds"))
     }
 
-    /// The text document of a text layer (`LIST btdk` in the Source Text record `btds`).
+    /// The text document of a text layer: the first `LIST btdk` in the Source Text record `btds`
+    /// (the same documents [`Layer::text_document_count`] counts).
     pub fn text_document(&self) -> Option<TextDocument> {
-        TextDocument::parse(self.source_text_record()?.child_list(b"btdk")?.bytes()?)
+        TextDocument::parse(self.source_text_record()?.find_list(b"btdk")?.bytes()?)
     }
 
     /// The Source Text property record: the `tdbs` in `btds[ADBE Text Document]` (a placeholder
@@ -1075,9 +1080,10 @@ pub enum CueType {
 
 impl<'a> Chunk<'a> {
     /// The marker list `LIST mrst` of a marker holder: a layer (`LIST Layr`) or a composition's
-    /// `SecL` list. A layer's `mrst` is a direct child of its root `tdgp` (`ADBE Marker`), so only
-    /// that place is looked at; most layers have none, and searching their whole property tree
-    /// for it was a large part of an import. Any other holder is searched depth-first.
+    /// `SecL` list. A layer's `mrst` is a direct child of its root `tdgp` (`ADBE Marker`, where
+    /// After Effects and the exporter write it), so only that place is looked at; most layers have
+    /// none, and searching their whole property tree for it was a large part of an import. Any
+    /// other holder is searched depth-first.
     pub(crate) fn marker_list(&self) -> Option<&Chunk<'a>> {
         if self.is_list(b"Layr") {
             return self.child_list(b"tdgp")?.child_list(b"mrst");
@@ -1150,9 +1156,52 @@ impl<'f, 'a> Comp<'f, 'a> {
 /// kept as the reference the differential tests compare with.
 #[cfg(test)]
 mod oracle {
-    use super::{MAX_DEPTH, TextValue};
+    use super::{MAX_DEPTH, MAX_UNDECODED_FIELDS, TextValue};
     use crate::container::bytes::text;
 
+    pub(super) fn same(a: &TextValue, b: &TextValue) -> bool {
+        match (a, b) {
+            (TextValue::Dict(x), TextValue::Dict(y)) => x.len() == y.len() && x.iter().all(|(k, v)| y.iter().any(|(k2, v2)| k == k2 && same(v, v2))),
+            (TextValue::Array(x), TextValue::Array(y)) => x.len() == y.len() && x.iter().zip(y).all(|(p, q)| same(p, q)),
+            _ => match (a.as_f64(), b.as_f64()) {
+                (Some(p), Some(q)) => p == q,
+                _ => a == b,
+            },
+        }
+    }
+
+    pub(super) fn is_neutral(v: &TextValue) -> bool {
+        match v {
+            TextValue::Name(n) => n == "nil",
+            TextValue::Bool(b) => !b,
+            TextValue::Array(a) => a.is_empty(),
+            TextValue::Dict(d) => d.is_empty(),
+            other => other.as_f64() == Some(0.0),
+        }
+    }
+
+    pub(super) fn undecoded_fields(actual: &TextValue, sampled: Option<&TextValue>, decoded: &[&str], neutral: &[(&str, &[i64])], out: &mut Vec<String>) {
+        let TextValue::Dict(pairs) = actual else { return };
+        for (key, value) in pairs {
+            if out.len() >= MAX_UNDECODED_FIELDS {
+                return;
+            }
+            if decoded.contains(&key.as_str()) || out.contains(key) {
+                continue;
+            }
+            if neutral.iter().any(|(slot, values)| slot == key && value.as_i64().is_some_and(|v| values.contains(&v))) {
+                continue;
+            }
+            let differs = match sampled.and_then(|s| s.get(key)) {
+                Some(default) => !same(value, default),
+                None => !is_neutral(value),
+            };
+            if differs {
+                out.push(key.clone());
+            }
+        }
+    }
+
     impl TextValue {
         fn key_text(&self) -> String {
             match self {
@@ -1535,6 +1584,16 @@ mod tests {
             let body = [b"/k ".to_vec(), b"[ ".repeat(depth), b"]".repeat(depth)].concat();
             assert_eq!(parse_text_dict(&body), oracle::parse_text_dict(&body), "array depth {depth}");
         }
+        // Dictionaries and arrays mixed (`<< /a [ << /a [ ...`), closed, and left open exactly
+        // at the limit.
+        for depth in 60..=68 {
+            let open: Vec<u8> = (0..depth).flat_map(|i| if i % 2 == 0 { &b"<< /a "[..] } else { &b"[ "[..] }).copied().collect();
+            let close: Vec<u8> = (0..depth).rev().flat_map(|i| if i % 2 == 0 { &b" >>"[..] } else { &b" ]"[..] }).copied().collect();
+            for body in [[b"/k ".to_vec(), open.clone(), b"1".to_vec(), close, b" /z 2".to_vec()].concat(), [b"/k ".to_vec(), open, b"1".to_vec()].concat()] {
+                assert_eq!(parse_text_dict(&body), oracle::parse_text_dict(&body), "mixed depth {depth}");
+                let _ = TextDocument::parse(&body);
+            }
+        }
     }
 
     #[test]
@@ -1571,10 +1630,83 @@ mod tests {
         // An escaped string is copied; a number key is written in its canonical form.
         assert!(matches!(pairs.get(5).map(|p| &p.1), Some(V::Bytes(Cow::Owned(b))) if b == b"(esc"));
         assert_eq!(pairs.get(6).map(|p| p.0.as_ref()), Some("7"));
-        // Containers are sized to what they hold.
+        // Containers hold what was read.
         let V::Dict(outer) = parse_dict(b"/0 << /a 1 /b 2 /c 3 /d 4 /e 5 >> /1 [ 1 2 3 4 5 6 7 8 9 ]") else { panic!("a dict") };
-        assert!(matches!(outer.first().map(|p| &p.1), Some(V::Dict(d)) if d.len() == 5 && d.capacity() == 5));
-        assert!(matches!(outer.get(1).map(|p| &p.1), Some(V::Array(a)) if a.len() == 9 && a.capacity() == 9));
+        assert!(matches!(outer.first().map(|p| &p.1), Some(V::Dict(d)) if d.len() == 5 && d.capacity() >= d.len()));
+        assert!(matches!(outer.get(1).map(|p| &p.1), Some(V::Array(a)) if a.len() == 9 && a.capacity() >= a.len()));
+    }
+
+    #[test]
+    fn slot_checks_agree_with_the_owned_ones() {
+        // Slots: defaults, decoded, neutral-listed and unknown ones. Values: each default as
+        // stored (also as `Int` where it is `2.0`), near misses, neutral values and every kind.
+        let slots = ["0", "6", "7", "17", "24", "34", "35", "37", "43", "55", "68", "77", "79", "86", "95", "96", "200", "x"];
+        let values: &[&[u8]] = &[
+            b"2",
+            b"2.0",
+            b"7",
+            b"1",
+            b"0",
+            b"-1",
+            b"0.5",
+            b"1.2",
+            b"36",
+            b"true",
+            b"false",
+            b"/nil",
+            b"/x",
+            b"/SimpleBlender",
+            b"[ ]",
+            b"<< >>",
+            b"[ .8 1 1.33 ]",
+            b"[ 0.8 1.0 ]",
+            b"[ 1 1 1 ]",
+            b"<< /0 .5 >>",
+            b"<< /0 0 /1 0 >>",
+            b"<< /1 0 /0 0 >>",
+            b"<< /99 /SimpleBlender >>",
+            b"<< /99 /SimplePaint /0 << /0 1 /1 [ 1 1 1 0 ] >> >>",
+            b"<< /99 /SimplePaint /0 << /0 1 /1 [ 1 1 1 1 ] >> >>",
+            b"(plain)",
+            b"(\xfe\xff\0a)",
+            b"word",
+            b"/\xff",
+        ];
+        let mut rng = Rng(0x2545_f491_4f6c_dd1d);
+        let mut listed = 0;
+        for case in 0..20_000 {
+            let mut body = b"/s << ".to_vec();
+            for _ in 0..rng.below(12) {
+                body.push(b'/');
+                body.extend_from_slice(slots.get(rng.below(slots.len())).copied().unwrap_or_default().as_bytes());
+                body.push(b' ');
+                body.extend_from_slice(values.get(rng.below(values.len())).copied().unwrap_or_default());
+                body.push(b' ');
+            }
+            body.extend_from_slice(b">>");
+            let (new, old) = (parse_dict(&body), oracle::parse_text_dict(&body));
+            let (Some(new), Some(old)) = (new.get("s"), old.get("s")) else { panic!("case {case}: a dict") };
+            for (sampled, old_sampled, decoded, neutral) in [
+                (&*STYLE_DEFAULTS, oracle::style_defaults(), DECODED_STYLE_SLOTS, NEUTRAL_STYLE_VALUES),
+                (&*PARAGRAPH_DEFAULTS, oracle::paragraph_defaults(), DECODED_PARAGRAPH_SLOTS, NEUTRAL_PARAGRAPH_VALUES),
+            ] {
+                let (mut a, mut b) = (Vec::new(), Vec::new());
+                undecoded_fields(new, Some(sampled), decoded, neutral, &mut a);
+                oracle::undecoded_fields(old, Some(&old_sampled), decoded, neutral, &mut b);
+                assert_eq!(a, b, "case {case}: {}", String::from_utf8_lossy(&body));
+                listed += a.len();
+            }
+            // Every pair of values compares and reads as neutral alike.
+            if let (V::Dict(x), TextValue::Dict(y)) = (new, old) {
+                for ((_, p), (_, q)) in x.iter().zip(y) {
+                    assert_eq!(is_neutral(p), oracle::is_neutral(q), "case {case}");
+                    for ((_, r), (_, t)) in x.iter().zip(y) {
+                        assert_eq!(same(p, r), oracle::same(q, t), "case {case}");
+                    }
+                }
+            }
+        }
+        assert!(listed > 10_000, "{listed} slots listed");
     }
 
     #[test]

From 9e2461414af08ac181fef7a7664d2d1801b8d513 Mon Sep 17 00:00:00 2001
From: vangel76 <vangel1976@googlemail.com>
Date: Sun, 8 Nov 2026 04:04:44 +0100
Subject: [PATCH 13/30] aep: remove test-only container accessors, share report
 and time-base code (#3281)

- Remove 35 public container accessors that only tests called (header,
  camera/light, keys, footage, masks, shapes, version) and the dead
  StyleMap::switch_name. Tests now check the importer's own reading of the
  same bytes, or the decoder it uses; three import tests gain the values
  the removed checks covered.
- Import and export reports share one loss entry (Loss<C>) with record,
  total, count and summary; the JSON shape is pinned for both.
- Collector::lose_with builds a detail only below the detail cap (callers
  switch later).
- The export uses the container's TimeBase; one NTSC table serves import
  and export; TimeBase::frames saturates like units instead of returning 0.
---
 crates/aep/src/container/camera.rs            |  89 --------------
 crates/aep/src/container/footage.rs           |  26 -----
 crates/aep/src/container/header.rs            |  81 -------------
 crates/aep/src/container/keys.rs              |  41 +------
 crates/aep/src/container/masks.rs             |  12 +-
 crates/aep/src/container/shapes.rs            |  11 +-
 crates/aep/src/container/style_map.rs         |   4 -
 crates/aep/src/container/version.rs           |   9 +-
 crates/aep/src/export/report.rs               |  79 ++++++++++---
 crates/aep/src/export/timebase.rs             |  70 ++++++-----
 crates/aep/src/import/report.rs               | 110 ++++++++++++++++--
 crates/aep/src/import/time.rs                 |  15 ++-
 crates/aep/tests/it/common/mod.rs             |   7 ++
 crates/aep/tests/it/container/batch3_core.rs  |  30 ++---
 .../aep/tests/it/container/batch3_objects.rs  |  96 +++------------
 crates/aep/tests/it/container/cases_600.rs    |   4 +-
 crates/aep/tests/it/container/header.rs       |  57 +++------
 crates/aep/tests/it/container/helpers.rs      |   3 +-
 crates/aep/tests/it/container/keyframes.rs    |  11 +-
 .../aep/tests/it/container/layer_switches.rs  |  46 +++-----
 crates/aep/tests/it/container/matte.rs        |   2 +-
 crates/aep/tests/it/container/robustness.rs   |  83 ++++---------
 .../it/container/text_markers_footage.rs      |   2 -
 crates/aep/tests/it/container/typed.rs        |   2 +-
 crates/aep/tests/it/container/values.rs       |   9 +-
 crates/aep/tests/it/export/built.rs           |   3 +-
 crates/aep/tests/it/export/masks.rs           |   5 +-
 crates/aep/tests/it/export/objects.rs         |  51 +++++---
 crates/aep/tests/it/export/precomp.rs         |   6 +-
 crates/aep/tests/it/import/cameras.rs         |  24 +++-
 crates/aep/tests/it/import/versions.rs        |   3 +-
 31 files changed, 392 insertions(+), 599 deletions(-)

diff --git a/crates/aep/src/container/camera.rs b/crates/aep/src/container/camera.rs
index 15623fd2c..0b72537ef 100644
--- a/crates/aep/src/container/camera.rs
+++ b/crates/aep/src/container/camera.rs
@@ -16,7 +16,6 @@
 //!   only when it is not the default 100.
 
 use crate::container::typed::{Layer, PropNode};
-use crate::container::values::{Tracked, ValueSource, read, read_opt};
 
 /// The Position of a camera or light layer as stored.
 #[derive(Debug, Clone, Copy, PartialEq)]
@@ -28,16 +27,6 @@ pub struct CameraPosition {
     pub auto_state: bool,
 }
 
-impl CameraPosition {
-    /// The position as the batch-3 notes had After Effects report it: in the auto state of a
-    /// two-node camera (`two_node`) x and y are the composition centre; otherwise the stored
-    /// value. **Contradicted by 256 and 537 (session S16): After Effects reports and renders the
-    /// stored value**; use `stored` for what After Effects shows.
-    pub fn reported(&self, comp_width: u32, comp_height: u32, two_node: bool) -> [f64; 3] {
-        if self.auto_state && two_node { [f64::from(comp_width) / 2.0, f64::from(comp_height) / 2.0, self.stored[2]] } else { self.stored }
-    }
-}
-
 impl<'f, 'a> Layer<'f, 'a> {
     /// The Position record of a camera or light layer.
     pub fn camera_position(&self) -> Option<CameraPosition> {
@@ -49,87 +38,9 @@ impl<'f, 'a> Layer<'f, 'a> {
         let derived = h.get(76) == Some(&1) && h.get(77) == Some(&1) && position.expression().is_none();
         Some(CameraPosition { stored, auto_state: derived })
     }
-
-    /// The point of interest of a camera in pixels (its Anchor Point record); `None` when absent.
-    pub fn camera_point_of_interest(&self) -> Option<[f64; 3]> {
-        let Some(PropNode::Group(transform)) = self.properties()?.get("ADBE Transform Group") else { return None };
-        let tracked = read(&transform, "ADBE Anchor Point", [0.0; 3], 1.0);
-        matches!(tracked.source, ValueSource::Stored | ValueSource::Keyframed).then_some(tracked.value)
-    }
-
-    /// A light's intensity in percent; the default 100 when the property is absent.
-    pub fn light_intensity(&self) -> Option<Tracked<f64>> {
-        let root = self.properties()?;
-        let Some(PropNode::Group(options)) = root.get("ADBE Light Options Group") else { return None };
-        let t = read(&options, "ADBE Light Intensity", [100.0], 1.0);
-        Some(Tracked { value: t.value[0], source: t.source })
-    }
 }
 
 /// The camera zoom After Effects uses when `ADBE Camera Zoom` is absent: 2666.67 px for the 50 mm
 /// default camera in the 1920 px wide corpus composition. Whether it follows other composition
 /// widths was not sampled.
 pub const DEFAULT_CAMERA_ZOOM: f64 = 2_666.666_666_666_666_5;
-
-impl<'f, 'a> Layer<'f, 'a> {
-    fn camera_options(&self) -> Option<crate::container::typed::PropGroup<'f, 'a>> {
-        match self.properties()?.get("ADBE Camera Options Group") {
-            Some(PropNode::Group(g)) => Some(g),
-            _ => None,
-        }
-    }
-
-    fn light_options(&self) -> Option<crate::container::typed::PropGroup<'f, 'a>> {
-        match self.properties()?.get("ADBE Light Options Group") {
-            Some(PropNode::Group(g)) => Some(g),
-            _ => None,
-        }
-    }
-
-    /// A camera's zoom in pixels (`ADBE Camera Options Group/ADBE Camera Zoom`); absent = the
-    /// default, [`DEFAULT_CAMERA_ZOOM`] (341: 2000 is stored). The auto Position keeps `-2666.67` and
-    /// is not recomputed from the zoom.
-    pub fn camera_zoom(&self) -> Option<Tracked<f64>> {
-        let t = read(&self.camera_options()?, "ADBE Camera Zoom", [DEFAULT_CAMERA_ZOOM], 1.0);
-        Some(Tracked { value: t.value[0], source: t.source })
-    }
-
-    /// The depth of field switch (`ADBE Camera Depth of Field`, a checkbox; off by default, 342).
-    pub fn camera_depth_of_field(&self) -> Option<Tracked<bool>> {
-        let t = read(&self.camera_options()?, "ADBE Camera Depth of Field", [0.0], 1.0);
-        Some(Tracked { value: t.value[0] != 0.0, source: t.source })
-    }
-
-    /// A camera's focus distance in pixels (`ADBE Camera Focus Distance`); `None` while absent (its
-    /// default is not known).
-    pub fn camera_focus_distance(&self) -> Option<Tracked<f64>> {
-        let t = read_opt::<1>(&self.camera_options()?, "ADBE Camera Focus Distance", 1.0)?;
-        Some(Tracked { value: t.value[0], source: t.source })
-    }
-
-    /// A camera's aperture (`ADBE Camera Aperture`); `None` while absent (its default is not known).
-    pub fn camera_aperture(&self) -> Option<Tracked<f64>> {
-        let t = read_opt::<1>(&self.camera_options()?, "ADBE Camera Aperture", 1.0)?;
-        Some(Tracked { value: t.value[0], source: t.source })
-    }
-
-    /// A light's colour as `[A, R, G, B]` fractions (`ADBE Light Options Group/ADBE Light Color`,
-    /// stored as doubles 0..255); white when absent (343 stores red).
-    pub fn light_color(&self) -> Option<Tracked<[f64; 4]>> {
-        Some(read(&self.light_options()?, "ADBE Light Color", [1.0; 4], 1.0 / 255.0))
-    }
-
-    /// A spot light's cone angle in degrees (`ADBE Light Cone Angle`); 90 when absent (344 stores 60).
-    /// A point light stores 90 with `tdsb` 3.
-    pub fn light_cone_angle(&self) -> Option<Tracked<f64>> {
-        let t = read(&self.light_options()?, "ADBE Light Cone Angle", [90.0], 1.0);
-        Some(Tracked { value: t.value[0], source: t.source })
-    }
-
-    /// A spot light's cone feather in percent (`ADBE Light Cone Feather 2`); 50 when absent (345
-    /// stores 30).
-    pub fn light_cone_feather(&self) -> Option<Tracked<f64>> {
-        let t = read(&self.light_options()?, "ADBE Light Cone Feather 2", [50.0], 1.0);
-        Some(Tracked { value: t.value[0], source: t.source })
-    }
-}
diff --git a/crates/aep/src/container/footage.rs b/crates/aep/src/container/footage.rs
index da0369d64..c1007fce5 100644
--- a/crates/aep/src/container/footage.rs
+++ b/crates/aep/src/container/footage.rs
@@ -48,21 +48,6 @@ pub struct Footage {
 }
 
 impl Footage {
-    /// The number of frames of an image sequence (`duration * native_frame_rate`: 3/30 s at 30 fps is
-    /// 3); `None` for anything else.
-    pub fn sequence_frame_count(&self) -> Option<u32> {
-        if !self.is_sequence {
-            return None;
-        }
-        let d = self.duration?;
-        let frames = i128::from(d.num).checked_mul(i128::from(self.native_frame_rate))?;
-        let den = i128::from(d.den);
-        if den <= 0 || frames % den != 0 {
-            return None;
-        }
-        u32::try_from(frames / den).ok()
-    }
-
     /// The solid's colour as fractions R, G, B.
     pub fn solid_rgb(&self) -> Option<[f32; 3]> {
         let [_, r, g, b] = self.solid_argb?;
@@ -297,12 +282,6 @@ impl<'f, 'a> Item<'f, 'a> {
         self.chunk.child(b"idta")?.bytes()?.get(58).copied()
     }
 
-    /// The ids of the compositions this item uses as precomp layers: the little-endian `u32` of
-    /// each `idpi` chunk.
-    pub fn used_item_ids(&self) -> Vec<u32> {
-        self.chunk.children().iter().filter(|c| c.is(b"idpi")).filter_map(|c| le_u32(c.bytes()?, 0)).collect()
-    }
-
     /// The footage data of a footage item.
     pub fn footage(&self) -> Option<Footage> {
         if self.kind()? != ItemKind::Footage {
@@ -351,11 +330,6 @@ impl<'f, 'a> Project<'f, 'a> {
         self.item_by_id(layer.header()?.source_id?)
     }
 
-    /// The name a layer shows: its own name, or its source's name when it has none.
-    pub fn layer_display_name(&self, layer: &Layer<'f, 'a>) -> Option<String> {
-        layer.name().or_else(|| self.layer_source(layer)?.display_name())
-    }
-
     /// The pixel size of a layer's source: a footage item's width and height, or a precomp's
     /// composition size.
     pub fn layer_source_size(&self, layer: &Layer<'f, 'a>) -> Option<(u32, u32)> {
diff --git a/crates/aep/src/container/header.rs b/crates/aep/src/container/header.rs
index 508353eb2..060d37840 100644
--- a/crates/aep/src/container/header.rs
+++ b/crates/aep/src/container/header.rs
@@ -237,12 +237,6 @@ impl LayerHeader {
         self.flag_bytes.get(byte).is_some_and(|b| b & mask != 0)
     }
 
-    /// Byte 37 bit `0x01`: the layer has a name set by the user (clear on a default-named camera or
-    /// light and on a precomp layer, whose name is the source's).
-    pub fn name_is_user_set(&self) -> bool {
-        self.flag(0, 0x01)
-    }
-
     /// Byte 37 bit `0x02`: guide layer.
     pub fn is_guide(&self) -> bool {
         self.flag(0, 0x02)
@@ -333,17 +327,6 @@ impl LayerHeader {
         Rational::new(i64::from(self.stretch), i64::from(self.stretch_den))
     }
 
-    /// The time stretch in percent (`stretch / stretch_den * 100`); a zero denominator reads as 1.
-    pub fn stretch_percent(&self) -> f64 {
-        let den = if self.stretch_den == 0 { 1.0 } else { f64::from(self.stretch_den) };
-        f64::from(self.stretch) / den * 100.0
-    }
-
-    /// The start time in seconds, `None` for a zero denominator.
-    pub fn start_seconds(&self) -> Option<f64> {
-        self.start.to_f64()
-    }
-
     /// The absolute in point, `start + in * stretch`, exact and reduced.
     pub fn in_point(&self) -> Option<Rational> {
         self.start.plus_scaled(&self.in_relative, &self.stretch_ratio()?)
@@ -355,16 +338,6 @@ impl LayerHeader {
     pub fn out_point(&self) -> Option<Rational> {
         self.start.plus_scaled(&self.out_relative, &self.stretch_ratio()?)
     }
-
-    /// The absolute in point in seconds.
-    pub fn in_point_seconds(&self) -> Option<f64> {
-        self.in_point()?.to_f64()
-    }
-
-    /// The absolute out point in seconds.
-    pub fn out_point_seconds(&self) -> Option<f64> {
-        self.out_point()?.to_f64()
-    }
 }
 
 impl<'f, 'a> Layer<'f, 'a> {
@@ -464,64 +437,10 @@ impl CompHeader {
         self.time_base.frame_rate()
     }
 
-    /// The frame rate from the 16.16 fixed-point field (25 is `0x0019_0000`).
-    pub fn frame_rate_from_fixed(&self) -> f64 {
-        f64::from(self.frame_rate_fixed) / 65536.0
-    }
-
     /// The duration in seconds.
     pub fn duration_seconds(&self) -> Option<f64> {
         self.time_base.seconds(i32::try_from(self.duration_units).ok()?)
     }
-
-    /// The work area start in seconds.
-    pub fn work_area_start_seconds(&self) -> Option<f64> {
-        self.time_base.seconds(i32::try_from(self.work_area_start_units).ok()?)
-    }
-
-    /// The work area end in seconds; the composition duration when the work area is the whole
-    /// composition.
-    pub fn work_area_end_seconds(&self) -> Option<f64> {
-        match self.work_area_end_units {
-            Some(end) => self.time_base.seconds(i32::try_from(end).ok()?),
-            None => self.duration_seconds(),
-        }
-    }
-
-    /// The background colour as fractions 0..1 (`byte / 255`).
-    pub fn background_rgb(&self) -> [f64; 3] {
-        self.background.map(|c| f64::from(c) / 255.0)
-    }
-
-    /// The pixel aspect ratio as a number.
-    pub fn pixel_aspect_ratio(&self) -> Option<f64> {
-        self.pixel_aspect.to_f64()
-    }
-
-    /// The display start time in seconds (the start timecode), `None` when absent or the
-    /// denominator is zero.
-    pub fn display_start_seconds(&self) -> Option<f64> {
-        self.display_start?.to_f64()
-    }
-
-    /// The display start as a frame number (`display start * frame rate`, rounded); 100 at 25 fps
-    /// for a display start of 4 s.
-    pub fn display_start_frame(&self) -> Option<i64> {
-        let rate = self.frame_rate()?;
-        Some((self.display_start_seconds()? * rate).round() as i64)
-    }
-
-    /// The frame rate as an exact fraction `timescale / frame_duration`, as typed: 29.97 fps is
-    /// `23976 / 800` (not `30000 / 1001`), 23.976 fps is `23976 / 1000`.
-    pub fn frame_rate_exact(&self) -> Option<Rational> {
-        Rational::new(i64::from(self.time_base.timescale), i64::from(self.time_base.frame_duration))
-    }
-
-    /// The duration in whole frames (`duration / frame_duration`). After Effects snaps a duration
-    /// to a whole number of frames: 5 s at 29.97 fps becomes 150 frames (5.005 s).
-    pub fn duration_frames(&self) -> Option<u32> {
-        self.duration_units.checked_div(self.time_base.frame_duration)
-    }
 }
 
 impl<'f, 'a> Comp<'f, 'a> {
diff --git a/crates/aep/src/container/keys.rs b/crates/aep/src/container/keys.rs
index d78bc6693..06fcaecc5 100644
--- a/crates/aep/src/container/keys.rs
+++ b/crates/aep/src/container/keys.rs
@@ -193,19 +193,10 @@ impl<'f> Keyframe<'f> {
         }
     }
 
-    /// The value of a 3-component spatial keyframe (Position), x, y and z in pixels.
-    pub fn spatial_value(&self) -> Option<[f64; 3]> {
-        let v = self.value()?;
-        if !matches!(self.kind(), KeyframeKind::Spatial { components: 3 }) {
-            return None;
-        }
-        Some([*v.first()?, *v.get(1)?, *v.get(2)?])
-    }
-
     /// The ease of the key: the four slots at byte 16 of a one-component plain record or at byte 24
     /// of a spatial record or a mask path record. For linear and hold keys all four are 0 (a bezier key stores what
     /// `setTemporalEase` was given). Plain records with several components keep four slots per
-    /// component, see [`Keyframe::ease_component`] and [`Keyframe::plain_ease_slots`].
+    /// component, see [`Keyframe::ease_component`].
     pub fn ease(&self) -> Option<KeyEase> {
         match self.kind() {
             KeyframeKind::Plain { components: 1 } => ease_at(self.record, 16),
@@ -214,16 +205,6 @@ impl<'f> Keyframe<'f> {
         }
     }
 
-    /// The `4 n` ease `f64` of a plain record as stored (from byte `8 + 8 n`). With one component
-    /// they are [`Keyframe::ease`]; with several they are type-major, see
-    /// [`Keyframe::ease_component`].
-    pub fn plain_ease_slots(&self) -> Option<Vec<f64>> {
-        match self.kind() {
-            KeyframeKind::Plain { components } => doubles(self.record, components.checked_mul(8)?.checked_add(8)?, components.checked_mul(4)?),
-            _ => None,
-        }
-    }
-
     /// The ease of one value component. A plain record with `n` components stores the `4 n` ease
     /// doubles **type-major**: `[in speed x n][in influence x n][out speed x n][out influence x n]`
     /// starting at byte `8 + 8 n`, and component `i` uses slot `i` of each block (verified for the
@@ -260,16 +241,6 @@ impl<'f> Keyframe<'f> {
         (0..n).map(|i| self.ease_component(i)).collect()
     }
 
-    /// The Euclidean ARGB distance to the next key that After Effects writes at byte 16 of a colour
-    /// (4-component spatial) record whose interpolation is not linear: 255 sqrt(2) = 360.6245 for
-    /// red to blue; 0 on the last key and on linear keys. `None` for other records.
-    pub fn color_distance(&self) -> Option<f64> {
-        match self.kind() {
-            KeyframeKind::Spatial { components: 4 } => be_f64(self.record, 16),
-            _ => None,
-        }
-    }
-
     /// The decoded spatial record (Position: 128 bytes, colour: 152 bytes).
     pub fn spatial(&self) -> Option<SpatialKey> {
         let KeyframeKind::Spatial { components: n } = self.kind() else { return None };
@@ -300,11 +271,6 @@ pub struct ExpressionFlags {
 }
 
 impl ExpressionFlags {
-    /// True when bytes 76, 77 and 120 are all 1.
-    pub fn all_set(&self) -> bool {
-        self.byte_76 == 1 && self.byte_77 == 1 && self.byte_120 == 1
-    }
-
     /// True when byte 119 is 1.
     pub fn disabled(&self) -> bool {
         self.byte_119 == 1
@@ -324,11 +290,6 @@ impl<'f, 'a> Property<'f, 'a> {
         be_u32(self.chunk.child(b"tdsb")?.bytes()?, 0)
     }
 
-    /// True when `tdb4` byte 5 has bit 0 set: the property is static, it has no keyframes.
-    pub fn is_static_flag_set(&self) -> Option<bool> {
-        Some(self.header()?.get(5)? & 1 != 0)
-    }
-
     /// The expression source: the raw UTF-8 text of the `Utf8` child that follows the value in the
     /// property (no length prefix, no engine tag; the engine is project-wide).
     pub fn expression(&self) -> Option<String> {
diff --git a/crates/aep/src/container/masks.rs b/crates/aep/src/container/masks.rs
index 7e77c69e9..6246fc1f5 100644
--- a/crates/aep/src/container/masks.rs
+++ b/crates/aep/src/container/masks.rs
@@ -8,7 +8,7 @@
 
 use crate::container::Chunk;
 use crate::container::bytes::{be_f32, be_u32, until_nul};
-use crate::container::typed::{KeyList, Layer, Project, PropGroup, PropNode, Property};
+use crate::container::typed::{KeyList, Layer, PropGroup, PropNode, Property};
 use crate::container::values::{Tracked, read};
 
 /// The mask mode (`mkif` `u32` at byte 4).
@@ -193,16 +193,6 @@ fn mask_from_atom(atom: &PropGroup<'_, '_>, mkif: Option<&[u8]>) -> Mask {
     mask
 }
 
-impl<'f, 'a> Project<'f, 'a> {
-    /// The vertices of every path shape of a mask in pixels of the layer: mask boxes are normalised
-    /// to the **layer** size (the size of its source), not the composition's. `None` when the layer
-    /// has no source with a size.
-    pub fn mask_vertices_px(&self, layer: &Layer<'f, 'a>, mask: &Mask) -> Option<Vec<Vec<PathVertex>>> {
-        let (width, height) = self.layer_source_size(layer)?;
-        Some(mask.shapes.iter().map(|s| s.vertices((f64::from(width), f64::from(height)))).collect())
-    }
-}
-
 /// One mask with the views of its records, for readers that need more than [`Mask`]: the
 /// keyframes and expressions of the mask properties (in [`MaskAtom::atom`]: `ADBE Mask Feather`,
 /// `ADBE Mask Opacity`, `ADBE Mask Offset`) and the path keyframes paired with their shapes.
diff --git a/crates/aep/src/container/shapes.rs b/crates/aep/src/container/shapes.rs
index ea89155a1..8aad83d3f 100644
--- a/crates/aep/src/container/shapes.rs
+++ b/crates/aep/src/container/shapes.rs
@@ -10,7 +10,7 @@
 //! points are in pixels relative to the layer origin.
 
 use crate::container::masks::ShapePath;
-use crate::container::typed::{Layer, PropGroup, PropNode, Property};
+use crate::container::typed::{Layer, PropGroup, PropNode};
 use crate::container::values::{Tracked, read, read_opt};
 
 /// The stroke line cap (`ADBE Vector Stroke Line Cap`, stored as a double; butt is the default and
@@ -262,12 +262,3 @@ impl<'f, 'a> Layer<'f, 'a> {
             .collect()
     }
 }
-
-impl<'f, 'a> Property<'f, 'a> {
-    /// The ARGB fractions of a static colour property (4 components stored as doubles 0..255).
-    pub fn color_argb(&self) -> Option<[f64; 4]> {
-        let v = self.static_value()?;
-        let [a, r, g, b] = *v.as_slice().first_chunk::<4>()?;
-        Some([a / 255.0, r / 255.0, g / 255.0, b / 255.0])
-    }
-}
diff --git a/crates/aep/src/container/style_map.rs b/crates/aep/src/container/style_map.rs
index fdb28c875..bc3169c9e 100644
--- a/crates/aep/src/container/style_map.rs
+++ b/crates/aep/src/container/style_map.rs
@@ -73,10 +73,6 @@ pub struct StyleMap {
 }
 
 impl StyleMap {
-    /// The switch group's match name (`dropShadow/enabled`).
-    pub fn switch_name(&self) -> String {
-        format!("{}/enabled", self.ae)
-    }
     /// A parameter's full match name (`dropShadow/opacity`).
     pub fn param_name(&self, p: &StyleParam) -> String {
         format!("{}/{}", self.ae, p.ae)
diff --git a/crates/aep/src/container/version.rs b/crates/aep/src/container/version.rs
index bf3fbf4c4..1c859cdac 100644
--- a/crates/aep/src/container/version.rs
+++ b/crates/aep/src/container/version.rs
@@ -8,7 +8,7 @@
 
 use std::fmt;
 
-use crate::container::bytes::{be_u16, be_u32};
+use crate::container::bytes::be_u32;
 use crate::container::chunk::AepFile;
 
 /// An After Effects version as packed in `head` / `svap`: `26.2.1x2` is major 26, minor 2, bug-fix
@@ -80,13 +80,6 @@ impl AepFile<'_> {
     pub fn saved_by_version(&self) -> Option<AeVersion> {
         AeVersion::from_word(be_u32(self.chunk(b"svap")?.bytes()?, 0)?)
     }
-
-    /// The `u16` at `head` byte 0: 97 (`0x61`) in a 2026 file, 96 in a copy saved as 25.x, 95 as
-    /// 24.x. It steps with the major version of [`AepFile::file_version`]; what it counts is not
-    /// known, so nothing is derived from it.
-    pub fn head_revision(&self) -> Option<u16> {
-        be_u16(self.chunk(b"head")?.bytes()?, 0)
-    }
 }
 
 #[cfg(test)]
diff --git a/crates/aep/src/export/report.rs b/crates/aep/src/export/report.rs
index 7caba0e7d..309f564e8 100644
--- a/crates/aep/src/export/report.rs
+++ b/crates/aep/src/export/report.rs
@@ -7,8 +7,9 @@ use std::collections::BTreeMap;
 
 use serde::{Deserialize, Serialize};
 
-/// Most example lines kept per loss category (the count is always exact).
-pub const MAX_DETAILS: usize = 20;
+/// Most example lines kept per loss category (the count is always exact); the same as the import
+/// report's.
+pub const MAX_DETAILS: usize = crate::import::MAX_DETAILS;
 
 /// Why a piece of the project did not arrive in the `.aep`, or arrived changed.
 #[derive(Clone, Copy, Debug, PartialEq, Eq, PartialOrd, Ord, Hash, Serialize, Deserialize)]
@@ -130,15 +131,9 @@ impl LossCategory {
     }
 }
 
-/// One category of things that were not exported.
-#[derive(Clone, Debug, PartialEq, Eq, Serialize, Deserialize)]
-pub struct Loss {
-    pub category: LossCategory,
-    /// How many occurrences (exact).
-    pub count: usize,
-    /// Up to [`MAX_DETAILS`] example lines.
-    pub details: Vec<String>,
-}
+/// One category of things that were not exported: the import report's loss entry with the
+/// export categories.
+pub type Loss = crate::import::Loss<LossCategory>;
 
 /// What was written to the file.
 #[derive(Clone, Debug, Default, PartialEq, Eq, Serialize, Deserialize)]
@@ -222,7 +217,7 @@ pub struct ExportReport {
 impl ExportReport {
     /// The sum of all loss counts.
     pub fn total_losses(&self) -> usize {
-        self.losses.iter().map(|l| l.count).sum()
+        Loss::total(&self.losses)
     }
 
     /// True when nothing was lost.
@@ -232,12 +227,12 @@ impl ExportReport {
 
     /// The loss count of a category.
     pub fn count(&self, category: LossCategory) -> usize {
-        self.losses.iter().find(|l| l.category == category).map_or(0, |l| l.count)
+        Loss::count_of(&self.losses, category)
     }
 
     /// `effects: 3, masks: 1` (empty when lossless).
     pub fn summary(&self) -> String {
-        self.losses.iter().map(|l| format!("{}: {}", l.category.label(), l.count)).collect::<Vec<_>>().join(", ")
+        Loss::summary(&self.losses, LossCategory::label)
     }
 }
 
@@ -251,11 +246,7 @@ pub(crate) struct Collector {
 impl Collector {
     /// Records one loss.
     pub fn lose(&mut self, category: LossCategory, detail: impl Into<String>) {
-        let loss = self.losses.entry(category).or_insert_with(|| Loss { category, count: 0, details: Vec::new() });
-        loss.count = loss.count.saturating_add(1);
-        if loss.details.len() < MAX_DETAILS {
-            loss.details.push(detail.into());
-        }
+        Loss::record(&mut self.losses, category, move || detail.into());
     }
 
     pub fn finish(self) -> ExportReport {
@@ -266,3 +257,53 @@ impl Collector {
         }
     }
 }
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    fn collected() -> ExportReport {
+        let mut col = Collector::default();
+        col.exported.layers = 2;
+        col.lose(LossCategory::RoundedTimes, "time 1");
+        col.lose(LossCategory::Effects, String::from("fx 1"));
+        col.lose(LossCategory::Effects, "fx 2");
+        let mut report = col.finish();
+        report.limitations.truncate(1);
+        report.limitations[0] = "limit".into();
+        report
+    }
+
+    /// The JSON shape agents read: field names, category spelling, order and the loss entries.
+    #[test]
+    fn the_json_shape_is_pinned() {
+        let json = serde_json::to_string(&collected()).unwrap();
+        assert_eq!(
+            json,
+            r#"{"exported":{"folders":0,"compositions":0,"solids":0,"layers":2,"solidLayers":0,"nullLayers":0,"adjustmentLayers":0,"properties":0,"keyframes":0,"expressions":0,"masks":0,"precompLayers":0,"effects":0,"footage":0,"footageLayers":0,"textLayers":0,"markers":0,"cameras":0,"lights":0,"shapeLayers":0,"timeRemaps":0,"textAnimators":0,"layerStyles":0},"losses":[{"category":"effects","count":2,"details":["fx 1","fx 2"]},{"category":"rounded_times","count":1,"details":["time 1"]}],"limitations":["limit"]}"#
+        );
+        let back: ExportReport = serde_json::from_str(&json).unwrap();
+        assert_eq!(back, collected());
+    }
+
+    #[test]
+    fn the_queries_read_the_losses() {
+        let report = collected();
+        assert_eq!((report.total_losses(), report.is_lossless()), (3, false));
+        assert_eq!((report.count(LossCategory::Effects), report.count(LossCategory::Lights)), (2, 0));
+        assert_eq!(report.summary(), "effects: 2, rounded times: 1");
+        let empty = Collector::default().finish();
+        assert_eq!((empty.total_losses(), empty.is_lossless(), empty.summary()), (0, true, String::new()));
+    }
+
+    #[test]
+    fn details_stop_at_the_cap() {
+        let mut col = Collector::default();
+        for i in 0..MAX_DETAILS + 5 {
+            col.lose(LossCategory::Masks, format!("mask {i}"));
+        }
+        let report = col.finish();
+        assert_eq!(report.count(LossCategory::Masks), MAX_DETAILS + 5);
+        assert_eq!(report.losses[0].details.len(), MAX_DETAILS);
+    }
+}
diff --git a/crates/aep/src/export/timebase.rs b/crates/aep/src/export/timebase.rs
index 7414a1aa7..05c464e94 100644
--- a/crates/aep/src/export/timebase.rs
+++ b/crates/aep/src/export/timebase.rs
@@ -9,13 +9,9 @@
 
 use effectcraft_time::{FrameRate, TICKS_PER_SECOND, Tick};
 
-/// Frame duration and time scale in units; one frame lasts `frame_duration` units and a second
-/// has `timescale` units.
-#[derive(Clone, Copy, Debug, PartialEq, Eq)]
-pub(crate) struct TimeBase {
-    pub frame_duration: u32,
-    pub timescale: u32,
-}
+/// The container's time base (frame duration and time scale in units; one frame lasts
+/// `frame_duration` units and a second has `timescale` units), which the importer reads.
+pub(crate) use crate::container::TimeBase;
 
 /// The 16.16 fixed-point rate After Effects stores next to the time base (a float32 rate).
 pub(crate) fn fixed_rate(rate: FrameRate) -> u32 {
@@ -26,11 +22,8 @@ pub(crate) fn fixed_rate(rate: FrameRate) -> u32 {
 
 /// The typed value of an NTSC rate (23.976, 29.97, 59.94, 119.88), which After Effects stores as
 /// a float32 of exactly these decimals.
-pub(crate) fn ntsc_typed(rate: FrameRate) -> Option<f32> {
-    [(FrameRate::FPS_23_976, 23.976f32), (FrameRate::FPS_29_97, 29.97), (FrameRate::FPS_59_94, 59.94), (FrameRate::FPS_119_88, 119.88)]
-        .into_iter()
-        .find(|(r, _)| *r == rate)
-        .map(|(_, v)| v)
+fn ntsc_typed(rate: FrameRate) -> Option<f32> {
+    TimeBase::NTSC.into_iter().find(|(r, _)| *r == rate).map(|(_, v)| v)
 }
 
 /// The time base for `rate`, or `None` for a rate After Effects cannot hold (non-positive, or not
@@ -67,28 +60,32 @@ pub(crate) fn time_base(rate: FrameRate) -> Option<TimeBase> {
 }
 
 impl TimeBase {
-    /// `tick` in time units, rounded to the nearest unit; the second value tells whether it was
-    /// not exact.
-    pub fn units(&self, tick: Tick) -> (i64, bool) {
-        let n = i128::from(tick.0) * i128::from(self.timescale);
-        let d = i128::from(TICKS_PER_SECOND);
-        let q = n.div_euclid(d);
-        let r = n.rem_euclid(d);
-        let rounded = if r * 2 >= d { q + 1 } else { q };
-        (i64::try_from(rounded).unwrap_or(if rounded < 0 { i64::MIN } else { i64::MAX }), r != 0)
+    /// The NTSC rates and the typed value After Effects stores for each: the one table the
+    /// importer and the exporter use.
+    pub(crate) const NTSC: [(FrameRate, f32); 4] =
+        [(FrameRate::FPS_23_976, 23.976), (FrameRate::FPS_29_97, 29.97), (FrameRate::FPS_59_94, 59.94), (FrameRate::FPS_119_88, 119.88)];
+
+    /// `tick` in time units, rounded to the nearest unit (saturated to `i64`); the second value
+    /// tells whether it was not exact.
+    pub(crate) fn units(&self, tick: Tick) -> (i64, bool) {
+        nearest(i128::from(tick.0).saturating_mul(i128::from(self.timescale)), i128::from(TICKS_PER_SECOND))
     }
 
-    /// Whole frames of `tick` (nearest).
-    pub fn frames(&self, tick: Tick, rate: FrameRate) -> i64 {
-        let n = i128::from(tick.0) * i128::from(rate.num);
-        let d = i128::from(TICKS_PER_SECOND) * i128::from(rate.den.max(1));
-        let q = n.div_euclid(d);
-        let r = n.rem_euclid(d);
-        let f = if r * 2 >= d { q + 1 } else { q };
-        i64::try_from(f).unwrap_or(0)
+    /// Whole frames of `tick` (nearest, saturated to `i64` like [`TimeBase::units`]).
+    pub(crate) fn frames(&self, tick: Tick, rate: FrameRate) -> i64 {
+        let d = i128::from(TICKS_PER_SECOND).saturating_mul(i128::from(rate.den.max(1)));
+        nearest(i128::from(tick.0).saturating_mul(i128::from(rate.num)), d).0
     }
 }
 
+/// `n / d` rounded to the nearest whole number (a half rounds up), saturated to `i64`, and whether
+/// it was not exact. `d` is positive.
+fn nearest(n: i128, d: i128) -> (i64, bool) {
+    let (q, r) = (n.div_euclid(d), n.rem_euclid(d));
+    let rounded = if r.saturating_mul(2) >= d { q.saturating_add(1) } else { q };
+    (i64::try_from(rounded).unwrap_or(if rounded < 0 { i64::MIN } else { i64::MAX }), r != 0)
+}
+
 #[cfg(test)]
 mod tests {
     use super::*;
@@ -131,4 +128,19 @@ mod tests {
         assert!(tb.units(Tick(TICKS_PER_SECOND / 3)).1);
         assert_eq!(tb.frames(Tick(TICKS_PER_SECOND * 2), FrameRate::new(25, 1)), 50);
     }
+
+    /// Frames saturate like units (they used to become 0 past `i64`). No storable rate gets
+    /// there: [`time_base`] only accepts rates far below one frame per tick.
+    #[test]
+    fn frames_and_units_saturate_alike() {
+        let tb = TimeBase { frame_duration: 1024, timescale: u32::MAX };
+        let huge = FrameRate { num: i64::MAX, den: 1 };
+        assert_eq!(tb.frames(Tick(i64::MAX), huge), i64::MAX);
+        assert_eq!(tb.frames(Tick(i64::MIN), huge), i64::MIN);
+        // A half rounds up on the signed value, in frames and in units.
+        assert_eq!(tb.frames(Tick(TICKS_PER_SECOND / 2), FrameRate::new(1, 1)), 1);
+        assert_eq!(tb.frames(Tick(-TICKS_PER_SECOND / 2), FrameRate::new(1, 1)), 0);
+        let tb1 = TimeBase { frame_duration: 1, timescale: 1 };
+        assert_eq!((tb1.units(Tick(TICKS_PER_SECOND / 2)), tb1.units(Tick(-TICKS_PER_SECOND / 2))), ((1, true), (0, true)));
+    }
 }
diff --git a/crates/aep/src/import/report.rs b/crates/aep/src/import/report.rs
index 129fcf143..d7dbfe898 100644
--- a/crates/aep/src/import/report.rs
+++ b/crates/aep/src/import/report.rs
@@ -92,16 +92,45 @@ impl LossCategory {
     }
 }
 
-/// One category of things that were not imported.
+/// One category of things that were not imported. The export report uses the same type with its
+/// own categories (`export::Loss`).
 #[derive(Clone, Debug, PartialEq, Eq, Serialize, Deserialize)]
-pub struct Loss {
-    pub category: LossCategory,
+pub struct Loss<C = LossCategory> {
+    pub category: C,
     /// How many occurrences (exact).
     pub count: usize,
     /// Up to [`MAX_DETAILS`] example lines.
     pub details: Vec<String>,
 }
 
+/// The loss bookkeeping the import and the export report share.
+impl<C: Copy + Ord> Loss<C> {
+    /// Counts one loss of `category`; `detail` is only called while the category holds fewer than
+    /// [`MAX_DETAILS`] lines.
+    pub(crate) fn record(losses: &mut BTreeMap<C, Self>, category: C, detail: impl FnOnce() -> String) {
+        let loss = losses.entry(category).or_insert_with(|| Loss { category, count: 0, details: Vec::new() });
+        loss.count = loss.count.saturating_add(1);
+        if loss.details.len() < MAX_DETAILS {
+            loss.details.push(detail());
+        }
+    }
+
+    /// The sum of all loss counts.
+    pub(crate) fn total(losses: &[Self]) -> usize {
+        losses.iter().map(|l| l.count).sum()
+    }
+
+    /// The loss count of a category.
+    pub(crate) fn count_of(losses: &[Self], category: C) -> usize {
+        losses.iter().find(|l| l.category == category).map_or(0, |l| l.count)
+    }
+
+    /// `effects: 3, masks: 1` (empty without losses).
+    pub(crate) fn summary(losses: &[Self], label: impl Fn(C) -> &'static str) -> String {
+        losses.iter().map(|l| format!("{}: {}", label(l.category), l.count)).collect::<Vec<_>>().join(", ")
+    }
+}
+
 /// What arrived in the project.
 #[derive(Clone, Debug, Default, PartialEq, Eq, Serialize, Deserialize)]
 #[serde(rename_all = "camelCase")]
@@ -243,7 +272,7 @@ impl AeVersionInfo {
 impl ImportReport {
     /// The sum of all loss counts.
     pub fn total_losses(&self) -> usize {
-        self.losses.iter().map(|l| l.count).sum()
+        Loss::total(&self.losses)
     }
 
     /// True when nothing was lost.
@@ -253,12 +282,12 @@ impl ImportReport {
 
     /// The loss count of a category.
     pub fn count(&self, category: LossCategory) -> usize {
-        self.losses.iter().find(|l| l.category == category).map_or(0, |l| l.count)
+        Loss::count_of(&self.losses, category)
     }
 
     /// `effects: 3, masks: 1` (empty when lossless).
     pub fn summary(&self) -> String {
-        self.losses.iter().map(|l| format!("{}: {}", l.category.label(), l.count)).collect::<Vec<_>>().join(", ")
+        Loss::summary(&self.losses, LossCategory::label)
     }
 }
 
@@ -274,11 +303,13 @@ pub(crate) struct Collector {
 impl Collector {
     /// Records one loss.
     pub fn lose(&mut self, category: LossCategory, detail: impl Into<String>) {
-        let loss = self.losses.entry(category).or_insert_with(|| Loss { category, count: 0, details: Vec::new() });
-        loss.count = loss.count.saturating_add(1);
-        if loss.details.len() < MAX_DETAILS {
-            loss.details.push(detail.into());
-        }
+        self.lose_with(category, move || detail.into());
+    }
+
+    /// Records one loss whose detail line is built only while the category holds fewer than
+    /// [`MAX_DETAILS`] lines (for a detail that needs `format!`).
+    pub fn lose_with(&mut self, category: LossCategory, detail: impl FnOnce() -> String) {
+        Loss::record(&mut self.losses, category, detail);
     }
 
     pub fn finish(self) -> ImportReport {
@@ -301,3 +332,60 @@ pub const LIMITATIONS: &[&str] = &[
     "Text: per-character 3D, text on a path and several style slots of unknown meaning are not decoded (stored values that differ from the default are reported as text layer features).",
     "Footage that is not a solid is linked by its stored path with its stored frame rate and duration; the importer never opens the files (use Reload Footage after the files are found).",
 ];
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    fn collected() -> ImportReport {
+        let mut col = Collector::default();
+        col.imported.layers = 2;
+        col.missing_footage.push("a.png".into());
+        col.lose(LossCategory::Masks, "mask 1");
+        col.lose(LossCategory::Effects, String::from("fx 1"));
+        col.lose_with(LossCategory::Effects, || "fx 2".to_string());
+        let mut report = col.finish();
+        report.limitations.truncate(1);
+        report
+    }
+
+    /// The JSON shape agents read: field names, category spelling, order and the loss entries.
+    #[test]
+    fn the_json_shape_is_pinned() {
+        let json = serde_json::to_string(&collected()).unwrap();
+        assert_eq!(
+            json,
+            r#"{"imported":{"folders":0,"compositions":0,"solids":0,"footage":0,"layers":2,"solidLayers":0,"nullLayers":0,"adjustmentLayers":0,"footageLayers":0,"precompLayers":0,"textLayers":0,"keyframes":0,"expressions":0,"masks":0,"trackMattes":0,"markers":0,"timeRemaps":0,"shapeLayers":0,"shapeItems":0,"cameras":0,"lights":0,"textAnimators":0,"effects":0,"layerStyles":0},"losses":[{"category":"effects","count":2,"details":["fx 1","fx 2"]},{"category":"masks","count":1,"details":["mask 1"]}],"missingFootage":["a.png"],"missingFonts":[],"limitations":["Frame blending, 3D material options, audio levels, guides are not decoded and not imported."],"aeVersion":{"fileVersion":"unknown","savedBy":"unknown","tested":false}}"#
+        );
+        let back: ImportReport = serde_json::from_str(&json).unwrap();
+        assert_eq!(back, collected());
+    }
+
+    #[test]
+    fn the_queries_read_the_losses() {
+        let report = collected();
+        assert_eq!((report.total_losses(), report.is_lossless()), (3, false));
+        assert_eq!((report.count(LossCategory::Effects), report.count(LossCategory::Lights)), (2, 0));
+        assert_eq!(report.summary(), "effects: 2, masks: 1");
+        let empty = Collector::default().finish();
+        assert_eq!((empty.total_losses(), empty.is_lossless(), empty.summary()), (0, true, String::new()));
+    }
+
+    /// The count stays exact past the detail cap, and a detail past the cap is never built.
+    #[test]
+    fn details_stop_at_the_cap_and_later_ones_are_not_built() {
+        let mut col = Collector::default();
+        let mut built = 0;
+        for i in 0..MAX_DETAILS + 5 {
+            col.lose_with(LossCategory::Masks, || {
+                built += 1;
+                format!("mask {i}")
+            });
+        }
+        let report = col.finish();
+        assert_eq!(report.count(LossCategory::Masks), MAX_DETAILS + 5);
+        assert_eq!(report.losses[0].details.len(), MAX_DETAILS);
+        assert_eq!(report.losses[0].details.last().map(String::as_str), Some("mask 19"));
+        assert_eq!(built, MAX_DETAILS);
+    }
+}
diff --git a/crates/aep/src/import/time.rs b/crates/aep/src/import/time.rs
index 936d5efcb..ed734fc57 100644
--- a/crates/aep/src/import/time.rs
+++ b/crates/aep/src/import/time.rs
@@ -7,6 +7,8 @@
 
 use effectcraft_time::{FrameRate, TICKS_PER_SECOND, Tick};
 
+use crate::container::TimeBase;
+
 /// The composition's frame structure: the stored time base and the rate the project gets.
 #[derive(Clone, Copy, Debug)]
 pub(crate) struct TimeMap {
@@ -27,12 +29,8 @@ pub(crate) fn frame_rate(timescale: u32, frame_duration: u32) -> Option<FrameRat
     }
     let exact = FrameRate::new(i64::from(timescale), i64::from(frame_duration));
     let fps = exact.as_f64();
-    for ntsc in [FrameRate::FPS_23_976, FrameRate::FPS_29_97, FrameRate::FPS_59_94, FrameRate::FPS_119_88] {
-        if (ntsc.as_f64() - fps).abs() < 0.0005 {
-            return Some(ntsc);
-        }
-    }
-    Some(exact)
+    let ntsc = TimeBase::NTSC.into_iter().map(|(rate, _)| rate).find(|ntsc| (ntsc.as_f64() - fps).abs() < 0.0005);
+    Some(ntsc.unwrap_or(exact))
 }
 
 impl TimeMap {
@@ -83,6 +81,11 @@ mod tests {
         assert_eq!(frame_rate(30720, 1024), Some(FrameRate::new(30, 1)));
         assert_eq!(frame_rate(0, 1), None);
         assert_eq!(frame_rate(1, 0), None);
+        // The time bases the exporter writes for the NTSC rates read back as those rates.
+        let written = [(23976, 1000), (23976, 800), (23976, 400), (23976, 200)];
+        for ((rate, _), (ts, fd)) in TimeBase::NTSC.into_iter().zip(written) {
+            assert_eq!(frame_rate(ts, fd), Some(rate));
+        }
     }
 
     #[test]
diff --git a/crates/aep/tests/it/common/mod.rs b/crates/aep/tests/it/common/mod.rs
index 134aff2fd..01054ba24 100644
--- a/crates/aep/tests/it/common/mod.rs
+++ b/crates/aep/tests/it/common/mod.rs
@@ -128,6 +128,13 @@ pub fn resolve(name: &str) -> Option<PathBuf> {
     locate(name).map(|s| s.path().clone())
 }
 
+/// The ids of the compositions an item uses as precomposition layers, as the file stores them:
+/// the little-endian `u32` of each `idpi` chunk (the importer does not read them; the exporter
+/// writes them).
+pub fn used_item_ids(item: &effectcraft_aep::Item<'_, '_>) -> Vec<u32> {
+    item.chunk().children().iter().filter(|c| c.is(b"idpi")).filter_map(|c| Some(u32::from_le_bytes(c.bytes()?.get(..4)?.try_into().ok()?))).collect()
+}
+
 /// The bytes of a case (see the module comment), or `None` when it is missing.
 pub fn try_fixture(name: &str) -> Option<Vec<u8>> {
     match locate(name)? {
diff --git a/crates/aep/tests/it/container/batch3_core.rs b/crates/aep/tests/it/container/batch3_core.rs
index 925deaa28..1813e2df8 100644
--- a/crates/aep/tests/it/container/batch3_core.rs
+++ b/crates/aep/tests/it/container/batch3_core.rs
@@ -140,16 +140,13 @@ fn scale_keys_keep_their_ease_type_major() {
         }
         assert_near(&keys[0].value().unwrap(), &[1.0, 1.0, 1.0], 1e-9);
         assert_near(&keys[1].value().unwrap(), &[2.0, 1.5, 1.0], 1e-9);
-        // The raw block: [in speed x3][in influence x3][out speed x3][out influence x3].
-        assert_near(&keys[0].plain_ease_slots().unwrap(), &[0.0, 0.0, 0.0, 0.33, 0.33, 0.33, 0.2, 0.2, 0.2, 0.66, 0.66, 0.66], 1e-9);
-        assert_near(&keys[1].plain_ease_slots().unwrap(), &[0.1, 0.1, 0.1, 0.66, 0.66, 0.66, 0.0, 0.0, 0.0, 0.33, 0.33, 0.33], 1e-9);
+        // The raw block is [in speed x3][in influence x3][out speed x3][out influence x3].
         for i in 0..3 {
             assert!(same_ease(&keys[0].ease_component(i).unwrap(), &ease(0.0, 0.33, 0.2, 0.66)), "key 1 component {i}");
             assert!(same_ease(&keys[1].ease_component(i).unwrap(), &ease(0.1, 0.66, 0.0, 0.33)), "key 2 component {i}");
         }
         assert!(keys[0].ease_component(3).is_none());
         assert_eq!(keys[0].ease_components().unwrap().len(), 3);
-        assert!(keys[0].color_distance().is_none());
     }));
 }
 
@@ -172,7 +169,6 @@ fn mask_feather_keys_keep_their_ease_type_major() {
         }
         assert_near(&keys[0].value().unwrap(), &[0.0, 0.0], 1e-9);
         assert_near(&keys[1].value().unwrap(), &[50.0, 30.0], 1e-9);
-        assert_near(&keys[0].plain_ease_slots().unwrap(), &[0.0, 0.0, 0.33, 0.33, 15.0, 15.0, 0.66, 0.66], 1e-9);
         for i in 0..2 {
             assert!(same_ease(&keys[0].ease_component(i).unwrap(), &ease(0.0, 0.33, 15.0, 0.66)), "key 1 component {i}");
             assert!(same_ease(&keys[1].ease_component(i).unwrap(), &ease(8.0, 0.66, 0.0, 0.33)), "key 2 component {i}");
@@ -213,14 +209,15 @@ fn bezier_colour_keys_carry_the_distance_to_the_next_key() {
             assert_eq!((k.interpolation_in(), k.interpolation_out()), (Some(Interpolation::Bezier), Some(Interpolation::Bezier)));
             assert!(same_ease(&k.ease_component(0).unwrap(), &ease(0.0, 0.0, 0.0, 0.0)));
         }
-        assert!(near(keys[0].color_distance().unwrap(), 255.0 * 2f64.sqrt(), 1e-3), "{:?}", keys[0].color_distance());
-        assert!(near(keys[0].color_distance().unwrap(), 360.6245, 1e-3));
-        assert_eq!(keys[1].color_distance(), Some(0.0));
+        let distance = |k: &effectcraft_aep::Keyframe<'_>| k.spatial().unwrap().segment_length;
+        assert!(near(distance(&keys[0]), 255.0 * 2f64.sqrt(), 1e-3), "{}", distance(&keys[0]));
+        assert!(near(distance(&keys[0]), 360.6245, 1e-3));
+        assert_eq!(distance(&keys[1]), 0.0);
     }));
     skip!(with_layer("210-key-fill-color-2key-linear.aep", L, |_, layer| {
         let p = layer.effects()[0].params().into_iter().find(|p| p.name == "Color").unwrap();
         let k = p.stored().unwrap().keys().unwrap().keyframes().next().unwrap();
-        assert_eq!(k.color_distance(), Some(0.0));
+        assert_eq!(k.spatial().unwrap().segment_length, 0.0);
     }));
 }
 
@@ -243,21 +240,19 @@ fn time_stretch_is_an_exact_ratio() {
     let (h, in_p, out_p, scale) = skip!(stretch_facts("316-layer-stretch50.aep"));
     assert_eq!((h.stretch, h.stretch_den), (1, 2));
     assert_eq!(h.stretch_ratio(), Some(rat(1, 2)));
-    assert_eq!(h.stretch_percent(), 50.0);
     assert_eq!(h.out_relative, rat(128000, 25600));
     assert_eq!((in_p, out_p, scale), (Some(rat(0, 1)), Some(rat(5, 2)), 25600));
     // 317: 150 %: 3/2, ends at 7.5 s, the property time scale is 25600 x 3/2.
     let (h, in_p, out_p, scale) = skip!(stretch_facts("317-layer-stretch150.aep"));
     assert_eq!((h.stretch, h.stretch_den), (3, 2));
     assert_eq!(h.stretch_ratio(), Some(rat(3, 2)));
-    assert_eq!(h.stretch_percent(), 150.0);
     assert_eq!((in_p, out_p, scale), (Some(rat(0, 1)), Some(rat(15, 2)), 38400));
     // 018: 200 %: 2/1, ends at 10 s, time scale 51200. The base is 1/1.
     let (h, _, out_p, scale) = skip!(stretch_facts("018-layer-stretch200.aep"));
     assert_eq!((h.stretch, h.stretch_den, h.stretch_ratio()), (2, 1, Some(rat(2, 1))));
     assert_eq!((out_p, scale), (Some(rat(10, 1)), 51200));
     let (h, _, out_p, scale) = skip!(stretch_facts("000-base.aep"));
-    assert_eq!((h.stretch, h.stretch_den, h.stretch_percent()), (1, 1, 100.0));
+    assert_eq!((h.stretch, h.stretch_den, h.stretch_ratio()), (1, 1, Some(rat(1, 1))));
     assert_eq!((out_p, scale), (Some(rat(5, 1)), 25600));
 }
 
@@ -269,9 +264,9 @@ fn fractional_times_are_exact_multiples_of_one_over_25600() {
     assert_eq!(h.in_relative, rat(8532, 25600));
     assert_eq!(h.out_relative, rat(136532, 25600));
     assert_eq!(h.start, rat(0, 25600));
+    // 0.33328125 s and 5.33328125 s.
     assert_eq!(h.in_point(), Some(rat(2133, 6400)));
-    assert_eq!(h.in_point_seconds(), Some(0.33328125));
-    assert_eq!(h.out_point_seconds(), Some(5.33328125));
+    assert_eq!(h.out_point(), Some(rat(34133, 6400)));
     assert_eq!(h.stretch_ratio(), Some(rat(1, 1)));
 }
 
@@ -364,18 +359,17 @@ fn pixel_aspect_shutter_phase_and_display_start() {
     // 325: pixelAspect 0.9091 reads back 0.90909090909091 = the exact ratio 10/11.
     let h = skip!(comp_header("325-comp-pixelaspect-0.9091.aep"));
     assert_eq!(h.pixel_aspect.reduced(), Some(rat(10, 11)));
-    assert!(near(h.pixel_aspect_ratio().unwrap(), 0.90909090909091, 1e-12));
     // 326: shutterPhase -90, the shutter angle stays 180.
     let h = skip!(comp_header("326-comp-shutterphase-m90.aep"));
     assert_eq!((h.shutter_phase, h.shutter_angle), (Some(-90), 180));
     // 327: displayStartFrame 100 at 25 fps = 4 s = 102400/25600; the shutter phase is back to 0.
     let h = skip!(comp_header("327-comp-displaystartframe-100.aep"));
     assert_eq!(h.display_start, Some(rat(102400, 25600)));
-    assert_eq!((h.display_start_seconds(), h.display_start_frame(), h.shutter_phase), (Some(4.0), Some(100), Some(0)));
+    assert_eq!(h.shutter_phase, Some(0));
     // The base: no phase, start 0.
     let h = skip!(comp_header("000-base.aep"));
-    assert_eq!((h.shutter_phase, h.display_start_seconds(), h.display_start_frame()), (Some(0), Some(0.0), Some(0)));
-    assert_eq!(h.pixel_aspect_ratio(), Some(1.0));
+    assert_eq!((h.shutter_phase, h.display_start.and_then(|r| r.reduced())), (Some(0), Some(rat(0, 1))));
+    assert_eq!(h.pixel_aspect.reduced(), Some(rat(1, 1)));
     // A short chunk still decodes the old fields.
     let bytes = [0u8; 176];
     let h = effectcraft_aep::CompHeader::parse(&bytes).unwrap();
diff --git a/crates/aep/tests/it/container/batch3_objects.rs b/crates/aep/tests/it/container/batch3_objects.rs
index d1cfbac29..d4b4f83ba 100644
--- a/crates/aep/tests/it/container/batch3_objects.rs
+++ b/crates/aep/tests/it/container/batch3_objects.rs
@@ -148,19 +148,20 @@ fn a_mask_box_is_normalised_to_the_layer_size() {
     for (got, want) in m.shapes[0].bbox.iter().zip(want_box) {
         assert!(near(f64::from(*got), want, 1e-6), "{:?}", m.shapes[0].bbox);
     }
-    let shapes = project.mask_vertices_px(&layer, m).unwrap();
-    assert_eq!(shapes.len(), 1);
-    let got: Vec<[f64; 2]> = shapes[0].iter().map(|v| v.position).collect();
+    // The importer scales the box by the layer's source size.
+    let (w, h) = project.layer_source_size(&layer).unwrap();
+    assert_eq!(m.shapes.len(), 1);
+    let got: Vec<[f64; 2]> = m.shapes[0].vertices((f64::from(w), f64::from(h))).iter().map(|v| v.position).collect();
     for (g, w) in got.iter().zip([[20.0, 30.0], [80.0, 30.0], [80.0, 70.0], [20.0, 70.0]]) {
         assert_near(g, &w, 1e-3);
     }
     assert_eq!(got.len(), 4);
-    // A layer without a sized source has no pixel vertices.
+    // A layer without a sized source has no size to scale by.
     let bytes = fixture!("333-shape-group-two-rects.aep");
     let file = open(&bytes);
     let project = Project::new(&file).unwrap();
     let shape = layer_named(&first_comp(&project), "Shape");
-    assert!(project.mask_vertices_px(&shape, m).is_none());
+    assert!(project.layer_source_size(&shape).is_none());
 }
 
 #[test]
@@ -178,12 +179,14 @@ fn one_mkif_per_mask_and_the_mode_none() {
         assert_eq!((m.mode, m.inverted, m.counter), (Some(MaskMode::Add), Some(false), Some(counter)));
         assert_eq!(m.shapes.len(), 1);
     }
-    let v1 = project.mask_vertices_px(&layer, &masks[0]).unwrap();
+    let (w, h) = project.layer_source_size(&layer).unwrap();
+    let px = |m: &effectcraft_aep::Mask| m.shapes.iter().map(|s| s.vertices((f64::from(w), f64::from(h)))).collect::<Vec<_>>();
+    let v1 = px(&masks[0]);
     for (v, w) in v1[0].iter().zip(ellipse_vertices()) {
         assert_near(&v.position, &w, 1e-2);
     }
     // Mask 2 has its own box (500..900 x 350..650) normalised to the layer.
-    let v2 = project.mask_vertices_px(&layer, &masks[1]).unwrap();
+    let v2 = px(&masks[1]);
     for (v, w) in v2[0].iter().zip([[500.0, 350.0], [900.0, 350.0], [900.0, 650.0], [500.0, 650.0]]) {
         assert_near(&v.position, &w, 1e-2);
     }
@@ -383,77 +386,14 @@ fn the_last_style_run_absorbs_the_final_carriage_return() {
 // ------------------------------------------------------------------ camera and light (341-345)
 
 #[test]
-fn camera_zoom_and_depth_of_field() {
-    let camera = |name: &str| {
-        Some({
-            let bytes = crate::common::try_fixture(name)?;
-            let file = open(&bytes);
-            let project = Project::new(&file).unwrap();
-            let layer = layer_of_type(&first_comp(&project), LayerType::Camera);
-            (
-                layer.camera_zoom(),
-                layer.camera_depth_of_field(),
-                layer.camera_focus_distance(),
-                layer.camera_aperture(),
-                layer.camera_position().map(|p| (p.stored, p.auto_state)),
-            )
-        })
-    };
-    // 341: Zoom 2000 is stored; the auto Position keeps [0, 0, -2666.67].
-    let (zoom, dof, focus, aperture, pos) = skip!(camera("341-camera-zoom-2000.aep"));
-    assert_eq!(zoom.map(|z| (z.value, z.source)), Some((2000.0, ValueSource::Stored)));
-    assert_eq!((dof.map(|d| (d.value, d.source)), focus, aperture), (Some((false, ValueSource::Default)), None, None));
-    let (stored, auto) = pos.unwrap();
-    assert!(auto && near(stored[2], -2666.67, 0.01) && stored[0] == 0.0, "{stored:?}");
-    // 342: DOF on, Focus Distance 800, Aperture 30; Zoom stays the default.
-    let (zoom, dof, focus, aperture, _) = skip!(camera("342-camera-dof-800-30.aep"));
-    assert_eq!(zoom.map(|z| (z.source, near(z.value, 2666.67, 0.01))), Some((ValueSource::Default, true)));
-    assert_eq!(dof.map(|d| (d.value, d.source)), Some((true, ValueSource::Stored)));
-    assert_eq!(focus.map(|f| (f.value, f.source)), Some((800.0, ValueSource::Stored)));
-    assert_eq!(aperture.map(|f| (f.value, f.source)), Some((30.0, ValueSource::Stored)));
-    // The default camera (256) has nothing but the default zoom.
-    let (zoom, dof, ..) = skip!(camera("256-camera-two-node-default.aep"));
-    assert_eq!((zoom.unwrap().source, dof.unwrap().value), (ValueSource::Default, false));
-    assert_eq!(zoom.unwrap().value, effectcraft_aep::DEFAULT_CAMERA_ZOOM);
-}
-
-#[test]
-fn light_colour_cone_angle_and_feather() {
-    let light = |name: &str| {
-        Some({
-            let bytes = crate::common::try_fixture(name)?;
-            let file = open(&bytes);
-            let project = Project::new(&file).unwrap();
-            let layer = layer_of_type(&first_comp(&project), LayerType::Light);
-            assert_eq!(layer.header().unwrap().light_type(), Some(effectcraft_aep::LightType::Spot), "{name}");
-            let t = |x: Option<effectcraft_aep::Tracked<f64>>| x.map(|x| (x.value, x.source));
-            (layer.light_color().map(|c| (c.value, c.source)), t(layer.light_cone_angle()), t(layer.light_cone_feather()))
-        })
-    };
-    // The default spot light: white, 90, 50, all absent.
-    let (colour, angle, feather) = skip!(light("254-light-spot-intensity-50.aep"));
-    assert_eq!((colour, angle, feather), (Some(([1.0; 4], ValueSource::Default)), Some((90.0, ValueSource::Default)), Some((50.0, ValueSource::Default))));
-    // 343: colour [1,0,0,1] = ARGB doubles [255,255,0,0].
-    let (colour, angle, feather) = skip!(light("343-light-spot-color-red.aep"));
-    assert_eq!(colour, Some(([1.0, 1.0, 0.0, 0.0], ValueSource::Stored)));
-    assert_eq!((angle, feather), (Some((90.0, ValueSource::Default)), Some((50.0, ValueSource::Default))));
-    // 344: Cone Angle 60. 345: Cone Feather 30.
-    let (colour, angle, feather) = skip!(light("344-light-spot-coneangle-60.aep"));
-    assert_eq!((colour.unwrap().1, angle, feather), (ValueSource::Default, Some((60.0, ValueSource::Stored)), Some((50.0, ValueSource::Default))));
-    let (_, angle, feather) = skip!(light("345-light-spot-conefeather-30.aep"));
-    assert_eq!((angle, feather), (Some((90.0, ValueSource::Default)), Some((30.0, ValueSource::Stored))));
-    // A point light (252) stores Cone Angle 90 / Feather 50 in their default state.
-    let bytes = fixture!("252-light-point.aep");
+fn camera_zoom_keeps_the_auto_position() {
+    // 341: Zoom 2000 is stored (checked on import); the auto Position keeps [0, 0, -2666.67].
+    let bytes = fixture!("341-camera-zoom-2000.aep");
     let file = open(&bytes);
     let project = Project::new(&file).unwrap();
-    let layer = layer_of_type(&first_comp(&project), LayerType::Light);
-    assert_eq!(layer.light_cone_angle().map(|a| (a.value, a.source)), Some((90.0, ValueSource::Stored)));
-    // Layers without light options have no light accessors.
-    let bytes = fixture!("000-base.aep");
-    let file = open(&bytes);
-    let project = Project::new(&file).unwrap();
-    let solid = base_layer(&first_comp(&project));
-    assert!(solid.light_color().is_none() && solid.camera_zoom().is_none() && solid.camera_depth_of_field().is_none());
+    let layer = layer_of_type(&first_comp(&project), LayerType::Camera);
+    let pos = layer.camera_position().unwrap();
+    assert!(pos.auto_state && near(pos.stored[2], -2666.67, 0.01) && pos.stored[0] == 0.0, "{:?}", pos.stored);
 }
 
 // ------------------------------------------------------------------ marker data (347-349, 249)
@@ -503,7 +443,7 @@ fn audio_footage_item() {
     assert_eq!((f.width, f.height, f.is_solid), (0, 0, false));
     assert_eq!(f.duration, Some(rat(48000, 48000)));
     assert_eq!((f.audio_sample_rate, f.file_size, f.bits_per_pixel, f.native_frame_rate), (Some(48000.0), 96044, 0, 0));
-    assert!(!f.is_sequence && f.sequence_frame_count().is_none());
+    assert!(!f.is_sequence && item.sequence_info().is_none());
     // The combined file stores no display name for the item (the single-case file had
     // "test-tone.wav"); the path names the file.
     assert_eq!(item.label(), Some(7));
@@ -527,7 +467,7 @@ fn image_sequence_is_one_item() {
         assert_eq!(f.duration, Some(rat(3, 30)), "{name}");
         assert_eq!((f.native_frame_rate, f.bits_per_pixel, f.file_size, f.audio_sample_rate), (30, 24, 504, None), "{name}");
         assert!(f.is_sequence, "{name}");
-        assert_eq!(f.sequence_frame_count(), Some(3), "{name}");
+        assert_eq!(item.sequence_info().map(|s| s.frame_count()), Some(3), "{name}");
         // The first file name sits in opti; the alias points at the sequence folder.
         assert_eq!(f.name.as_deref(), Some("seq_001.png"), "{name}");
         assert!(f.path.as_deref().is_some_and(|p| p.ends_with("test-seq")), "{name}");
diff --git a/crates/aep/tests/it/container/cases_600.rs b/crates/aep/tests/it/container/cases_600.rs
index 53651e6e3..ad6248ecc 100644
--- a/crates/aep/tests/it/container/cases_600.rs
+++ b/crates/aep/tests/it/container/cases_600.rs
@@ -38,7 +38,7 @@ fn a_composition_counts_the_compositions_it_shows() {
     let id = |n: &str| items.iter().find(|i| i.display_name().as_deref() == Some(n)).and_then(|i| i.id()).expect(n);
     let c = items.iter().find(|i| i.display_name().as_deref() == Some("C")).expect("C");
     // The list holds each used composition once (in no particular order).
-    let mut used = c.used_item_ids();
+    let mut used = crate::common::used_item_ids(c);
     used.sort();
     let mut want = vec![id("P30"), id("Q")];
     want.sort();
@@ -60,8 +60,8 @@ fn an_image_sequence_knows_its_numbering() {
     let item = project.all_items().into_iter().find(|i| i.footage().is_some_and(|f| !f.is_solid)).expect("sequence");
     let f = item.footage().expect("footage");
     assert_eq!((f.file_type.as_str(), f.width, f.height, f.native_frame_rate, f.is_sequence), ("oEXR", 64, 48, 30, true));
-    assert_eq!(f.sequence_frame_count(), Some(3));
     let s = item.sequence_info().expect("numbering");
+    assert_eq!(s.frame_count(), 3);
     assert_eq!((s.prefix.as_str(), s.suffix.as_str(), s.start, s.end, s.digits), ("shot_", ".exr", 101, 103, 4));
     assert_eq!(s.file_name(101), "shot_0101.exr");
     // A still has no numbering (000: the solid; the base has no other footage).
diff --git a/crates/aep/tests/it/container/header.rs b/crates/aep/tests/it/container/header.rs
index bb07e96b3..2ebdbd59d 100644
--- a/crates/aep/tests/it/container/header.rs
+++ b/crates/aep/tests/it/container/header.rs
@@ -55,7 +55,6 @@ fn assert_plain(h: &LayerHeader) {
     assert_eq!(h.label, 1);
     // No name was set, so the copy of the name at byte 64 is empty (the layer shows its source name).
     assert_eq!(h.name_copy, "");
-    assert!(!h.name_is_user_set());
     assert!(!h.is_null_object());
     assert_eq!(h.parent_id, None);
     assert_eq!(h.source_id, Some(0x1a));
@@ -67,16 +66,13 @@ fn base_layer_header() {
     assert_plain(&h);
     assert_eq!(h.quality, Quality::Best);
     assert_eq!(h.blend_mode, BlendMode::Normal);
-    assert_eq!(h.stretch, 1);
-    assert_eq!(h.stretch_percent(), 100.0);
+    assert_eq!((h.stretch, h.stretch_den), (1, 1));
     assert_eq!(switches(&h), NONE);
     // start 0 s, in 0 s, out 5 s; denominator = the composition timescale.
     assert_eq!(h.start, Rational { num: 0, den: 25600 });
     assert_eq!(h.in_relative, Rational { num: 0, den: 25600 });
     assert_eq!(h.out_relative, Rational { num: 128_000, den: 25600 });
-    assert_eq!(h.start_seconds(), Some(0.0));
-    assert_eq!(h.in_point_seconds(), Some(0.0));
-    assert_eq!(h.out_point_seconds(), Some(5.0));
+    assert_eq!(h.in_point(), Rational::new(0, 1));
     assert_eq!(h.out_point(), Rational::new(5, 1));
 }
 
@@ -98,7 +94,7 @@ fn one_switch_per_case() {
         assert_eq!(switches(&h), expected, "{name}");
         assert_plain(&h);
         assert_eq!((h.quality, h.blend_mode, h.stretch), (Quality::Best, BlendMode::Normal, 1), "{name}");
-        assert_eq!(h.out_point_seconds(), Some(5.0), "{name}");
+        assert_eq!(h.out_point(), Rational::new(5, 1), "{name}");
     }
 }
 
@@ -106,7 +102,6 @@ fn one_switch_per_case() {
 fn name_blend_mode_and_quality() {
     let h = skip!(l_header("010-layer-name.aep"));
     assert_eq!(h.name_copy, "Renamed");
-    assert!(h.name_is_user_set());
     let bytes = fixture!("010-layer-name.aep");
     let file = open(&bytes);
     let project = Project::new(&file).unwrap();
@@ -114,7 +109,6 @@ fn name_blend_mode_and_quality() {
     // The layer name is the user's; the source footage keeps its own name.
     assert_eq!(layer.name().as_deref(), Some("Renamed"));
     assert_eq!(project.layer_source(&layer).and_then(|i| i.display_name()).as_deref(), Some("L"));
-    assert_eq!(project.layer_display_name(&layer).as_deref(), Some("Renamed"));
 
     assert_eq!(skip!(l_header("016-layer-blend-multiply.aep")).blend_mode, BlendMode::Multiply);
     assert_eq!(skip!(l_header("023-layer-quality-draft.aep")).quality, Quality::Draft);
@@ -127,7 +121,7 @@ fn display_name_falls_back_to_the_source_name() {
     let project = Project::new(&file).unwrap();
     let layer = base_layer(&first_comp(&project));
     assert_eq!(layer.name(), None);
-    assert_eq!(project.layer_display_name(&layer).as_deref(), Some("L"));
+    assert_eq!(project.layer_source(&layer).and_then(|i| i.display_name()).as_deref(), Some("L"));
     assert_eq!(project.layer_source_size(&layer), Some((1920, 1080)));
     let source = project.layer_source(&layer).unwrap();
     assert_eq!(source.id(), Some(0x1a));
@@ -139,26 +133,23 @@ fn time_stretch_and_the_in_out_start_convention() {
     // 018: stretch 100 -> 200: the stored out point stays 5 s, the layer ends at 10 s.
     let h = skip!(l_header("018-layer-stretch200.aep"));
     assert_eq!(h.stretch, 2);
-    assert_eq!(h.stretch_percent(), 200.0);
+    assert_eq!(h.stretch_ratio(), Rational::new(2, 1));
     assert_eq!(h.out_relative, Rational { num: 128_000, den: 25600 });
-    assert_eq!(h.out_point_seconds(), Some(10.0));
-    assert_eq!(h.in_point_seconds(), Some(0.0));
+    assert_eq!(h.out_point(), Rational::new(10, 1));
+    assert_eq!(h.in_point(), Rational::new(0, 1));
 
     // 019: inPoint 0 -> 1; AE moved the out point to 6 s and left the start at 0.
     let h = skip!(l_header("019-layer-inpoint1.aep"));
-    assert_eq!(h.start_seconds(), Some(0.0));
+    assert_eq!(h.start.num, 0);
     assert_eq!(h.in_relative, Rational { num: 25600, den: 25600 });
     assert_eq!(h.in_point(), Rational::new(1, 1));
-    assert_eq!(h.out_point_seconds(), Some(6.0));
+    assert_eq!(h.out_point(), Rational::new(6, 1));
 
     // 021: startTime 0 -> 0.5: in 0.5 s and out 5.5 s although the stored in point stays 0.
     let h = skip!(l_header("021-layer-starttime0.5.aep"));
     assert_eq!(h.start, Rational { num: 12800, den: 25600 });
-    assert_eq!(h.start_seconds(), Some(0.5));
     assert_eq!(h.in_relative.num, 0);
     assert_eq!(h.in_point(), Rational::new(1, 2));
-    assert_eq!(h.in_point_seconds(), Some(0.5));
-    assert_eq!(h.out_point_seconds(), Some(5.5));
     assert_eq!(h.out_point(), Rational::new(11, 2));
 }
 
@@ -175,7 +166,6 @@ fn parent_link_and_null_object() {
     let nh = null.header().unwrap();
     assert_eq!(null.name().as_deref(), Some("Null"));
     assert!(nh.is_null_object());
-    assert!(nh.name_is_user_set());
     assert_eq!(nh.layer_type, LayerType::Av);
     assert_eq!(nh.parent_id, None);
     assert_eq!(project.layer_source(null).and_then(|i| i.display_name()).as_deref(), Some("Null 1"));
@@ -225,17 +215,14 @@ fn base_comp_header() {
     assert_eq!((h.width, h.height), (1920, 1080));
     assert_eq!((h.time_base.frame_duration, h.time_base.timescale), (1024, 25600));
     assert_eq!(h.frame_rate(), Some(25.0));
-    assert_eq!(h.frame_rate_from_fixed(), 25.0);
+    assert_eq!(h.frame_rate_fixed, 25 << 16);
     assert_eq!(h.duration_units, 128_000);
     assert_eq!(h.duration_seconds(), Some(5.0));
     assert_eq!(h.background, [0, 0, 0]);
-    assert_eq!(h.background_rgb(), [0.0, 0.0, 0.0]);
     assert_eq!(h.shutter_angle, 180);
-    assert_eq!(h.work_area_start_seconds(), Some(0.0));
+    assert_eq!(h.work_area_start_units, 0);
     assert_eq!(h.work_area_end_units, None);
-    assert_eq!(h.work_area_end_seconds(), Some(5.0));
     assert_eq!(h.pixel_aspect, Rational { num: 1, den: 1 });
-    assert_eq!(h.pixel_aspect_ratio(), Some(1.0));
     assert!(!h.motion_blur);
     // The manifest calls the classic renderer `ADBE Advanced 3d`; the file stores `ADBE Escher`
     // and the display name `Classic 3D`.
@@ -255,7 +242,7 @@ fn one_comp_change_per_case() {
     let (h, _, _) = skip!(comp_header("031-comp-fps30.aep"));
     assert_eq!((h.time_base.frame_duration, h.time_base.timescale), (1024, 30720));
     assert_eq!(h.frame_rate(), Some(30.0));
-    assert_eq!(h.frame_rate_from_fixed(), 30.0);
+    assert_eq!(h.frame_rate_fixed, 30 << 16);
     assert_eq!(h.duration_units, 153_600);
     assert_eq!(h.duration_seconds(), Some(5.0));
 
@@ -263,12 +250,11 @@ fn one_comp_change_per_case() {
     let (h, _, _) = skip!(comp_header("032-comp-duration10.aep"));
     assert_eq!(h.duration_units, 256_000);
     assert_eq!(h.duration_seconds(), Some(10.0));
-    assert_eq!(h.work_area_end_seconds(), Some(10.0));
+    assert_eq!(h.work_area_end_units, None);
 
     // 033: bgColor [0,0,0] -> [0,1,0].
     let (h, _, _) = skip!(comp_header("033-comp-bg-green.aep"));
     assert_eq!(h.background, [0, 255, 0]);
-    assert_eq!(h.background_rgb(), [0.0, 1.0, 0.0]);
 
     // 034: shutterAngle 180 -> 90.
     let (h, _, _) = skip!(comp_header("034-comp-shutter90.aep"));
@@ -279,8 +265,6 @@ fn one_comp_change_per_case() {
     let (h, _, _) = skip!(comp_header("035-comp-workarea-1-2.aep"));
     assert_eq!(h.work_area_start_units, 25600);
     assert_eq!(h.work_area_end_units, Some(76_800));
-    assert_eq!(h.work_area_start_seconds(), Some(1.0));
-    assert_eq!(h.work_area_end_seconds(), Some(3.0));
 }
 
 #[test]
@@ -290,7 +274,6 @@ fn one_comp_change_per_case_aspect_blur_renderer() {
     // 037: pixelAspect 1 -> 2.
     let (h, _, _) = skip!(comp_header("037-comp-pixelaspect2.aep"));
     assert_eq!(h.pixel_aspect, Rational { num: 2, den: 1 });
-    assert_eq!(h.pixel_aspect_ratio(), Some(2.0));
 
     // 038: comp motion blur on.
     let (h, _, _) = skip!(comp_header("038-comp-motionblur.aep"));
@@ -328,17 +311,16 @@ fn precomp_item_ids_and_labels() {
     assert_eq!(h.source_id, pre_item.id());
     assert_eq!(project.layer_source(layer).unwrap().id(), pre_item.id());
     assert_eq!(h.label, 15);
-    assert!(!h.name_is_user_set());
     assert_eq!(layer.name(), None);
-    assert_eq!(project.layer_display_name(layer).as_deref(), Some("Pre"));
+    assert_eq!(project.layer_source(layer).and_then(|i| i.display_name()).as_deref(), Some("Pre"));
     assert_eq!(project.layer_source_size(layer), Some((1920, 1080)));
     // The precomp layer's start time has the denominator 1; the Pre comp is 1920x1080, 25 fps, 5 s.
     assert_eq!(h.start.den, 1);
     let ph = pre.header().unwrap();
     assert_eq!((ph.width, ph.height, ph.frame_rate(), ph.duration_seconds()), (1920, 1080, Some(25.0), Some(5.0)));
     // C records that it uses the comp Pre (chunk idpi, a little-endian u32).
-    assert_eq!(c_item.used_item_ids(), [pre_item.id().unwrap()]);
-    assert!(pre_item.used_item_ids().is_empty());
+    assert_eq!(crate::common::used_item_ids(c_item), [pre_item.id().unwrap()]);
+    assert!(crate::common::used_item_ids(pre_item).is_empty());
     assert_eq!(pre_item.label(), Some(15));
     // The layer inside Pre is a new layer made from the solid L (moving the layers into a precomp
     // creates new layers).
@@ -347,7 +329,7 @@ fn precomp_item_ids_and_labels() {
     let ih = inner[0].header().unwrap();
     assert_ne!(ih.id, L);
     assert_eq!(ih.source_id, Some(0x1a));
-    assert_eq!(project.layer_display_name(&inner[0]).as_deref(), Some("L"));
+    assert_eq!(project.layer_source(&inner[0]).and_then(|i| i.display_name()).as_deref(), Some("L"));
 }
 
 #[test]
@@ -356,9 +338,8 @@ fn a_negative_stretch_is_a_reversed_layer() {
     // point 0 and out point 5 s relative, so the layer runs from 5 s back to 0 s; 983: -50 % = -1/2.
     let h = skip!(l_header("981-layer-stretch-minus100-start5.aep"));
     assert_eq!((h.stretch, h.stretch_den), (-1, 1));
-    assert_eq!(h.stretch_percent(), -100.0);
-    assert_eq!((h.in_point_seconds(), h.out_point_seconds()), (Some(5.0), Some(0.0)));
+    assert_eq!((h.in_point(), h.out_point()), (Rational::new(5, 1), Rational::new(0, 1)));
     let h = skip!(l_header("983-layer-stretch-minus50-opacity-keys.aep"));
     assert_eq!((h.stretch, h.stretch_den), (-1, 2));
-    assert_eq!((h.in_point_seconds(), h.out_point_seconds()), (Some(5.0), Some(2.5)));
+    assert_eq!((h.in_point(), h.out_point()), (Rational::new(5, 1), Rational::new(5, 2)));
 }
diff --git a/crates/aep/tests/it/container/helpers.rs b/crates/aep/tests/it/container/helpers.rs
index d255692c0..5c01ebb8f 100644
--- a/crates/aep/tests/it/container/helpers.rs
+++ b/crates/aep/tests/it/container/helpers.rs
@@ -379,7 +379,8 @@ pub fn layer_named<'f, 'a>(comp: &Comp<'f, 'a>, name: &str) -> Layer<'f, 'a> {
 
 /// The layer that shows this name: its own name, or its source's while it has none.
 pub fn layer_shown_as<'f, 'a>(project: &Project<'f, 'a>, comp: &Comp<'f, 'a>, name: &str) -> Layer<'f, 'a> {
-    comp.layers().find(|l| project.layer_display_name(l).as_deref() == Some(name)).unwrap_or_else(|| panic!("no layer shown as {name}"))
+    let shown = |l: &Layer<'f, 'a>| l.name().or_else(|| project.layer_source(l)?.display_name());
+    comp.layers().find(|l| shown(l).as_deref() == Some(name)).unwrap_or_else(|| panic!("no layer shown as {name}"))
 }
 
 /// The first layer of this type in a composition.
diff --git a/crates/aep/tests/it/container/keyframes.rs b/crates/aep/tests/it/container/keyframes.rs
index 611c7027e..ac7b35ff7 100644
--- a/crates/aep/tests/it/container/keyframes.rs
+++ b/crates/aep/tests/it/container/keyframes.rs
@@ -19,6 +19,9 @@ fn prop_of<R>(name: &str, path: &[&str], f: impl FnOnce(Property<'_, '_>) -> R)
 const POSITION: &[&str] = &["ADBE Transform Group", "ADBE Position"];
 const OPACITY: &[&str] = &["ADBE Transform Group", "ADBE Opacity"];
 
+/// The ease of a linear key: all four slots 0.
+const NO_EASE: KeyEase = KeyEase { in_speed: 0.0, in_influence: 0.0, out_speed: 0.0, out_influence: 0.0 };
+
 fn ease(in_speed: f64, in_influence: f64, out_speed: f64, out_influence: f64) -> KeyEase {
     KeyEase { in_speed, in_influence, out_speed, out_influence }
 }
@@ -33,7 +36,7 @@ fn in_and_out_interpolation_are_separate_bytes() {
         assert_eq!((keys[0].interpolation_in(), keys[0].interpolation_out()), (Some(Interpolation::Linear), Some(Interpolation::Hold)));
         assert_eq!((keys[1].interpolation_in(), keys[1].interpolation_out()), (Some(Interpolation::Linear), Some(Interpolation::Linear)));
         assert_eq!(keys.iter().map(|k| k.seconds(25600).unwrap()).collect::<Vec<_>>(), [0.0, 1.0]);
-        assert_eq!(keys[1].spatial_value(), Some([100.0, 0.0, 0.0]));
+        assert_eq!(keys[1].value(), Some(vec![100.0, 0.0, 0.0]));
     }));
     // 203: key 1 inType HOLD, outType LINEAR (bytes 03 01): byte 4 is the incoming side.
     skip!(prop_of("203-key-in-hold-out-linear.aep", POSITION, |p| {
@@ -76,7 +79,7 @@ fn opacity_ease_speed_is_in_stored_units_per_second() {
         assert_near(&[e0.in_speed, e0.in_influence, e0.out_speed, e0.out_influence], &[0.05, 0.2, 0.2, 0.8], 1e-12);
         let e1 = keys[1].ease().unwrap();
         assert_near(&[e1.in_speed, e1.in_influence, e1.out_speed, e1.out_influence], &[0.3, 0.6, 0.09, 0.4], 1e-12);
-        assert_eq!(keys[0].plain_ease_slots().unwrap().len(), 4);
+        assert_eq!(keys[0].ease_components(), Some(vec![e0]));
         for k in &keys {
             assert_eq!((k.interpolation_in(), k.interpolation_out()), (Some(Interpolation::Bezier), Some(Interpolation::Bezier)));
         }
@@ -94,7 +97,7 @@ fn scale_keys_use_the_plain_template_with_three_components() {
             // A 128-byte record is not always spatial: the header's template flag decides.
             assert_eq!(k.kind(), KeyframeKind::Plain { components: 3 });
             assert_eq!(k.spatial(), None);
-            assert_eq!(k.plain_ease_slots(), Some(vec![0.0; 12]));
+            assert_eq!(k.ease_components(), Some(vec![NO_EASE; 3]));
             assert_eq!(k.ease(), None);
             assert_eq!((k.interpolation_in(), k.interpolation_out()), (Some(Interpolation::Linear), Some(Interpolation::Linear)));
         }
@@ -125,7 +128,7 @@ fn two_dimensional_mask_feather_keys() {
     assert!(keys.iter().all(|k| k.raw().len() == 88 && k.kind() == KeyframeKind::Plain { components: 2 }));
     assert_eq!(keys.iter().map(|k| k.value().unwrap()).collect::<Vec<_>>(), [vec![0.0, 0.0], vec![40.0, 20.0]]);
     assert_eq!(keys.iter().map(|k| k.seconds(25600).unwrap()).collect::<Vec<_>>(), [0.0, 1.0]);
-    assert_eq!(keys[0].plain_ease_slots(), Some(vec![0.0; 8]));
+    assert_eq!(keys[0].ease_components(), Some(vec![NO_EASE; 2]));
     let mask = &layer.masks()[0];
     assert!(mask.feather.source == ValueSource::Keyframed && mask.feather.value == [0.0, 0.0]);
 }
diff --git a/crates/aep/tests/it/container/layer_switches.rs b/crates/aep/tests/it/container/layer_switches.rs
index 292863a9e..1f8565752 100644
--- a/crates/aep/tests/it/container/layer_switches.rs
+++ b/crates/aep/tests/it/container/layer_switches.rs
@@ -2,7 +2,7 @@
 //! colours, checked against the values the corpus was made with (its MANIFEST, batch 2).
 
 use crate::container::helpers::{assert_near, base_layer, first_comp, layer_of_type, layer_shown_as, open};
-use effectcraft_aep::{BlendMode, CompHeader, LayerHeader, LayerType, LightType, Project, Rational, ValueSource};
+use effectcraft_aep::{BlendMode, CompHeader, LayerHeader, LayerType, LightType, Project};
 
 fn l_header(name: &str) -> Option<LayerHeader> {
     Some({
@@ -80,22 +80,24 @@ fn ntsc_frame_rates_are_exact_fractions() {
     // 229: frameRate 29.97 -> read back 29.9700012207031; the duration snaps from 5 s to 150 frames (5.005005 s).
     let h = skip!(comp_header("229-comp-fps-29.97.aep"));
     assert_eq!((h.time_base.frame_duration, h.time_base.timescale), (800, 23976));
-    assert_eq!(h.frame_rate_exact(), Some(Rational { num: 2997, den: 100 }));
     assert!((h.frame_rate().unwrap() - 29.97).abs() < 1e-12);
-    assert!((h.frame_rate_from_fixed() - 29.970_001_220_703_1).abs() < 1e-7);
-    assert_eq!((h.duration_units, h.duration_frames()), (120_000, Some(150)));
+    // The 16.16 rate holds the float32 29.97 (29.9700012207031).
+    assert_eq!(h.frame_rate_fixed, 1_964_114);
+    // 150 frames of 800 units.
+    assert_eq!(h.duration_units, 120_000);
     assert!((h.duration_seconds().unwrap() - 5.005_005_005_005_01).abs() < 1e-9);
     // 230: frameRate 23.976 -> read back 23.9759979248047; 120 frames.
     let h = skip!(comp_header("230-comp-fps-23.976.aep"));
     assert_eq!((h.time_base.frame_duration, h.time_base.timescale), (1000, 23976));
-    assert_eq!(h.frame_rate_exact(), Some(Rational { num: 2997, den: 125 }));
     assert!((h.frame_rate().unwrap() - 23.976).abs() < 1e-12);
-    assert!((h.frame_rate_from_fixed() - 23.975_997_924_804_7).abs() < 1e-7);
-    assert_eq!((h.duration_units, h.duration_frames()), (120_000, Some(120)));
+    // The 16.16 rate holds the float32 23.976 (23.9759979248047).
+    assert_eq!(h.frame_rate_fixed, 1_571_291);
+    // 120 frames of 1000 units.
+    assert_eq!(h.duration_units, 120_000);
     assert!((h.duration_seconds().unwrap() - 5.005_005_005_005_01).abs() < 1e-9);
     // 25 fps stays 25.
     let h = skip!(comp_header("000-base.aep"));
-    assert_eq!((h.frame_rate_exact(), h.duration_frames()), (Some(Rational { num: 25, den: 1 }), Some(125)));
+    assert_eq!((h.time_base.timescale, h.time_base.frame_duration, h.duration_units), (25600, 1024, 128_000));
 }
 
 #[test]
@@ -128,7 +130,6 @@ fn background_is_8_bits_per_channel() {
     // 231: bgColor [0.5, 0.5, 0.5] is stored as 128 and reads back as 128/255 = 0.50196.
     let h = skip!(comp_header("231-comp-bg-grey-0.5.aep"));
     assert_eq!(h.background, [128, 128, 128]);
-    assert_near(&h.background_rgb(), &[0.501_960_784_313_73; 3], 1e-12);
     // The frame rate stays 25 even though an earlier edit of the AE session left other numbers in the cache-like fields.
     assert_eq!((h.time_base.frame_duration, h.time_base.timescale), (1024, 25600));
 }
@@ -143,12 +144,10 @@ fn cameras_auto_orient_and_position() {
     let camera = layer_of_type(&comp, LayerType::Camera);
     let h = camera.header().unwrap();
     assert_eq!((h.flag_bytes[1], h.is_auto_oriented(), h.is_three_d(), h.source_id, h.light_type()), (0x44, true, true, None, None));
-    // The default Position is an "auto state" record that stores [0, 0, -2666.67]; the two-node camera reports the comp centre.
+    // The default Position is an "auto state" record that stores [0, 0, -2666.67].
     let pos = camera.camera_position().unwrap();
     assert!(pos.auto_state);
     assert_near(&pos.stored, &[0.0, 0.0, -2666.67], 0.01);
-    assert_near(&pos.reported(1920, 1080, true), &[960.0, 540.0, -2666.67], 0.01);
-    assert_eq!(camera.camera_point_of_interest(), Some([960.0, 540.0, 0.0]));
 
     let bytes = fixture!("251-camera-one-node.aep");
     let file = open(&bytes);
@@ -159,10 +158,9 @@ fn cameras_auto_orient_and_position() {
     // AE reports [0, 0, -2666.67] for the one-node camera: the stored value.
     let pos = camera.camera_position().unwrap();
     assert!(pos.auto_state);
-    assert_near(&pos.reported(1920, 1080, h.is_auto_oriented()), &[0.0, 0.0, -2666.67], 0.01);
-    assert_eq!(camera.camera_point_of_interest(), Some([960.0, 540.0, 0.0]));
+    assert_near(&pos.stored, &[0.0, 0.0, -2666.67], 0.01);
 
-    // 253: Position set to [100, 200, -1000]: stored as given, no auto state; the point of interest stays [960, 540, 0].
+    // 253: Position set to [100, 200, -1000]: stored as given, no auto state.
     let bytes = fixture!("253-camera-position-100-200-m1000.aep");
     let file = open(&bytes);
     let project = Project::new(&file).unwrap();
@@ -170,35 +168,27 @@ fn cameras_auto_orient_and_position() {
     let pos = camera.camera_position().unwrap();
     assert!(!pos.auto_state);
     assert_eq!(pos.stored, [100.0, 200.0, -1000.0]);
-    assert_eq!(pos.reported(1920, 1080, true), [100.0, 200.0, -1000.0]);
-    assert_eq!(camera.camera_point_of_interest(), Some([960.0, 540.0, 0.0]));
-    // A camera has no light intensity.
-    assert_eq!(camera.light_intensity(), None);
 }
 
 #[test]
-fn lights_type_and_intensity() {
-    // 254: a spot light, Intensity 100 -> 50 (stored as 50.0 percent, absent at the default 100).
+fn lights_type_and_position() {
+    // 254: a spot light (its Intensity 50 is checked on import).
     let bytes = fixture!("254-light-spot-intensity-50.aep");
     let file = open(&bytes);
     let project = Project::new(&file).unwrap();
     let light = layer_of_type(&first_comp(&project), LayerType::Light);
     let h = light.header().unwrap();
     assert_eq!((h.light_type(), h.light_type_code, h.source_id, h.is_auto_oriented(), h.is_three_d()), (Some(LightType::Spot), 1, None, true, true));
-    let intensity = light.light_intensity().unwrap();
-    assert_eq!((intensity.value, intensity.source), (50.0, ValueSource::Stored));
     assert!(light.camera_position().unwrap().auto_state);
     assert_near(&light.camera_position().unwrap().stored, &[0.0, 0.0, -1333.33], 0.01);
 
-    // 252: a point light (light type 2) at the default intensity, which is not stored.
+    // 252: a point light (light type 2).
     let bytes = fixture!("252-light-point.aep");
     let file = open(&bytes);
     let project = Project::new(&file).unwrap();
     let light = layer_of_type(&first_comp(&project), LayerType::Light);
     let h = light.header().unwrap();
     assert_eq!((h.light_type(), h.light_type_code), (Some(LightType::Point), 2));
-    let intensity = light.light_intensity().unwrap();
-    assert_eq!((intensity.value, intensity.source), (100.0, ValueSource::Default));
     // The solid under it is no light.
     let solid = base_layer(&first_comp(&project)).header().unwrap();
     assert_eq!((solid.light_type(), solid.light_type_code), (None, 0));
@@ -220,6 +210,6 @@ fn solid_colour_is_four_float32_argb() {
     // L is still red.
     let red = project.layer_source(&base_layer(&comp)).unwrap().footage().unwrap();
     assert_eq!(red.solid_rgb(), Some([1.0, 0.0, 0.0]));
-    // The new layer has no user-set name flag (it shows its source's name).
-    assert!(!blue.header().unwrap().name_is_user_set());
+    // The new layer has no name of its own (it shows its source's name).
+    assert_eq!(blue.name(), None);
 }
diff --git a/crates/aep/tests/it/container/matte.rs b/crates/aep/tests/it/container/matte.rs
index 65fe3e6b3..2502954fb 100644
--- a/crates/aep/tests/it/container/matte.rs
+++ b/crates/aep/tests/it/container/matte.rs
@@ -13,7 +13,7 @@ fn layers(name: &str) -> Option<Vec<(String, bool, Option<TrackMatte>, u32)>> {
         comp.layers()
             .map(|l| {
                 let h = l.header().expect("header");
-                (project.layer_display_name(&l).unwrap_or_default(), h.is_video_enabled(), l.track_matte(), h.id)
+                (l.name().or_else(|| project.layer_source(&l)?.display_name()).unwrap_or_default(), h.is_video_enabled(), l.track_matte(), h.id)
             })
             .collect()
     })
diff --git a/crates/aep/tests/it/container/robustness.rs b/crates/aep/tests/it/container/robustness.rs
index 5c3422a10..0a427bb88 100644
--- a/crates/aep/tests/it/container/robustness.rs
+++ b/crates/aep/tests/it/container/robustness.rs
@@ -154,16 +154,15 @@ use effectcraft_aep::{AepFile, Body, Chunk, Comp, Layer, Project, PropGroup, Pro
 
 /// Touches the property accessors; none may panic on a damaged property.
 fn exercise_property(p: &Property<'_, '_>) {
-    let _ = (p.header(), p.dims(), p.is_animated(), p.static_value(), p.time_scale(), p.flags(), p.is_static_flag_set());
-    let _ = (p.expression(), p.expression_flags().map(|f| (f.all_set(), f.disabled())), p.expression_enabled(), p.user_name(), p.first_key_value());
-    let _ = p.color_argb();
+    let _ = (p.header(), p.dims(), p.is_animated(), p.static_value(), p.time_scale(), p.flags());
+    let _ = (p.expression(), p.expression_flags().map(|f| f.disabled()), p.expression_enabled(), p.user_name(), p.first_key_value());
     if let Some(keys) = p.keys() {
         let scale = p.time_scale().unwrap_or(0);
         for k in keys.keyframes() {
-            let _ = (k.time_units(), k.spatial_value(), k.raw().len(), k.kind(), k.seconds(scale), k.seconds(0));
+            let _ = (k.time_units(), k.raw().len(), k.kind(), k.seconds(scale), k.seconds(0));
             let _ = (k.interpolation_in(), k.interpolation_out(), k.flags(), k.label(), k.is_roving());
-            let _ = (k.scalar_value(), k.ease(), k.spatial(), k.components(), k.value(), k.plain_ease_slots());
-            let _ = (k.ease_components(), k.color_distance());
+            let _ = (k.scalar_value(), k.ease(), k.spatial(), k.components(), k.value());
+            let _ = k.ease_components();
             for component in [0, 1, 2, 3, 7, 255, usize::MAX] {
                 let _ = k.ease_component(component);
             }
@@ -193,17 +192,14 @@ fn exercise_group(g: &PropGroup<'_, '_>, depth: usize) {
 fn exercise_layer(project: &Project<'_, '_>, comp_size: (u32, u32), layer: &Layer<'_, '_>) {
     let _ = (layer.name(), layer.is_three_d(), layer.id(), layer.track_matte());
     if let Some(h) = layer.header() {
-        let _ = (h.in_point(), h.out_point(), h.in_point_seconds(), h.out_point_seconds(), h.start_seconds(), h.stretch_percent());
-        let _ = (h.stretch_ratio(), h.stretch_den);
+        let _ = (h.in_point(), h.out_point(), h.stretch_ratio(), h.stretch_den);
         let _ = (h.is_shy(), h.is_locked(), h.is_solo(), h.is_three_d(), h.is_motion_blur(), h.is_adjustment(), h.is_guide());
-        let _ = (h.is_null_object(), h.collapses_transformations(), h.name_is_user_set(), h.quality, h.blend_mode, h.layer_type);
+        let _ = (h.is_null_object(), h.collapses_transformations(), h.quality, h.blend_mode, h.layer_type);
         let _ = (h.is_enabled(), h.is_video_enabled(), h.is_audio_enabled(), h.is_effects_enabled(), h.is_auto_oriented(), h.light_type(), h.blend_mode.code());
     }
     let _ = (layer.is_enabled(), layer.is_audio_enabled(), layer.is_effects_enabled());
-    let _ = (layer.camera_position().map(|p| p.reported(comp_size.0, comp_size.1, true)), layer.camera_point_of_interest(), layer.light_intensity());
+    let _ = layer.camera_position().map(|p| (p.stored, p.auto_state));
     let _ = project.layer_anchor_px(layer);
-    let _ = (layer.camera_zoom(), layer.camera_depth_of_field(), layer.camera_focus_distance(), layer.camera_aperture());
-    let _ = (layer.light_color(), layer.light_cone_angle(), layer.light_cone_feather());
     let _ = layer
         .time_remap()
         .map(|t| (t.enabled, t.keys.iter().fold(0.0, |acc, k| acc + k.value_seconds + k.time_seconds.unwrap_or(0.0) + f64::from(k.time_units))));
@@ -230,7 +226,7 @@ fn exercise_layer(project: &Project<'_, '_>, comp_size: (u32, u32), layer: &Laye
             }
         }
     }
-    let _ = (project.layer_source(layer).map(|i| i.id()), project.layer_display_name(layer), project.layer_source_size(layer));
+    let _ = (project.layer_source(layer).map(|i| i.id()), project.layer_source(layer).and_then(|i| i.display_name()), project.layer_source_size(layer));
     if let Some(t) = layer.transform(comp_size.0, comp_size.1) {
         let _ = (t.anchor_px(f64::from(comp_size.0), f64::from(comp_size.1)), t.position.value, t.opacity_percent.value);
     }
@@ -263,7 +259,6 @@ fn exercise_layer(project: &Project<'_, '_>, comp_size: (u32, u32), layer: &Laye
     }
     for m in layer.masks() {
         let _ = (m.name.clone(), m.mode, m.inverted, m.counter, m.feather, m.opacity_percent, m.expansion, m.path_animated, m.path_key_seconds.len());
-        let _ = project.mask_vertices_px(layer, &m).map(|shapes| shapes.iter().map(Vec::len).sum::<usize>());
         for s in &m.shapes {
             let _ = (s.vertex_count(), s.vertices((1920.0, 1080.0)).len(), s.vertices((f64::NAN, f64::INFINITY)).len(), s.open);
         }
@@ -291,10 +286,9 @@ fn exercise_comp(project: &Project<'_, '_>, comp: &Comp<'_, '_>) {
     let mut size = (1920, 1080);
     if let Some(h) = comp.header() {
         size = (u32::from(h.width), u32::from(h.height));
-        let _ = (h.frame_rate(), h.frame_rate_from_fixed(), h.duration_seconds(), h.work_area_start_seconds(), h.work_area_end_seconds());
-        let _ = (h.frame_rate_exact(), h.duration_frames());
-        let _ = (h.background_rgb(), h.pixel_aspect_ratio(), h.pixel_aspect.reduced(), h.shutter_angle, h.motion_blur);
-        let _ = (h.shutter_phase, h.display_start, h.display_start_seconds(), h.display_start_frame());
+        let _ = (h.frame_rate(), h.frame_rate_fixed, h.duration_seconds(), h.work_area_start_units, h.work_area_end_units);
+        let _ = (h.background, h.pixel_aspect.to_f64(), h.pixel_aspect.reduced(), h.shutter_angle, h.motion_blur);
+        let _ = (h.shutter_phase, h.display_start.map(|r| r.to_f64()));
     }
     for layer in comp.layers() {
         exercise_layer(project, size, &layer);
@@ -305,10 +299,8 @@ fn exercise_comp(project: &Project<'_, '_>, comp: &Comp<'_, '_>) {
 fn exercise(file: &AepFile<'_>) {
     let Some(project) = Project::new(file) else { return };
     for item in project.all_items() {
-        let _ = (item.kind(), item.name(), item.id(), item.label(), item.used_item_ids(), item.footage(), item.display_name());
-        let _ = item
-            .footage()
-            .map(|f| (f.duration, f.native_frame_rate, f.bits_per_pixel, f.file_size, f.audio_sample_rate, f.is_sequence, f.sequence_frame_count()));
+        let _ = (item.kind(), item.name(), item.id(), item.label(), item.footage(), item.display_name());
+        let _ = item.footage().map(|f| (f.duration, f.native_frame_rate, f.bits_per_pixel, f.file_size, f.audio_sample_rate, f.is_sequence));
         let _ = item.id().and_then(|id| project.item_by_id(id));
         if let Some(comp) = item.comp() {
             exercise_comp(&project, &comp);
@@ -561,12 +553,12 @@ fn extreme_values_in_the_decoded_headers() {
     use effectcraft_aep::{CompHeader, LayerHeader, Rational, ShapePath};
     // Every field at its maximum: no overflow, no division by zero, no panic.
     let h = LayerHeader::parse(&[0xff; 164]).unwrap();
-    let _ = (h.in_point(), h.out_point(), h.in_point_seconds(), h.out_point_seconds(), h.start_seconds(), h.stretch_percent());
+    let _ = (h.in_point(), h.out_point(), h.start.to_f64(), h.stretch_ratio());
     let mut zero_den = [0u8; 164];
     zero_den[8..12].copy_from_slice(&u32::MAX.to_be_bytes());
     zero_den[12..16].copy_from_slice(&i32::MIN.to_be_bytes());
     let h = LayerHeader::parse(&zero_den).unwrap();
-    assert_eq!((h.in_point(), h.out_point(), h.start_seconds()), (None, None, None));
+    assert_eq!((h.in_point(), h.out_point(), h.start.to_f64()), (None, None, None));
     let mut wide = [0u8; 164];
     wide[8..12].copy_from_slice(&u32::MAX.to_be_bytes());
     wide[12..16].copy_from_slice(&i32::MIN.to_be_bytes());
@@ -574,14 +566,12 @@ fn extreme_values_in_the_decoded_headers() {
     wide[20..24].copy_from_slice(&i32::MAX.to_be_bytes());
     wide[24..28].copy_from_slice(&u32::MAX.to_be_bytes());
     let h = LayerHeader::parse(&wide).unwrap();
-    let _ = (h.in_point(), h.in_point_seconds());
+    let _ = h.in_point();
     let c = CompHeader::parse(&[0xff; 204]).unwrap();
-    assert_eq!((c.duration_seconds(), c.work_area_start_seconds(), c.work_area_end_units), (None, None, None));
-    let _ = (c.frame_rate(), c.frame_rate_from_fixed(), c.background_rgb(), c.pixel_aspect_ratio(), c.frame_rate_exact());
-    assert_eq!(c.duration_frames(), Some(1));
+    assert_eq!((c.duration_seconds(), c.work_area_end_units), (None, None));
+    let _ = (c.frame_rate(), c.pixel_aspect.to_f64());
     let zero = CompHeader::parse(&[0; 204]).unwrap();
-    assert_eq!((zero.frame_rate(), zero.pixel_aspect_ratio(), zero.duration_seconds()), (None, None, None));
-    assert_eq!((zero.frame_rate_exact(), zero.duration_frames()), (None, None));
+    assert_eq!((zero.frame_rate(), zero.pixel_aspect.to_f64(), zero.duration_seconds()), (None, None, None));
     let all = LayerHeader::parse(&[0xff; 164]).unwrap();
     let _ = (all.is_enabled(), all.is_auto_oriented(), all.light_type(), all.blend_mode.code());
     assert_eq!(LayerHeader::parse(&[0u8; 164]).unwrap().light_type(), None);
@@ -680,7 +670,7 @@ fn hostile_text_dictionaries_and_marker_headers_never_panic() {
 
 #[test]
 fn extreme_values_in_the_batch_3_fields() {
-    use effectcraft_aep::{CompHeader, Footage, LayerHeader, Rational};
+    use effectcraft_aep::{CompHeader, LayerHeader};
     // Time stretch: zero and maximal numerators and denominators (bytes 8 and 108), with extreme times.
     for (num, den) in [(0u32, 0u32), (1, 0), (0, 1), (u32::MAX, 1), (1, u32::MAX), (u32::MAX, u32::MAX), (3, 2)] {
         let mut ldta = [0u8; 164];
@@ -693,7 +683,7 @@ fn extreme_values_in_the_batch_3_fields() {
         ldta[28..32].copy_from_slice(&i32::MIN.to_be_bytes());
         ldta[32..36].copy_from_slice(&1u32.to_be_bytes());
         let h = LayerHeader::parse(&ldta).unwrap();
-        let _ = (h.stretch_ratio(), h.stretch_percent(), h.in_point(), h.out_point(), h.in_point_seconds(), h.out_point_seconds());
+        let _ = (h.stretch_ratio(), h.in_point(), h.out_point());
         if den == 0 {
             assert_eq!((h.stretch_ratio(), h.in_point(), h.out_point()), (None, None, None));
         }
@@ -701,31 +691,8 @@ fn extreme_values_in_the_batch_3_fields() {
     // Display start and shutter phase from extreme bytes; a missing tail leaves them unknown.
     for fill in [0x00u8, 0x7f, 0x80, 0xff] {
         let c = CompHeader::parse(&[fill; 204]).unwrap();
-        let _ = (c.shutter_phase, c.display_start, c.display_start_seconds(), c.display_start_frame());
+        let _ = (c.shutter_phase, c.display_start.map(|r| r.to_f64()));
     }
-    let zero_rate = CompHeader::parse(&[0; 204]).unwrap();
-    assert_eq!((zero_rate.display_start_seconds(), zero_rate.display_start_frame()), (None, None));
-    // Footage durations: zero denominator, negative and maximal numerators, a huge frame rate.
-    let base = Footage {
-        file_type: String::new(),
-        width: 0,
-        height: 0,
-        name: None,
-        is_solid: false,
-        solid_argb: None,
-        path: None,
-        duration: None,
-        native_frame_rate: 0,
-        bits_per_pixel: 0,
-        file_size: 0,
-        audio_sample_rate: None,
-        is_sequence: true,
-    };
-    for (num, den, rate) in [(3i64, 30i64, 30u32), (3, 0, 30), (-3, 30, 30), (i64::MAX, 1, u32::MAX), (i64::MIN, -1, u32::MAX), (1, i64::MAX, 1), (0, 1, 0)] {
-        let f = Footage { duration: Some(Rational { num, den }), native_frame_rate: rate, ..base.clone() };
-        let _ = f.sequence_frame_count();
-    }
-    assert_eq!(Footage { duration: Some(Rational { num: 3, den: 30 }), native_frame_rate: 30, ..base.clone() }.sequence_frame_count(), Some(3));
-    assert_eq!(Footage { duration: Some(Rational { num: 3, den: 0 }), native_frame_rate: 30, ..base.clone() }.sequence_frame_count(), None);
-    assert_eq!(Footage { duration: None, ..base }.sequence_frame_count(), None);
+    // A zero denominator has no value.
+    assert_eq!(CompHeader::parse(&[0; 204]).unwrap().display_start.and_then(|r| r.to_f64()), None);
 }
diff --git a/crates/aep/tests/it/container/text_markers_footage.rs b/crates/aep/tests/it/container/text_markers_footage.rs
index 9517c0453..48f49297e 100644
--- a/crates/aep/tests/it/container/text_markers_footage.rs
+++ b/crates/aep/tests/it/container/text_markers_footage.rs
@@ -13,7 +13,6 @@ fn text_layer_document(name: &str) -> Option<TextDocument> {
         let layer = comp.layers().find(|l| l.name().as_deref() == Some("T")).expect("the text layer T");
         let h = layer.header().unwrap();
         assert_eq!(h.layer_type, LayerType::Text);
-        assert!(h.name_is_user_set());
         layer.text_document().expect("text document")
     })
 }
@@ -192,7 +191,6 @@ fn png_footage_layer() {
     // The path comes from the alias JSON (the fixture holds a neutral replacement of the original).
     assert!(f.path.as_deref().is_some_and(|p| p.ends_with("test8x8.png")), "{:?}", f.path);
     assert_eq!(project.layer_source_size(&layer), Some((8, 8)));
-    assert_eq!(project.layer_display_name(&layer).as_deref(), Some("png"));
     // L is still there below it.
     assert_eq!(comp.layers().count(), 2);
 }
diff --git a/crates/aep/tests/it/container/typed.rs b/crates/aep/tests/it/container/typed.rs
index 15d26992c..381f86796 100644
--- a/crates/aep/tests/it/container/typed.rs
+++ b/crates/aep/tests/it/container/typed.rs
@@ -186,7 +186,7 @@ fn position_keyframes() {
     assert_eq!(times, [0, 25_600, 64_000]);
     let seconds: Vec<f64> = times.iter().map(|t| tb.seconds(*t).unwrap()).collect();
     assert_eq!(seconds, [0.0, 1.0, 2.5]);
-    let values: Vec<[f64; 3]> = keys.keyframes().map(|k| k.spatial_value().unwrap()).collect();
+    let values: Vec<Vec<f64>> = keys.keyframes().map(|k| k.value().unwrap()).collect();
     assert_eq!(values, [[0.0, 0.0, 0.0], [100.0, 0.0, 0.0], [200.0, 100.0, 0.0]]);
 }
 
diff --git a/crates/aep/tests/it/container/values.rs b/crates/aep/tests/it/container/values.rs
index b9ceadd57..b7e91881d 100644
--- a/crates/aep/tests/it/container/values.rs
+++ b/crates/aep/tests/it/container/values.rs
@@ -119,7 +119,7 @@ fn linear_position_keys() {
         let values: Vec<_> = keys.iter().map(|k| k.spatial().unwrap().value).collect();
         assert_eq!(values, [[0.0, 0.0, 0.0], [100.0, 0.0, 0.0], [200.0, 100.0, 0.0]]);
         assert_eq!(p.first_key_value(), Some(vec![0.0, 0.0, 0.0]));
-        assert_eq!(p.is_static_flag_set(), Some(false));
+        assert!(p.is_animated());
     }));
     // The transform of the layer reports the animated Position as keyframed (value at the first key).
     let (t, _) = skip!(transform("055-key-position-3key-inserted-t2.5.aep"));
@@ -181,7 +181,7 @@ fn roving_and_label_flags() {
         assert_eq!(roving, [false, true, false]);
         assert_eq!(keys[1].time_units(), Some(26509));
         assert_eq!(keys[1].seconds(25600), Some(1.0355078125));
-        assert_eq!(keys[1].spatial_value(), Some([100.0, 0.0, 0.0]));
+        assert_eq!(keys[1].value(), Some(vec![100.0, 0.0, 0.0]));
         assert_eq!(keys[1].flags(), Some(0x0027));
         assert_eq!(keys[1].label(), Some(0));
     }));
@@ -193,7 +193,7 @@ fn roving_and_label_flags() {
         assert_eq!(keys[1].flags(), Some(0x0247));
         assert_eq!(keys[0].flags(), Some(0x0007));
         assert_eq!(keys[1].is_roving(), Some(false));
-        assert_eq!(keys[1].spatial_value(), Some([100.0, 0.0, 0.0]));
+        assert_eq!(keys[1].value(), Some(vec![100.0, 0.0, 0.0]));
     }));
 }
 
@@ -204,7 +204,6 @@ fn scalar_opacity_keys() {
         assert!(p.is_animated());
         assert_eq!(p.dims(), Some(1));
         assert_eq!(p.time_scale(), Some(25600));
-        assert_eq!(p.is_static_flag_set(), Some(false));
         let list = p.keys().unwrap();
         assert_eq!(list.header.record_size, 48);
         let keys: Vec<_> = list.keyframes().collect();
@@ -243,10 +242,8 @@ fn expression_text_and_flag_bytes() {
         assert_eq!(p.expression(), None);
         let flags = p.expression_flags().unwrap();
         assert_eq!((flags.byte_76, flags.byte_77, flags.byte_120), (0, 0, 0));
-        assert!(!flags.all_set());
         // A written static property: tdsb 1, byte 5 of tdb4 has bit 0 set (15 for Position).
         assert_eq!(p.flags(), Some(1));
-        assert_eq!(p.is_static_flag_set(), Some(true));
         assert_eq!(p.header().and_then(|h| h.get(5).copied()), Some(15));
     }));
 }
diff --git a/crates/aep/tests/it/export/built.rs b/crates/aep/tests/it/export/built.rs
index 14f9d8795..a3d4b7ea6 100644
--- a/crates/aep/tests/it/export/built.rs
+++ b/crates/aep/tests/it/export/built.rs
@@ -139,8 +139,7 @@ fn layer_header_fields() {
     assert!(h[2].is_motion_blur() && h[2].is_guide());
     assert_eq!(h[2].blend_mode, AepBlend::Screen);
     assert_eq!((h[2].start.num, h[2].start.den), (46_080, 30_720));
-    assert_eq!(h[2].in_point_seconds(), Some(2.0));
-    assert_eq!(h[2].out_point_seconds(), Some(6.0));
+    assert_eq!((h[2].in_point(), h[2].out_point()), (effectcraft_aep::Rational::new(2, 1), effectcraft_aep::Rational::new(6, 1)));
     assert_eq!(h[2].name_copy, "Mid");
     // Ids are unique.
     let mut ids: Vec<u32> = h.iter().map(|x| x.id).collect();
diff --git a/crates/aep/tests/it/export/masks.rs b/crates/aep/tests/it/export/masks.rs
index 544797802..7a7b18442 100644
--- a/crates/aep/tests/it/export/masks.rs
+++ b/crates/aep/tests/it/export/masks.rs
@@ -201,8 +201,9 @@ fn every_written_field_parses_back() {
     for m in [&masks[0], &masks[2], &masks[4]] {
         assert_eq!((m.feather.source, m.opacity_percent.source, m.expansion.source), (ValueSource::Default, ValueSource::Default, ValueSource::Default));
     }
-    // Paths: vertices in layer pixels, open bit.
-    let px = view.mask_vertices_px(&layer, &masks[2]).expect("vertices");
+    // Paths: vertices in layer pixels (the box scaled by the source size, as the importer does), open bit.
+    let (w, h) = view.layer_source_size(&layer).expect("size");
+    let px: Vec<_> = masks[2].shapes.iter().map(|s| s.vertices((f64::from(w), f64::from(h)))).collect();
     let open = open_path();
     assert!(masks[2].shapes[0].open && !masks[0].shapes[0].open);
     for (v, (want, (ti, to))) in px[0].iter().zip(open.vertices.iter().zip(open.in_tangents.iter().zip(&open.out_tangents))) {
diff --git a/crates/aep/tests/it/export/objects.rs b/crates/aep/tests/it/export/objects.rs
index d42f1c399..f9de6e836 100644
--- a/crates/aep/tests/it/export/objects.rs
+++ b/crates/aep/tests/it/export/objects.rs
@@ -190,6 +190,20 @@ fn with_props(p: &mut Project, c: effectcraft_project::ItemId, idx: usize, set:
     });
 }
 
+/// The layers of the first composition as the importer reads `bytes` back.
+fn reimported_layers(bytes: &[u8]) -> Vec<effectcraft_project::Layer> {
+    let exists = |_: &str| true;
+    let options = effectcraft_aep::import::ImportOptions { allow_losses: true, ..effectcraft_aep::import::ImportOptions::new(&exists) };
+    let mut p = Project::default();
+    let r = effectcraft_aep::import::import(&mut p, bytes, &options).expect("import");
+    p.comp(r.comps[0]).expect("comp").layers.iter().cloned().collect()
+}
+
+/// The value at `path` of a read-back layer.
+fn value(l: &effectcraft_project::Layer, path: &str) -> effectcraft_keyframe::Value {
+    l.props.prop(path).unwrap_or_else(|| panic!("no {path}")).value.clone()
+}
+
 fn first_comp_layers(bytes: &[u8], mut f: impl FnMut(&effectcraft_aep::Layer<'_, '_>)) {
     let file = parse(bytes).expect("parse");
     assert_eq!(effectcraft_aep::write(&file).expect("write"), bytes);
@@ -229,12 +243,18 @@ fn cameras_are_written_with_position_point_of_interest_and_options() {
         assert!(h.is_three_d() && h.is_auto_oriented(), "two-node camera");
         let pos = l.camera_position().expect("position");
         assert_eq!((pos.stored, pos.auto_state), ([100.0, 200.0, -1000.0], false));
-        assert_eq!(l.camera_point_of_interest(), Some([960.0, 540.0, 0.0]));
-        assert_eq!(l.camera_depth_of_field().map(|t| t.value), Some(true));
-        assert_eq!(l.camera_focus_distance().map(|t| t.value), Some(800.0));
-        assert_eq!(l.camera_aperture().map(|t| t.value), Some(30.0));
-        assert_eq!(l.camera_zoom().map(|t| t.value), Some(1500.0));
     });
+    // The importer reads the written options back.
+    let back = reimported_layers(&r.bytes);
+    for (path, want) in [
+        ("transform/poi", Value::Vec3([960.0, 540.0, 0.0])),
+        ("cameraOptions/dof", Value::Bool(true)),
+        ("cameraOptions/focusDistance", Value::Scalar(800.0)),
+        ("cameraOptions/aperture", Value::Scalar(30.0)),
+        ("cameraOptions/zoom", Value::Scalar(1500.0)),
+    ] {
+        assert_eq!(value(&back[0], path), want, "{path}");
+    }
     // One-node (auto-orient off): bit 0x40 clear (251).
     with_layer(&mut p, c, 0, |l| l.auto_orient = effectcraft_project::AutoOrient::Off);
     first_comp_layers(&export_all(&p).bytes, |l| assert!(!l.header().expect("h").is_auto_oriented()));
@@ -271,20 +291,25 @@ fn spot_and_point_lights_are_written_with_their_options() {
         seen.push(h.light_type());
         match h.light_type() {
             Some(effectcraft_aep::LightType::Spot) => {
-                assert_eq!(l.light_intensity().map(|t| t.value), Some(50.0));
-                assert_eq!(l.light_color().map(|t| t.value), Some([1.0, 1.0, 0.0, 0.0]));
-                assert_eq!(l.light_cone_angle().map(|t| t.value), Some(60.0));
-                assert_eq!(l.light_cone_feather().map(|t| t.value), Some(30.0));
                 assert_eq!(l.camera_position().map(|p| p.stored), Some([100.0, 50.0, -500.0]));
-                assert_eq!(l.camera_point_of_interest(), Some([960.0, 540.0, 0.0]));
-            }
-            Some(effectcraft_aep::LightType::Point) => {
-                assert_eq!(l.light_intensity().map(|t| t.value), Some(100.0));
             }
+            Some(effectcraft_aep::LightType::Point) => {}
             other => panic!("{other:?}"),
         }
     });
     assert_eq!(seen.len(), 2);
+    // The importer reads the written options back (layer 0 is the point light, 1 the spot).
+    let back = reimported_layers(&r.bytes);
+    assert_eq!(value(&back[0], "lightOptions/intensity"), Value::Scalar(100.0));
+    for (path, want) in [
+        ("lightOptions/intensity", Value::Scalar(50.0)),
+        ("lightOptions/color", Value::Color([1.0, 0.0, 0.0, 1.0])),
+        ("lightOptions/coneAngle", Value::Scalar(60.0)),
+        ("lightOptions/coneFeather", Value::Scalar(30.0)),
+        ("transform/poi", Value::Vec3([960.0, 540.0, 0.0])),
+    ] {
+        assert_eq!(value(&back[1], path), want, "{path}");
+    }
     // Parallel and ambient lights, and unsampled options, are reported.
     let mut q = Project::default();
     let c = add_comp(&mut q, "C", 640, 360, FrameRate::new(25, 1), 1.0, None);
diff --git a/crates/aep/tests/it/export/precomp.rs b/crates/aep/tests/it/export/precomp.rs
index e384bfd1b..a25493f77 100644
--- a/crates/aep/tests/it/export/precomp.rs
+++ b/crates/aep/tests/it/export/precomp.rs
@@ -47,10 +47,10 @@ fn a_precomposition_layer_points_at_its_composition() {
     let (c, pre) = (by_name("C"), by_name("Pre"));
     let pre_id = pre.id().expect("id");
     // C records the composition it uses (idpi, little-endian), idpc byte 0 is 1.
-    assert_eq!(c.used_item_ids(), vec![pre_id]);
+    assert_eq!(crate::common::used_item_ids(&c), vec![pre_id]);
     let idpc = c.chunk().child(b"idpc").and_then(|x| x.bytes()).expect("idpc");
     assert_eq!(idpc.first(), Some(&1));
-    assert_eq!(pre.used_item_ids(), Vec::<u32>::new());
+    assert_eq!(crate::common::used_item_ids(&pre), Vec::<u32>::new());
     assert_eq!(pre.chunk().child(b"idpc").and_then(|x| x.bytes()).and_then(|b| b.first().copied()), Some(0));
     let layer = c.comp().expect("comp").layers().next().expect("layer");
     let h = layer.header().expect("header");
@@ -107,7 +107,7 @@ fn one_composition_used_twice_is_recorded_once_and_chains_nest() {
     let view = effectcraft_aep::Project::new(&file).expect("project");
     let items = view.all_items();
     let id = |n: &str| items.iter().find(|i| i.display_name().as_deref() == Some(n)).and_then(|i| i.id()).expect(n);
-    let used = |n: &str| items.iter().find(|i| i.display_name().as_deref() == Some(n)).expect(n).used_item_ids();
+    let used = |n: &str| items.iter().find(|i| i.display_name().as_deref() == Some(n)).map(crate::common::used_item_ids).expect(n);
     assert_eq!(used("B"), vec![id("A")]);
     // Ascending ids (601; the order carries no meaning), and idpc counts them.
     let mut ab = vec![id("A"), id("B")];
diff --git a/crates/aep/tests/it/import/cameras.rs b/crates/aep/tests/it/import/cameras.rs
index 863f8bee1..3b4f3f30c 100644
--- a/crates/aep/tests/it/import/cameras.rs
+++ b/crates/aep/tests/it/import/cameras.rs
@@ -50,10 +50,14 @@ fn cameras() {
     close(&v(&c, "cameraOptions/focusDistance"), &[2666.6667]);
     close(&v(&c, "cameraOptions/aperture"), &[25.3093]);
     assert_eq!(v(&c, "cameraOptions/dof"), Value::Bool(false));
-    // 251: one-node camera.
-    assert_eq!(skip!(layer("251-camera-one-node.aep", "Camera 1")).auto_orient, AutoOrient::Off);
-    // 253: position set by the user.
-    close(&v(&skip!(layer("253-camera-position-100-200-m1000.aep", "Camera 1")), "transform/position"), &[100.0, 200.0, -1000.0]);
+    // 251: one-node camera; its point of interest is stored at the centre too.
+    let c = skip!(layer("251-camera-one-node.aep", "Camera 1"));
+    assert_eq!(c.auto_orient, AutoOrient::Off);
+    close(&v(&c, "transform/poi"), &[960.0, 540.0, 0.0]);
+    // 253: position set by the user; the point of interest stays at the centre.
+    let c = skip!(layer("253-camera-position-100-200-m1000.aep", "Camera 1"));
+    close(&v(&c, "transform/position"), &[100.0, 200.0, -1000.0]);
+    close(&v(&c, "transform/poi"), &[960.0, 540.0, 0.0]);
     // 341, 342: zoom, depth of field.
     close(&v(&skip!(layer("341-camera-zoom-2000.aep", "Camera 1")), "cameraOptions/zoom"), &[2000.0]);
     let c = skip!(layer("342-camera-dof-800-30.aep", "Camera 1"));
@@ -75,9 +79,17 @@ fn spot_and_point_lights() {
     close(&v(&l, "transform/poi"), &[960.0, 540.0, 0.0]);
     close(&v(&l, "transform/position"), &[0.0, 0.0, -1333.3333]);
     assert_eq!(l.auto_orient, AutoOrient::TowardsPointOfInterest);
+    // The options it does not store keep After Effects' defaults: white, 90, 50.
+    close(&v(&l, "lightOptions/color"), &[1.0, 1.0, 1.0, 1.0]);
+    close(&v(&l, "lightOptions/coneAngle"), &[90.0]);
+    close(&v(&l, "lightOptions/coneFeather"), &[50.0]);
     close(&v(&skip!(layer("343-light-spot-color-red.aep", "Light 1")), "lightOptions/color"), &[1.0, 0.0, 0.0, 1.0]);
-    close(&v(&skip!(layer("344-light-spot-coneangle-60.aep", "Light 1")), "lightOptions/coneAngle"), &[60.0]);
-    close(&v(&skip!(layer("345-light-spot-conefeather-30.aep", "Light 1")), "lightOptions/coneFeather"), &[30.0]);
+    let l = skip!(layer("344-light-spot-coneangle-60.aep", "Light 1"));
+    close(&v(&l, "lightOptions/coneAngle"), &[60.0]);
+    close(&v(&l, "lightOptions/coneFeather"), &[50.0]);
+    let l = skip!(layer("345-light-spot-conefeather-30.aep", "Light 1"));
+    close(&v(&l, "lightOptions/coneFeather"), &[30.0]);
+    close(&v(&l, "lightOptions/coneAngle"), &[90.0]);
     // 252: a point light stores its cone as default-state records, which hold nothing.
     let l = skip!(layer("252-light-point.aep", "Light 1"));
     assert!(matches!(l.source, LayerSource::Light { kind: LightKind::Point }));
diff --git a/crates/aep/tests/it/import/versions.rs b/crates/aep/tests/it/import/versions.rs
index cac6a9a6b..77c39ea02 100644
--- a/crates/aep/tests/it/import/versions.rs
+++ b/crates/aep/tests/it/import/versions.rs
@@ -169,13 +169,12 @@ fn copies_saved_as_25x_and_24x_import_like_the_2026_file() {
 #[ignore = "needs the version fixtures of the corpus (<family>-26/-25x/-24x.aep)"]
 fn the_container_of_a_copy_states_its_version_in_head_and_the_writer_in_svap() {
     for family in FAMILIES {
-        for (suffix, version, revision) in [("26", "26.2.1x2", 97), ("25x", "25.6.0x97", 96), ("24x", "24.6.0x65", 95)] {
+        for (suffix, version) in [("26", "26.2.1x2"), ("25x", "25.6.0x97"), ("24x", "24.6.0x65")] {
             let name = format!("{family}-{suffix}.aep");
             let Some(bytes) = crate::common::try_file(&name) else { continue };
             let file = parse(&bytes).unwrap();
             assert_eq!(file.file_version().map(|v| v.text()).as_deref(), Some(version), "{name}");
             assert_eq!(file.saved_by_version().map(|v| v.text()).as_deref(), Some("26.2.1x2"), "{name}");
-            assert_eq!(file.head_revision(), Some(revision), "{name}");
         }
     }
 }

From 66cbb9d89e840fd1d055c79942bb479d881098d2 Mon Sep 17 00:00:00 2001
From: vangel76 <vangel1976@googlemail.com>
Date: Sun, 8 Nov 2026 04:34:39 +0100
Subject: [PATCH 14/30] aep: review fixes for #3281: NTSC table beside
 TimeBase, real-path NTSC round trip, light and camera defaults on import, doc
 wording

---
 crates/aep/examples/aepcheck3281.rs           | 105 ++++++++++++++++++
 crates/aep/src/container/typed.rs             |   9 ++
 crates/aep/src/export/timebase.rs             |   5 -
 crates/aep/src/import/time.rs                 |   5 -
 .../aep/tests/it/container/batch3_objects.rs  |   3 +-
 crates/aep/tests/it/export/built.rs           |  17 +++
 crates/aep/tests/it/import/cameras.rs         |  12 +-
 docs/aep-format.md                            |   2 +-
 8 files changed, 144 insertions(+), 14 deletions(-)
 create mode 100644 crates/aep/examples/aepcheck3281.rs

diff --git a/crates/aep/examples/aepcheck3281.rs b/crates/aep/examples/aepcheck3281.rs
new file mode 100644
index 000000000..0ed70c5eb
--- /dev/null
+++ b/crates/aep/examples/aepcheck3281.rs
@@ -0,0 +1,105 @@
+//! Local check tool for #3281 (never committed).
+//! aepcheck3281 dump <dir>            -> per fixture: hashes of the imported project, import report, export bytes, export report
+//! aepcheck3281 bench <file> <reps>   -> median import / export time in microseconds
+//! aepcheck3281 scale <in.aep> <n> <out.aep>
+#![allow(clippy::unwrap_used, clippy::expect_used, clippy::panic)]
+use std::hint::black_box;
+use std::time::Instant;
+
+use effectcraft_aep::{Body, Chunk};
+
+fn fnv(bytes: &[u8]) -> u64 {
+    let mut h: u64 = 0xcbf2_9ce4_8422_2325;
+    for b in bytes {
+        h ^= u64::from(*b);
+        h = h.wrapping_mul(0x0100_0000_01b3);
+    }
+    h
+}
+
+fn dump(dir: &str) {
+    let mut names: Vec<_> = std::fs::read_dir(dir).unwrap().filter_map(|e| e.ok()).map(|e| e.path()).collect();
+    names.sort();
+    let exists = |_: &str| true;
+    let opts = effectcraft_aep::import::ImportOptions { allow_losses: true, ..effectcraft_aep::import::ImportOptions::new(&exists) };
+    for path in names {
+        let ext = path.extension().and_then(|e| e.to_str()).unwrap_or("");
+        if ext != "aep" && ext != "aepx" {
+            continue;
+        }
+        let bytes = std::fs::read(&path).unwrap();
+        let name = path.file_name().unwrap().to_string_lossy().to_string();
+        let mut p = effectcraft_project::Project::default();
+        match effectcraft_aep::import::import(&mut p, &bytes, &opts) {
+            Ok(r) => {
+                let pj = serde_json::to_vec(&p).unwrap();
+                let rj = serde_json::to_vec(&r.report).unwrap();
+                let summary = (r.report.total_losses(), r.report.is_lossless(), r.report.summary());
+                let eo = effectcraft_aep::export::ExportOptions { allow_losses: true };
+                let (eb, er, es) = match effectcraft_aep::export::export(&p, &eo) {
+                    Ok(x) => (
+                        fnv(&x.bytes),
+                        fnv(&serde_json::to_vec(&x.report).unwrap()),
+                        format!("{:?}", (x.report.total_losses(), x.report.is_lossless(), x.report.summary())),
+                    ),
+                    Err(e) => (0, 0, format!("ERR {e}")),
+                };
+                println!("{name} project={:016x} report={:016x} export={eb:016x} export_report={er:016x} isum={summary:?} esum={es}", fnv(&pj), fnv(&rj));
+            }
+            Err(e) => println!("{name} IMPORT ERR {e}"),
+        }
+    }
+}
+
+fn time<T>(reps: usize, mut f: impl FnMut() -> T) -> f64 {
+    let mut v = Vec::with_capacity(reps);
+    for _ in 0..reps {
+        let t = Instant::now();
+        black_box(f());
+        v.push(t.elapsed().as_secs_f64() * 1e6);
+    }
+    v.sort_by(f64::total_cmp);
+    v[v.len() / 2]
+}
+
+fn bench(path: &str, reps: usize) {
+    let bytes = std::fs::read(path).unwrap();
+    let exists = |_: &str| true;
+    let opts = effectcraft_aep::import::ImportOptions { allow_losses: true, ..effectcraft_aep::import::ImportOptions::new(&exists) };
+    let m = time(reps, || {
+        let mut p = effectcraft_project::Project::default();
+        effectcraft_aep::import::import(&mut p, &bytes, &opts).map(|r| r.items.len()).ok()
+    });
+    println!("import {m:.1} us");
+    let mut proj = effectcraft_project::Project::default();
+    effectcraft_aep::import::import(&mut proj, &bytes, &opts).unwrap();
+    let eo = effectcraft_aep::export::ExportOptions { allow_losses: true };
+    let m = time(reps, || effectcraft_aep::export::export(&proj, &eo).map(|r| r.bytes.len()).ok());
+    println!("export {m:.1} us");
+}
+
+fn scale(input: &str, n: usize, out: &str) {
+    let bytes = std::fs::read(input).unwrap();
+    let mut file = effectcraft_aep::parse(&bytes).unwrap();
+    for c in &mut file.chunks {
+        if c.is_list(b"Fold")
+            && let Body::List { children, .. } = &mut c.body
+        {
+            let items: Vec<Chunk<'_>> = children.iter().filter(|c| c.is_list(b"Item")).cloned().collect();
+            for _ in 1..n {
+                children.extend(items.iter().cloned());
+            }
+        }
+    }
+    std::fs::write(out, effectcraft_aep::write(&file).unwrap()).unwrap();
+}
+
+fn main() {
+    let a: Vec<String> = std::env::args().collect();
+    match a.get(1).map(String::as_str) {
+        Some("dump") => dump(&a[2]),
+        Some("bench") => bench(&a[2], a.get(3).and_then(|s| s.parse().ok()).unwrap_or(20)),
+        Some("scale") => scale(&a[2], a[3].parse().unwrap(), &a[4]),
+        _ => eprintln!("usage: see the top of this file"),
+    }
+}
diff --git a/crates/aep/src/container/typed.rs b/crates/aep/src/container/typed.rs
index a61c69090..09567fd84 100644
--- a/crates/aep/src/container/typed.rs
+++ b/crates/aep/src/container/typed.rs
@@ -135,6 +135,15 @@ pub struct TimeBase {
 }
 
 impl TimeBase {
+    /// The NTSC rates and the value After Effects stores for each (a float32 of exactly these
+    /// decimals): the one table the importer and the exporter use.
+    pub(crate) const NTSC: [(effectcraft_time::FrameRate, f32); 4] = [
+        (effectcraft_time::FrameRate::FPS_23_976, 23.976),
+        (effectcraft_time::FrameRate::FPS_29_97, 29.97),
+        (effectcraft_time::FrameRate::FPS_59_94, 59.94),
+        (effectcraft_time::FrameRate::FPS_119_88, 119.88),
+    ];
+
     /// Frames per second (`timescale / frame_duration`), `None` for a zero duration.
     pub fn frame_rate(&self) -> Option<f64> {
         (self.frame_duration != 0).then(|| f64::from(self.timescale) / f64::from(self.frame_duration))
diff --git a/crates/aep/src/export/timebase.rs b/crates/aep/src/export/timebase.rs
index 05c464e94..af9d22926 100644
--- a/crates/aep/src/export/timebase.rs
+++ b/crates/aep/src/export/timebase.rs
@@ -60,11 +60,6 @@ pub(crate) fn time_base(rate: FrameRate) -> Option<TimeBase> {
 }
 
 impl TimeBase {
-    /// The NTSC rates and the typed value After Effects stores for each: the one table the
-    /// importer and the exporter use.
-    pub(crate) const NTSC: [(FrameRate, f32); 4] =
-        [(FrameRate::FPS_23_976, 23.976), (FrameRate::FPS_29_97, 29.97), (FrameRate::FPS_59_94, 59.94), (FrameRate::FPS_119_88, 119.88)];
-
     /// `tick` in time units, rounded to the nearest unit (saturated to `i64`); the second value
     /// tells whether it was not exact.
     pub(crate) fn units(&self, tick: Tick) -> (i64, bool) {
diff --git a/crates/aep/src/import/time.rs b/crates/aep/src/import/time.rs
index ed734fc57..0f4f67097 100644
--- a/crates/aep/src/import/time.rs
+++ b/crates/aep/src/import/time.rs
@@ -81,11 +81,6 @@ mod tests {
         assert_eq!(frame_rate(30720, 1024), Some(FrameRate::new(30, 1)));
         assert_eq!(frame_rate(0, 1), None);
         assert_eq!(frame_rate(1, 0), None);
-        // The time bases the exporter writes for the NTSC rates read back as those rates.
-        let written = [(23976, 1000), (23976, 800), (23976, 400), (23976, 200)];
-        for ((rate, _), (ts, fd)) in TimeBase::NTSC.into_iter().zip(written) {
-            assert_eq!(frame_rate(ts, fd), Some(rate));
-        }
     }
 
     #[test]
diff --git a/crates/aep/tests/it/container/batch3_objects.rs b/crates/aep/tests/it/container/batch3_objects.rs
index d4b4f83ba..ca24d385d 100644
--- a/crates/aep/tests/it/container/batch3_objects.rs
+++ b/crates/aep/tests/it/container/batch3_objects.rs
@@ -148,7 +148,8 @@ fn a_mask_box_is_normalised_to_the_layer_size() {
     for (got, want) in m.shapes[0].bbox.iter().zip(want_box) {
         assert!(near(f64::from(*got), want, 1e-6), "{:?}", m.shapes[0].bbox);
     }
-    // The importer scales the box by the layer's source size.
+    // The box scales by the size of the layer's source (the importer takes that size from the
+    // source item it matched, the same item `layer_source_size` reads).
     let (w, h) = project.layer_source_size(&layer).unwrap();
     assert_eq!(m.shapes.len(), 1);
     let got: Vec<[f64; 2]> = m.shapes[0].vertices((f64::from(w), f64::from(h))).iter().map(|v| v.position).collect();
diff --git a/crates/aep/tests/it/export/built.rs b/crates/aep/tests/it/export/built.rs
index a3d4b7ea6..dc4c8dc3c 100644
--- a/crates/aep/tests/it/export/built.rs
+++ b/crates/aep/tests/it/export/built.rs
@@ -83,6 +83,23 @@ fn ntsc_and_odd_frame_rates_use_the_time_bases_after_effects_writes() {
     }
 }
 
+#[test]
+fn every_ntsc_rate_reads_back_as_the_rate_it_was_written_for() {
+    // The export's time base for each NTSC rate and the import's rate for that time base use the
+    // one NTSC table; the real paths must agree both ways.
+    for rate in [FrameRate::FPS_23_976, FrameRate::FPS_29_97, FrameRate::FPS_59_94, FrameRate::FPS_119_88] {
+        let mut p = Project::default();
+        add_comp(&mut p, "R", 640, 360, rate, 2.0, None);
+        let r = export_all(&p);
+        let exists = |_: &str| true;
+        let options = effectcraft_aep::import::ImportOptions { allow_losses: true, ..effectcraft_aep::import::ImportOptions::new(&exists) };
+        let mut back = Project::default();
+        let imported = effectcraft_aep::import::import(&mut back, &r.bytes, &options).expect("import");
+        let comp = imported.comps.first().and_then(|c| back.comp(*c)).expect("comp");
+        assert_eq!(comp.frame_rate, rate, "{}", rate.label());
+    }
+}
+
 #[test]
 fn layer_header_fields() {
     let mut p = Project::default();
diff --git a/crates/aep/tests/it/import/cameras.rs b/crates/aep/tests/it/import/cameras.rs
index 3b4f3f30c..cdc4326a4 100644
--- a/crates/aep/tests/it/import/cameras.rs
+++ b/crates/aep/tests/it/import/cameras.rs
@@ -46,7 +46,7 @@ fn cameras() {
     assert_eq!(c.auto_orient, AutoOrient::TowardsPointOfInterest);
     close(&v(&c, "transform/poi"), &[960.0, 540.0, 0.0]);
     close(&v(&c, "transform/position"), &[0.0, 0.0, -2666.6667]);
-    close(&v(&c, "cameraOptions/zoom"), &[2666.6667]);
+    close(&v(&c, "cameraOptions/zoom"), &[effectcraft_aep::DEFAULT_CAMERA_ZOOM]);
     close(&v(&c, "cameraOptions/focusDistance"), &[2666.6667]);
     close(&v(&c, "cameraOptions/aperture"), &[25.3093]);
     assert_eq!(v(&c, "cameraOptions/dof"), Value::Bool(false));
@@ -62,6 +62,8 @@ fn cameras() {
     close(&v(&skip!(layer("341-camera-zoom-2000.aep", "Camera 1")), "cameraOptions/zoom"), &[2000.0]);
     let c = skip!(layer("342-camera-dof-800-30.aep", "Camera 1"));
     assert_eq!(v(&c, "cameraOptions/dof"), Value::Bool(true));
+    // The zoom it does not store stays the default.
+    close(&v(&c, "cameraOptions/zoom"), &[2666.6667]);
     close(&v(&c, "cameraOptions/focusDistance"), &[800.0]);
     close(&v(&c, "cameraOptions/aperture"), &[30.0]);
     // 535-537: a camera above the 3D solid of 486.
@@ -83,10 +85,14 @@ fn spot_and_point_lights() {
     close(&v(&l, "lightOptions/color"), &[1.0, 1.0, 1.0, 1.0]);
     close(&v(&l, "lightOptions/coneAngle"), &[90.0]);
     close(&v(&l, "lightOptions/coneFeather"), &[50.0]);
-    close(&v(&skip!(layer("343-light-spot-color-red.aep", "Light 1")), "lightOptions/color"), &[1.0, 0.0, 0.0, 1.0]);
+    let l = skip!(layer("343-light-spot-color-red.aep", "Light 1"));
+    close(&v(&l, "lightOptions/color"), &[1.0, 0.0, 0.0, 1.0]);
+    close(&v(&l, "lightOptions/coneAngle"), &[90.0]);
+    close(&v(&l, "lightOptions/coneFeather"), &[50.0]);
     let l = skip!(layer("344-light-spot-coneangle-60.aep", "Light 1"));
     close(&v(&l, "lightOptions/coneAngle"), &[60.0]);
     close(&v(&l, "lightOptions/coneFeather"), &[50.0]);
+    close(&v(&l, "lightOptions/color"), &[1.0, 1.0, 1.0, 1.0]);
     let l = skip!(layer("345-light-spot-conefeather-30.aep", "Light 1"));
     close(&v(&l, "lightOptions/coneFeather"), &[30.0]);
     close(&v(&l, "lightOptions/coneAngle"), &[90.0]);
@@ -94,6 +100,8 @@ fn spot_and_point_lights() {
     let l = skip!(layer("252-light-point.aep", "Light 1"));
     assert!(matches!(l.source, LayerSource::Light { kind: LightKind::Point }));
     close(&v(&l, "lightOptions/intensity"), &[100.0]);
+    // Its stored Cone Angle 90 (a default-state record) has no counterpart: a point light has no cone.
+    assert!(l.props.prop("lightOptions/coneAngle").is_none());
     assert_eq!(l.auto_orient, AutoOrient::Off);
 }
 
diff --git a/docs/aep-format.md b/docs/aep-format.md
index d6eff25f8..a0eb9de6a 100644
--- a/docs/aep-format.md
+++ b/docs/aep-format.md
@@ -138,7 +138,7 @@ write on their own.
 | `svap` (4 bytes, the first top-level chunk) is the version of the After Effects that **wrote** the file: `0f 11 0e 02` in all 36 (a down-saved copy keeps the 2026 word) and in all 1 192 other `.aep` files of the local corpus folders. After Effects opens a file without `svap` (`t-nosvap`). | All 36; corpus scan. |
 | `head` bytes 4 to 7 are the version the file is **written for**: `0f 11 0e 02` (= `svap`) in the 2026 saves, `0f 0b 06 61` in the 25.x copies, `0f 03 06 41` in the 24.x copies, the same word in every family. After Effects refuses a file whose word is zero ("created with an older version [0.0x0]", `u-zhead`). | All 36; `u-zhead`. |
 | The word is packed (bit 31 first): bits 25-24 and 21-19 the major, 18-15 the minor, 14-11 the bug-fix, 10-8 a stage (6 in all), 7-0 the build; bits 31-26 (`000011`) and 23-22 (`00`) are the same in all samples and not decoded. `0f110e02` = **26.2.1x2**, which is what the saving After Effects reports for itself (`app.version` recorded by the corpus scripts) - this one sample fixes minor, bug-fix and build. The copies read as **25.6.0x97** and **24.6.0x65** (major **V** from three consecutive majors; minor, bug-fix and build of the copies **E**: one other word decides their positions). `effectcraft_aep::AeVersion`, `AepFile::file_version`, `AepFile::saved_by_version`. | Tests `decodes_the_sampled_words`, `the_container_of_a_copy_states_its_version_in_head_and_the_writer_in_svap`. |
-| `head` bytes 0 to 1 (a `u16`) step with the major: 97 (`0x61`) in the 2026 saves, 96 in 25.x, 95 in 24.x; bytes 2 to 3 are 5, 9 and 6 (**?**). Bytes 8 to 15 differ between families, not between versions; bytes 16 to 19 are the save counter (one higher in each copy). Nothing is derived from bytes 0 to 3 (`AepFile::head_revision` exposes the `u16`). | All 36. |
+| `head` bytes 0 to 1 (a `u16`) step with the major: 97 (`0x61`) in the 2026 saves, 96 in 25.x, 95 in 24.x; bytes 2 to 3 are 5, 9 and 6 (**?**). Bytes 8 to 15 differ between families, not between versions; bytes 16 to 19 are the save counter (one higher in each copy). Nothing is derived from bytes 0 to 3, and the reader does not expose them. | All 36. |
 | The XMP packet after the container is no guide: its `CreatorTool` is "Adobe After Effects 2026" in the copies too. | All 36. |
 | **26 against 25.x** (per family, chunk tree aligned by item and layer id): besides `head`, `nhed` / `nnhd` differ in 6 bytes (`nhed` 20-23 and 26-27: `827fa930` / `0015` in the 2026 save, `00000000` / `011b` in both copies; session state, see section 4). Every **solid's** `Pin /CLRS` changes: the 2026 save has `dcui` (1 byte, 1), `apid` all `0xff` and an empty `Utf8`; the copies drop `dcui`, set `apid` to a GUID (`601e9973...`, the same in all) and embed a 935-byte JSON with an ICC profile (`baseColorProfile/colorProfileData`). A **footage** item that the 2026 save stores with an assigned profile (`mcsp` = 1 and a profile JSON) loses `mcsp` and that JSON in the copies, and its `epid` becomes all `0xff`. The rest is save noise: the footage alias `ascendcount_base` (the copies were saved in another folder), `sspc` byte 112 of a footage item (a modification time), the `oEXR` `opti` of an EXR item (the copies hold the display device name `\.\DISPLAY1` as UTF-16 at byte 126 and, in the 24.x copy, a few non-zero bytes from byte 2 102 that look like uninitialised memory; the 2026 save has zeros), the plug-ins' sequence data `sdat` of Lumetri Color (16 instances and the project's `EfdG`), the mask counter `mkif` byte 8. No chunk is added or reordered, and no `pard`, `cdat`, `ldta`, `cdta`, `tdb4`, keyframe, text or shape chunk differs. | All 12 families. |
 | **25.x against 24.x**: only `head` (bytes 1, 3, 5 and 7), and the session noise in `opti` and `sdat` above. | All 12 families. |

From f5ec122466808c831eeec9c66100fad211986fe2 Mon Sep 17 00:00:00 2001
From: vangel76 <vangel1976@googlemail.com>
Date: Sun, 8 Nov 2026 04:34:49 +0100
Subject: [PATCH 15/30] aep: drop a local check tool committed by mistake
 (#3281)

---
 crates/aep/examples/aepcheck3281.rs | 105 ----------------------------
 1 file changed, 105 deletions(-)
 delete mode 100644 crates/aep/examples/aepcheck3281.rs

diff --git a/crates/aep/examples/aepcheck3281.rs b/crates/aep/examples/aepcheck3281.rs
deleted file mode 100644
index 0ed70c5eb..000000000
--- a/crates/aep/examples/aepcheck3281.rs
+++ /dev/null
@@ -1,105 +0,0 @@
-//! Local check tool for #3281 (never committed).
-//! aepcheck3281 dump <dir>            -> per fixture: hashes of the imported project, import report, export bytes, export report
-//! aepcheck3281 bench <file> <reps>   -> median import / export time in microseconds
-//! aepcheck3281 scale <in.aep> <n> <out.aep>
-#![allow(clippy::unwrap_used, clippy::expect_used, clippy::panic)]
-use std::hint::black_box;
-use std::time::Instant;
-
-use effectcraft_aep::{Body, Chunk};
-
-fn fnv(bytes: &[u8]) -> u64 {
-    let mut h: u64 = 0xcbf2_9ce4_8422_2325;
-    for b in bytes {
-        h ^= u64::from(*b);
-        h = h.wrapping_mul(0x0100_0000_01b3);
-    }
-    h
-}
-
-fn dump(dir: &str) {
-    let mut names: Vec<_> = std::fs::read_dir(dir).unwrap().filter_map(|e| e.ok()).map(|e| e.path()).collect();
-    names.sort();
-    let exists = |_: &str| true;
-    let opts = effectcraft_aep::import::ImportOptions { allow_losses: true, ..effectcraft_aep::import::ImportOptions::new(&exists) };
-    for path in names {
-        let ext = path.extension().and_then(|e| e.to_str()).unwrap_or("");
-        if ext != "aep" && ext != "aepx" {
-            continue;
-        }
-        let bytes = std::fs::read(&path).unwrap();
-        let name = path.file_name().unwrap().to_string_lossy().to_string();
-        let mut p = effectcraft_project::Project::default();
-        match effectcraft_aep::import::import(&mut p, &bytes, &opts) {
-            Ok(r) => {
-                let pj = serde_json::to_vec(&p).unwrap();
-                let rj = serde_json::to_vec(&r.report).unwrap();
-                let summary = (r.report.total_losses(), r.report.is_lossless(), r.report.summary());
-                let eo = effectcraft_aep::export::ExportOptions { allow_losses: true };
-                let (eb, er, es) = match effectcraft_aep::export::export(&p, &eo) {
-                    Ok(x) => (
-                        fnv(&x.bytes),
-                        fnv(&serde_json::to_vec(&x.report).unwrap()),
-                        format!("{:?}", (x.report.total_losses(), x.report.is_lossless(), x.report.summary())),
-                    ),
-                    Err(e) => (0, 0, format!("ERR {e}")),
-                };
-                println!("{name} project={:016x} report={:016x} export={eb:016x} export_report={er:016x} isum={summary:?} esum={es}", fnv(&pj), fnv(&rj));
-            }
-            Err(e) => println!("{name} IMPORT ERR {e}"),
-        }
-    }
-}
-
-fn time<T>(reps: usize, mut f: impl FnMut() -> T) -> f64 {
-    let mut v = Vec::with_capacity(reps);
-    for _ in 0..reps {
-        let t = Instant::now();
-        black_box(f());
-        v.push(t.elapsed().as_secs_f64() * 1e6);
-    }
-    v.sort_by(f64::total_cmp);
-    v[v.len() / 2]
-}
-
-fn bench(path: &str, reps: usize) {
-    let bytes = std::fs::read(path).unwrap();
-    let exists = |_: &str| true;
-    let opts = effectcraft_aep::import::ImportOptions { allow_losses: true, ..effectcraft_aep::import::ImportOptions::new(&exists) };
-    let m = time(reps, || {
-        let mut p = effectcraft_project::Project::default();
-        effectcraft_aep::import::import(&mut p, &bytes, &opts).map(|r| r.items.len()).ok()
-    });
-    println!("import {m:.1} us");
-    let mut proj = effectcraft_project::Project::default();
-    effectcraft_aep::import::import(&mut proj, &bytes, &opts).unwrap();
-    let eo = effectcraft_aep::export::ExportOptions { allow_losses: true };
-    let m = time(reps, || effectcraft_aep::export::export(&proj, &eo).map(|r| r.bytes.len()).ok());
-    println!("export {m:.1} us");
-}
-
-fn scale(input: &str, n: usize, out: &str) {
-    let bytes = std::fs::read(input).unwrap();
-    let mut file = effectcraft_aep::parse(&bytes).unwrap();
-    for c in &mut file.chunks {
-        if c.is_list(b"Fold")
-            && let Body::List { children, .. } = &mut c.body
-        {
-            let items: Vec<Chunk<'_>> = children.iter().filter(|c| c.is_list(b"Item")).cloned().collect();
-            for _ in 1..n {
-                children.extend(items.iter().cloned());
-            }
-        }
-    }
-    std::fs::write(out, effectcraft_aep::write(&file).unwrap()).unwrap();
-}
-
-fn main() {
-    let a: Vec<String> = std::env::args().collect();
-    match a.get(1).map(String::as_str) {
-        Some("dump") => dump(&a[2]),
-        Some("bench") => bench(&a[2], a.get(3).and_then(|s| s.parse().ok()).unwrap_or(20)),
-        Some("scale") => scale(&a[2], a[3].parse().unwrap(), &a[4]),
-        _ => eprintln!("usage: see the top of this file"),
-    }
-}

From 8439daea0b49be4ce94135f4fee2bc59f55334fe Mon Sep 17 00:00:00 2001
From: vangel76 <vangel1976@googlemail.com>
Date: Sun, 8 Nov 2026 04:36:18 +0100
Subject: [PATCH 16/30] aep export: sort keys as one compact byte string,
 bounded by the name (#3277)

The cached natural keys were Vecs of (bool, String, u128) segments: a 255-byte
name of alternating letters and digits took about 14 KB, held for every item at
once. Each key is now one byte string whose byte order is the natural order,
at most 5 bytes per name byte. Order and output are unchanged.
---
 crates/aep/src/export/emit.rs | 93 +++++++++++++++++++++++++----------
 1 file changed, 66 insertions(+), 27 deletions(-)

diff --git a/crates/aep/src/export/emit.rs b/crates/aep/src/export/emit.rs
index 25d69d7bb..2c4f714ce 100644
--- a/crates/aep/src/export/emit.rs
+++ b/crates/aep/src/export/emit.rs
@@ -127,40 +127,54 @@ fn emit_with(t: &Template, plan: &ProjectPlan, extra: &[u8]) -> R<Vec<u8>> {
 /// Marks a root entry that goes into the `Solids` folder.
 const ROOT_SOLID: u64 = 1 << 63;
 
-/// Sorts by name in natural order, then by the tie-break key. Each name's [`natural_key`] is built
-/// once, not on every comparison; the sort is stable, as `sort_by` is.
+/// Sorts by name in natural order, then by the tie-break key. Each name's sort key is built once,
+/// not on every comparison; the sort is stable, as `sort_by` is.
 fn sort_named(v: &mut [Sorted]) {
-    v.sort_by_cached_key(|(name, key, _)| (Natural(natural_key(name)), *key));
+    v.sort_by_cached_key(|(name, key, _)| (natural_bytes(name), *key));
 }
 
-/// A [`natural_key`] ordered segment by segment: a number before text, numbers by value and then
-/// by their digits (`1` before `01`), text by its lowercase string; a key that is a prefix of the
-/// other first. Two keys compare equal only when they are equal.
-#[derive(PartialEq, Eq)]
-struct Natural(Vec<(bool, String, u128)>);
-
-impl Ord for Natural {
-    fn cmp(&self, other: &Self) -> std::cmp::Ordering {
-        for (x, y) in self.0.iter().zip(other.0.iter()) {
-            let c = match (x.0, y.0) {
-                (true, true) => x.2.cmp(&y.2).then_with(|| x.1.cmp(&y.1)),
-                (false, false) => x.1.cmp(&y.1),
-                (true, false) => std::cmp::Ordering::Less,
-                (false, true) => std::cmp::Ordering::Greater,
-            };
-            if c != std::cmp::Ordering::Equal {
-                return c;
+/// The [`natural_key`] of `name` as one byte string whose plain byte order is the natural order:
+/// segment by segment, a number before text, numbers by value and then by their digits (`1`
+/// before `01`), text by its lowercase string, and a key that is a prefix of the other first.
+///
+/// - A number: `0x01`, the count of significant bytes of its value, those bytes big-endian, its
+///   digits, `0x00` (digits are never `0x00`, so a shorter digit string sorts first).
+/// - Text: `0x02`, its lowercase UTF-8 with each `0x00` written as `0x00 0x01`, then `0x00 0x00`.
+///
+/// At most 5 bytes per byte of `name` (`NATURAL_BYTES_PER_NAME_BYTE`), so the cached keys stay
+/// within a small multiple of the names they sort (one segment as a `(bool, String, u128)` takes
+/// 48 bytes plus its string, which is why the segments themselves are not cached).
+fn natural_bytes(name: &str) -> Vec<u8> {
+    let mut out = Vec::with_capacity(name.len().saturating_add(4));
+    for (number, text, value) in natural_key(name) {
+        if number {
+            out.push(0x01);
+            let be = value.to_be_bytes();
+            let zeros = be.iter().take_while(|b| **b == 0).count();
+            let significant = be.get(zeros..).unwrap_or_default();
+            out.push(significant.len() as u8);
+            out.extend_from_slice(significant);
+            out.extend_from_slice(text.as_bytes());
+            out.push(0x00);
+        } else {
+            out.push(0x02);
+            for b in text.bytes() {
+                out.push(b);
+                if b == 0 {
+                    out.push(0x01);
+                }
             }
+            out.extend_from_slice(&[0x00, 0x00]);
         }
-        self.0.len().cmp(&other.0.len())
     }
+    out
 }
 
-impl PartialOrd for Natural {
-    fn partial_cmp(&self, other: &Self) -> Option<std::cmp::Ordering> {
-        Some(self.cmp(other))
-    }
-}
+/// The bound on [`natural_bytes`]: a run of `d` digits takes at most `3 + 2d` bytes (its value
+/// never needs more bytes than digits), a text run of `b` bytes at most `3 + 2b` (lowercasing and
+/// the NUL escape at most double a character), and every run is at least one byte long.
+#[cfg(test)]
+const NATURAL_BYTES_PER_NAME_BYTE: usize = 5;
 
 fn assign_ids(entries: &[Entry], cx: &mut Cx<'_>, map: &mut HashMap<ItemId, u32>) -> R<()> {
     // Iterative to bound the stack by the folder depth the plan already limits.
@@ -998,6 +1012,11 @@ mod tests {
             "ß",
             "İ",
             "\u{0}",
+            "\u{1}",
+            "a\u{0}",
+            "Ⱥ",
+            "K",
+            "ẞ",
             "Solid ",
             "solid ",
             "x9",
@@ -1015,7 +1034,7 @@ mod tests {
             z = (z ^ (z >> 27)).wrapping_mul(0x94d0_49bb_1331_11eb);
             (z ^ (z >> 31)) as usize
         };
-        for round in 0..200 {
+        for round in 0..2000 {
             let n = 1 + next() % 40;
             let v: Vec<Sorted> = (0..n)
                 .map(|i| {
@@ -1031,6 +1050,26 @@ mod tests {
         }
     }
 
+    /// The cached sort keys stay within [`NATURAL_BYTES_PER_NAME_BYTE`] bytes per name byte, also
+    /// for the worst name (255 bytes of alternating one-character text and digit runs: 255
+    /// segments, which as `(bool, String, u128)` segments took about 14 KB), and the per-character
+    /// premise of the bound holds for every character.
+    #[test]
+    fn sort_keys_are_bounded_by_the_name() {
+        for c in (0..=0x10_ffff_u32).filter_map(char::from_u32) {
+            let lower: usize = c.to_lowercase().map(char::len_utf8).sum::<usize>() + usize::from(c == '\0');
+            assert!(lower <= 2 * c.len_utf8(), "{c:?}");
+        }
+        let worst: String = (0..255).map(|i| if i % 2 == 0 { 'a' } else { '1' }).collect();
+        let others = ["", "1", "a", "\u{0}", "İ", "Ⱥ1", "99999999999999999999999999999999999999999999", &"\u{0}".repeat(255), &"Ⱥ".repeat(127)];
+        for name in std::iter::once(worst.as_str()).chain(others) {
+            let k = natural_bytes(name);
+            assert!(k.len() <= NATURAL_BYTES_PER_NAME_BYTE * name.len(), "{name:?}: {} bytes", k.len());
+        }
+        assert_eq!(natural_key(&worst).len(), 255);
+        assert!(natural_bytes(&worst).len() <= 1_275);
+    }
+
     /// `tdmn_is` and `tdmn_bytes` agree with the Latin-1 decoding they replaced for every name the
     /// emitter looks up, which holds because those names are ASCII.
     #[test]

From 245e9b684478852836f441a624d4ab3d0ccd05f1 Mon Sep 17 00:00:00 2001
From: vangel76 <vangel1976@googlemail.com>
Date: Sun, 8 Nov 2026 04:36:37 +0100
Subject: [PATCH 17/30] aep container: check bdata digits and size before
 reserving (#3275)

decode_hex reserved the decoded size before it knew the value decodes,
so a large bdata with a bad digit reserved half its length first. It now
refuses a value larger than a chunk's 32-bit size field (TooLarge), checks
every digit in one vectorisable pass, and only then reserves, with
try_reserve_exact so a value that does not fit in memory is an error
instead of an abort.
---
 crates/aep/src/container/aepx.rs | 48 ++++++++++++++++++++++++++++++--
 1 file changed, 46 insertions(+), 2 deletions(-)

diff --git a/crates/aep/src/container/aepx.rs b/crates/aep/src/container/aepx.rs
index 21c30ae8b..e79b904d1 100644
--- a/crates/aep/src/container/aepx.rs
+++ b/crates/aep/src/container/aepx.rs
@@ -473,6 +473,15 @@ fn decode_entities(raw: &[u8], offset: usize, out: &mut Vec<u8>) -> Result<(), A
 
 /// Decodes a `bdata` value (hex digits, two per byte).
 fn decode_hex(text: &[u8], offset: usize) -> Result<Vec<u8>, AepError> {
+    decode_hex_at_most(text, offset, MAX_BDATA)
+}
+
+/// The most bytes one `bdata` may decode to: what the 32-bit size field of a chunk can hold (a
+/// larger body could not be written back as an `.aep` either).
+const MAX_BDATA: usize = u32::MAX as usize;
+
+/// [`decode_hex`] with the decoded-size limit as a parameter (so tests can reach it).
+fn decode_hex_at_most(text: &[u8], offset: usize, max: usize) -> Result<Vec<u8>, AepError> {
     if text.len() % 2 == 1 {
         return Err(xml(offset, "bdata has an odd number of hex digits"));
     }
@@ -483,8 +492,18 @@ fn decode_hex(text: &[u8], offset: usize) -> Result<Vec<u8>, AepError> {
         _ => None,
     };
     let (pairs, _) = text.as_chunks::<2>();
-    // Sized once (collecting into `Option<Vec>` has no size hint and regrows step by step).
-    let mut out = Vec::with_capacity(pairs.len());
+    if pairs.len() > max {
+        return Err(AepError::TooLarge);
+    }
+    // Nothing is reserved for a value that does not decode: one cheap pass checks every digit first.
+    // Blocks without an early exit inside, so the check vectorises; it stops at the first bad block.
+    if !text.chunks(4096).all(|block| block.iter().fold(true, |ok, b| ok & b.is_ascii_hexdigit())) {
+        return Err(xml(offset, "bdata holds a character that is not a hex digit"));
+    }
+    // Sized once (collecting into `Option<Vec>` has no size hint and regrows step by step), and
+    // without aborting when the memory is not there.
+    let mut out = Vec::new();
+    out.try_reserve_exact(pairs.len()).map_err(|_| xml(offset, "bdata is too large to hold in memory"))?;
     for [hi, lo] in pairs {
         match (digit(*hi), digit(*lo)) {
             (Some(h), Some(l)) => out.push((h << 4) | l),
@@ -653,6 +672,31 @@ mod tests {
         assert_eq!(f.chunks[0].bytes(), Some(&[0x0a, 0xff][..]));
     }
 
+    #[test]
+    fn a_large_bdata_with_a_bad_digit_is_refused_before_it_is_sized() {
+        // 10 MB of hex that is bad from the first pair (and once more at the very end).
+        let mut text = b"zz".to_vec();
+        text.extend(std::iter::repeat_n(*b"00", 5_000_000).flatten());
+        assert_eq!(decode_hex(&text, 3), Err(xml(3, "bdata holds a character that is not a hex digit")));
+        let mut late = vec![b'0'; 10_000_000];
+        late.extend_from_slice(b"0g");
+        assert_eq!(decode_hex(&late, 3), Err(xml(3, "bdata holds a character that is not a hex digit")));
+        let x = doc(&format!("<a bdata=\"{}\"/>", std::str::from_utf8(&text).unwrap()));
+        assert!(matches!(read_aepx(x.as_bytes()), Err(AepError::Xml { .. })));
+    }
+
+    #[test]
+    fn bdata_decodes_up_to_the_size_limit_and_not_past_it() {
+        assert_eq!(decode_hex_at_most(b"00ff10", 0, 3), Ok(vec![0x00, 0xff, 0x10]));
+        assert_eq!(decode_hex_at_most(b"00ff10", 0, 2), Err(AepError::TooLarge));
+        assert_eq!(decode_hex_at_most(b"", 0, 0), Ok(Vec::new()));
+        assert_eq!(decode_hex_at_most(b"00", 0, 0), Err(AepError::TooLarge));
+        // The odd-length error still comes first.
+        assert_eq!(decode_hex_at_most(b"001", 0, 0), Err(xml(0, "bdata has an odd number of hex digits")));
+        // The real limit is what a chunk's 32-bit size field holds.
+        assert_eq!(MAX_BDATA as u64, u64::from(u32::MAX));
+    }
+
     #[test]
     fn decode_hex_matches_the_collecting_version() {
         fn old(text: &[u8], offset: usize) -> Result<Vec<u8>, AepError> {

From d2359d607ea345420e5883843018ec2c5583588a Mon Sep 17 00:00:00 2001
From: vangel76 <vangel1976@googlemail.com>
Date: Sun, 8 Nov 2026 04:41:46 +0100
Subject: [PATCH 18/30] aep export: the every-layout test counts from a
 baseline, not from zero (#3278)

---
 crates/aep/src/export/tree.rs | 5 +++--
 1 file changed, 3 insertions(+), 2 deletions(-)

diff --git a/crates/aep/src/export/tree.rs b/crates/aep/src/export/tree.rs
index f975e1668..9c71a27b8 100644
--- a/crates/aep/src/export/tree.rs
+++ b/crates/aep/src/export/tree.rs
@@ -213,9 +213,10 @@ mod tests {
     /// text, cameras, lights, shapes, styles) are built and no write went out of range.
     #[test]
     fn every_fixed_layout_fits() {
-        assert_eq!(fixed_layout_errors(), 0);
+        // A delta: other tests on this thread may have counted a broken layout on purpose.
+        let before = fixed_layout_errors();
         assert!(crate::export::template::Template::load().is_ok());
-        assert_eq!(fixed_layout_errors(), 0);
+        assert_eq!(fixed_layout_errors(), before);
     }
 
     #[test]

From d6ec32cbaa48178cb1c4830277c80d0221d8e6cb Mon Sep 17 00:00:00 2001
From: vangel76 <vangel1976@googlemail.com>
Date: Sun, 8 Nov 2026 06:19:17 +0100
Subject: [PATCH 19/30] aep export: correct the order the natural sort key doc
 gives for equal numbers (#3277)

---
 crates/aep/src/export/emit.rs | 8 +++++---
 1 file changed, 5 insertions(+), 3 deletions(-)

diff --git a/crates/aep/src/export/emit.rs b/crates/aep/src/export/emit.rs
index 2c4f714ce..08ab82904 100644
--- a/crates/aep/src/export/emit.rs
+++ b/crates/aep/src/export/emit.rs
@@ -134,11 +134,13 @@ fn sort_named(v: &mut [Sorted]) {
 }
 
 /// The [`natural_key`] of `name` as one byte string whose plain byte order is the natural order:
-/// segment by segment, a number before text, numbers by value and then by their digits (`1`
-/// before `01`), text by its lowercase string, and a key that is a prefix of the other first.
+/// segment by segment, a number before text, numbers by value and then by their digit strings
+/// byte by byte (`01` before `1`), text by its lowercase string, and a key that is a prefix of
+/// the other first.
 ///
 /// - A number: `0x01`, the count of significant bytes of its value, those bytes big-endian, its
-///   digits, `0x00` (digits are never `0x00`, so a shorter digit string sorts first).
+///   digits, `0x00` (digits are never `0x00`, so a digit string that is a prefix of another, as
+///   `0` of `00`, sorts first).
 /// - Text: `0x02`, its lowercase UTF-8 with each `0x00` written as `0x00 0x01`, then `0x00 0x00`.
 ///
 /// At most 5 bytes per byte of `name` (`NATURAL_BYTES_PER_NAME_BYTE`), so the cached keys stay

From b3c89f314c44c36179eb92465463e188460980cf Mon Sep 17 00:00:00 2001
From: vangel76 <vangel1976@googlemail.com>
Date: Sun, 8 Nov 2026 06:19:18 +0100
Subject: [PATCH 20/30] aep: the format notes name the accessors that remain
 (#3281)

---
 docs/aep-format.md | 29 ++++++++++++++---------------
 1 file changed, 14 insertions(+), 15 deletions(-)

diff --git a/docs/aep-format.md b/docs/aep-format.md
index a0eb9de6a..9640aba0c 100644
--- a/docs/aep-format.md
+++ b/docs/aep-format.md
@@ -216,12 +216,12 @@ the value from the corpus manifest (test file in parentheses at the end of each
 
 API: `LayerHeader` (`is_video_enabled`/`is_enabled`, `is_audio_enabled`, `is_effects_enabled`,
 `is_auto_oriented`, `light_type`, `blend_mode`, `stretch` / `stretch_den`, `stretch_ratio`,
-`stretch_percent`, `in_point`, `out_point`); the same switches on `Layer`; `Layer::track_matte`
+`in_point`, `out_point`); the same switches on `Layer`; `Layer::track_matte`
 (`TrackMatte`, `MatteMode`; test `tests/matte.rs`). `stretch` is now the
 numerator of the ratio (it was the whole multiplier before 50 % and 150 % were sampled). Tests:
 `tests/header.rs`, `tests/layer_switches.rs`. The layer name itself is the `Utf8` child of the
 `Layr` (empty while the name is the source's); the layer then shows the name of its source item
-(`Project::layer_display_name`).
+(`Project::layer_source(...)` then `Item::display_name`, the rule the importer uses).
 
 ### 3.2 Composition header (`Item/cdta`, 204 bytes; the decoder needs the first 176) and renderer
 
@@ -246,9 +246,9 @@ numerator of the ratio (it was the whole multiplier before 50 % and 150 % were s
 
 The inert `ADBE Time Remapping` record of every AV layer has `tduM` = the source's duration in seconds: 5 for 5 s compositions (124, 257, 258), 3 and 2 for a 3 s and a 2 s composition (600, 601), 1 for the 1 s WAV (351), 0.1 for the three-frame sequence (353), 0 on solids and stills (000, 126). Every property's keyframe time scale (`tdb4` bytes 12 to 15) follows the composition (23 976 in every
 property of `L` after 229 and 230). The corpus manifest calls the classic renderer
-`ADBE Advanced 3d`; the file stores `ADBE Escher` / `Classic 3D`. API: `CompHeader::frame_rate_exact`
-(exact fraction), `duration_frames`, `shutter_phase`, `display_start`, `display_start_seconds`,
-`display_start_frame`. Tests: `tests/header.rs`, `tests/layer_switches.rs`.
+`ADBE Advanced 3d`; the file stores `ADBE Escher` / `Classic 3D`. API: `CompHeader::{time_base,
+frame_rate_fixed, duration_units, shutter_phase, display_start}` (`display_start` is the exact
+fraction). Tests: `tests/header.rs`, `tests/layer_switches.rs`.
 
 ### 3.3 Items, footage and precomps
 
@@ -292,7 +292,8 @@ name. A footage layer shows the item's name while it has no name of its own (351
 
 Test: `tests/header.rs` (precomp), `tests/text_markers_footage.rs` and `tests/batch3_objects.rs`
 (footage), `tests/layer_switches.rs` (solid colour). API: `Footage::{duration, native_frame_rate,
-bits_per_pixel, file_size, audio_sample_rate, is_sequence, sequence_frame_count}`.
+bits_per_pixel, file_size, audio_sample_rate, is_sequence}`; `Item::sequence_info` (with
+`SequenceInfo::frame_count`).
 
 ### 3.4 Properties: sparse storage, static values and units
 
@@ -401,8 +402,8 @@ out speed, at 40 out influence**). Scale key 1 of 305 (`n = 3`, in 0 / 33 %, out
 15 / 66) is `0,0, .33,.33, 15,15, .66,.66`. Component `i` uses slot `i` of each block (**V** for the
 block layout and the units, Scale speed in fractions per second and Mask Feather speed in pixels
 per second; **E** that different values per dimension sit in the slot of their dimension, because
-the tool that made the corpus applies one ease to all dimensions; **V** since the exporter wrote three different eases for the three Scale dimensions and After Effects read the same three back, aep-export.md R13). `Keyframe::plain_ease_slots`
-returns the doubles as stored, `Keyframe::ease_component(i)` one component's `KeyEase`. Layout of
+the tool that made the corpus applies one ease to all dimensions; **V** since the exporter wrote three different eases for the three Scale dimensions and After Effects read the same three back, aep-export.md R13). `Keyframe::ease_component(i)`
+returns one component's `KeyEase`, `Keyframe::ease_components` all of them. Layout of
 the spatial template: `u32` at 8 (1 normally, 0 after the spatial auto-bezier and continuous
 switches were turned off together, 054), `f64` arc length of the segment to the next key at 16
 (100 in 204 key 1, 0 on the last key and right after creation; safe to ignore), **ease at 24 in
@@ -427,7 +428,7 @@ in tangent (`n` x `f64`, relative offset from the value) at `56 + 8 n`, out tang
 | **ease, colour switched to bezier** | spatial n=4 @24..55 | keyframe.set_interpolation bezier on two colour keys stores speed 0 and influence 0 on both sides, and After Effects interpolates them linearly (598 Start Color red to blue: 0.75 / 0.5 / 0.25 red at 0.5 / 1 / 1.5 s); a custom colour ease cannot be set by script | 598 | V |
 | **ease, mask path** | 64-byte record @24..55 | in speed, in influence, out speed, out influence as in the spatial template: 599 out / in influence 0.75, 700 0.2 / 0.5, speeds 0 (the path at 0.5 s is 5.42 % / 28.0 % of the way). The `f64` at 16 is 1 (093) or 2 (599, 700) on the first key and 0 on the last (not decoded) | 093, 599, 700 | V (influence), ? (speed unit) |
 
-API: `Keyframe::{interpolation_in, interpolation_out, kind, value, ease, ease_component, ease_components, plain_ease_slots, color_distance, spatial}`;
+API: `Keyframe::{interpolation_in, interpolation_out, kind, value, ease, ease_component, ease_components, spatial}` (the `f64` at byte 16 of a colour key is `SpatialKey::segment_length`);
 `Property::keys()` hands the property's template to its records. Marker record (16 bytes): time,
 `03 03` hold bytes, 8 stale bytes. Mask path record (64 bytes): the common fields and the ease at byte 24 (599, 700). Test:
 `tests/values.rs`, `tests/keyframes.rs`.
@@ -630,7 +631,7 @@ a non-zero byte at 112).
 328), so mode and inverted are reported per mask. `mkif` byte 8 is the running mask id counter of the
 **layer** in the session (1, 2 for the two masks of 328; 329 then gets 3; undo does not reset it; a new
 layer starts at 1 again): exposed as `Mask::counter`, a session counter and not a stable id. API:
-`Mask::{mode, inverted, counter}`, `Project::mask_vertices_px` (vertices in layer pixels), `Layer::mask_atoms` (`MaskAtom`: the mask with its atom group, its path property and its shapes by position, for the keys and expressions of the mask properties). Tests:
+`Mask::{mode, inverted, counter}`, `ShapePath::vertices(size)` (vertices in layer pixels, with the size of the layer's source, `Project::layer_source_size`), `Layer::mask_atoms` (`MaskAtom`: the mask with its atom group, its path property and its shapes by position, for the keys and expressions of the mask properties). Tests:
 `tests/masks.rs` (with a synthetic check of the handle order), `tests/batch3_objects.rs`.
 
 ### 3.9 Shape layers (`tdgp[ADBE Root Vectors Group]`)
@@ -758,7 +759,7 @@ groups as on other layers, with these conventions:
 
 | What | Path | Stored | Evidence | Conf. |
 |---|---|---|---|---|
-| camera Position, default (auto state) | `ADBE Transform Group/ADBE Position`, `tdb4` 76 and 77 = 1 although no expression exists | `[0, 0, -2666.67]` (x and y are 0 whatever the composition size; z = -zoom). A **one-node** camera reports `[0, 0, -2666.67]` (251). **Correction (S16): a reopened two-node camera reports `[0, 0, -2666.67]` too (256 read back), and After Effects renders it there**: the default two-node camera of 537 above the 3D solid of 486 renders from `[0, 0, -2666.67]` towards the point of interest, not like the composition's default view (537 differs from 486 in 24 % of the grid points, and EffectCraft's import with the stored position matches 537 but for 4 edge points). The `[960, 540, ...]` of the batch-3 notes was not reproduced (535 and 537, created by script, read back the stored value too); `CameraPosition::reported` keeps the old rule and is marked as contradicted | 256, 251, 537 | V |
+| camera Position, default (auto state) | `ADBE Transform Group/ADBE Position`, `tdb4` 76 and 77 = 1 although no expression exists | `[0, 0, -2666.67]` (x and y are 0 whatever the composition size; z = -zoom). A **one-node** camera reports `[0, 0, -2666.67]` (251). **Correction (S16): a reopened two-node camera reports `[0, 0, -2666.67]` too (256 read back), and After Effects renders it there**: the default two-node camera of 537 above the 3D solid of 486 renders from `[0, 0, -2666.67]` towards the point of interest, not like the composition's default view (537 differs from 486 in 24 % of the grid points, and EffectCraft's import with the stored position matches 537 but for 4 edge points). The `[960, 540, ...]` of the batch-3 notes was not reproduced (535 and 537, created by script, read back the stored value too); the reader keeps only the stored value (`CameraPosition::stored`) | 256, 251, 537 | V |
 | camera Position, set by the user | same, `tdb4` 76 and 77 = 0 | the absolute value `[100, 200, -1000]` | 253 | V |
 | camera point of interest | `ADBE Anchor Point` | `[960, 540, 0]` in **pixels** (not a fraction); the record's `tdsb` is 1 on a two-node and 3 on the one-node camera (not asserted) | 251, 253, 256 | V (value), E (`tdsb`) |
 | light Position, default | same as the camera | `[0, 0, -1333.33]`, as After Effects reports it (255 read back); the point of interest `[960, 540, 0]` | 254, 255 | V |
@@ -774,10 +775,8 @@ groups as on other layers, with these conventions:
 
 A point light made by converting a spot light has a different property set (`Orientation`, `Rotate
 X/Y/Z`, `Cone Angle`, `Cone Feather 2` in the default state) that a spot light lacks (252); whether that
-is an artefact of the conversion is untested. API: `Layer::camera_position`,
-`CameraPosition::reported`, `Layer::camera_point_of_interest`, `Layer::light_intensity`,
-`Layer::{camera_zoom, camera_depth_of_field, camera_focus_distance, camera_aperture, light_color,
-light_cone_angle, light_cone_feather}`, `DEFAULT_CAMERA_ZOOM` (2 666.67 is verified for the 1920 px
+is an artefact of the conversion is untested. API: `Layer::camera_position`; the camera and light
+options are read by the importer's table (`import/camera.rs`); `DEFAULT_CAMERA_ZOOM` (2 666.67 is verified for the 1920 px
 composition only), `Layer::orientation` (`Orientation`; test `orientation_is_otst_otda` in
 `tests/batch5.rs`). Render checks against After Effects (20 px grid, 5 184 points): 486 1 point
 off, 535 2, 536 0, 537 4 (anti-aliased edges); **488 (Orientation `[10, 20, 30]`): 272 points

From c862ce0aa0fe8217eebe04ad5c4d6ce1a08bc008 Mon Sep 17 00:00:00 2001
From: vangel76 <vangel1976@googlemail.com>
Date: Sun, 8 Nov 2026 08:18:44 +0100
Subject: [PATCH 21/30] aep: the format notes name the 1 x 1 mask scale of text
 and shape layers (#3281)

---
 docs/aep-format.md | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/docs/aep-format.md b/docs/aep-format.md
index 9640aba0c..584a34330 100644
--- a/docs/aep-format.md
+++ b/docs/aep-format.md
@@ -631,7 +631,7 @@ a non-zero byte at 112).
 328), so mode and inverted are reported per mask. `mkif` byte 8 is the running mask id counter of the
 **layer** in the session (1, 2 for the two masks of 328; 329 then gets 3; undo does not reset it; a new
 layer starts at 1 again): exposed as `Mask::counter`, a session counter and not a stable id. API:
-`Mask::{mode, inverted, counter}`, `ShapePath::vertices(size)` (vertices in layer pixels, with the size of the layer's source, `Project::layer_source_size`), `Layer::mask_atoms` (`MaskAtom`: the mask with its atom group, its path property and its shapes by position, for the keys and expressions of the mask properties). Tests:
+`Mask::{mode, inverted, counter}`, `ShapePath::vertices(size)` (vertices in layer pixels: `size` is the size of the layer's source, `Project::layer_source_size`; a text or shape layer has no source size and its mask boxes are already pixels, so the importer passes 1 x 1), `Layer::mask_atoms` (`MaskAtom`: the mask with its atom group, its path property and its shapes by position, for the keys and expressions of the mask properties). Tests:
 `tests/masks.rs` (with a synthetic check of the handle order), `tests/batch3_objects.rs`.
 
 ### 3.9 Shape layers (`tdgp[ADBE Root Vectors Group]`)

From b80ac9edb974ae9a97247f6a1303b6ab2bba437b Mon Sep 17 00:00:00 2001
From: vangel76 <vangel1976@googlemail.com>
Date: Sun, 8 Nov 2026 15:00:52 +0100
Subject: [PATCH 22/30] aep: read imports through a flat tree index (#3300)

Import reads an .aep through TreeIndex, one depth-first array of chunks that
borrows the file's bytes, instead of building and freeing the owned Chunk tree
(one Vec per list). The parser mirrors read::Parser step for step: the same
chunk count order against max_chunks, the same depth limit and opaque
fallbacks, the same errors. The typed view reads through Node, a handle to a
chunk of either tree, so the accessors work unchanged on both; .aepx keeps its
owned tree. Chunk, parse and write stay for export and editing.

The array starts small and doubles, never past what the input can hold or the
chunk limit allows; a failed allocation is TooLarge, a tree past u32 indices
TooManyChunks.
---
 crates/aep/src/container.rs                  |   2 +
 crates/aep/src/container/arbitrary.rs        |  14 +-
 crates/aep/src/container/effects.rs          |  51 +-
 crates/aep/src/container/footage.rs          |  14 +-
 crates/aep/src/container/index.rs            | 955 +++++++++++++++++++
 crates/aep/src/container/masks.rs            |  12 +-
 crates/aep/src/container/read.rs             |  18 +-
 crates/aep/src/container/settings.rs         |  25 +-
 crates/aep/src/container/shapes.rs           |   2 +-
 crates/aep/src/container/textdoc.rs          |  29 +-
 crates/aep/src/container/typed.rs            |  84 +-
 crates/aep/src/container/values.rs           |   1 -
 crates/aep/src/container/version.rs          |  25 +-
 crates/aep/src/import.rs                     |  93 +-
 crates/aep/src/import/markers.rs             |   7 +-
 crates/aep/src/import/report.rs              |   5 +
 crates/aep/src/import/settings.rs            |   9 +-
 crates/aep/src/import/shapes.rs              |   2 +-
 crates/aep/tests/it/common/mod.rs            |   2 +-
 crates/aep/tests/it/container.rs             |   1 +
 crates/aep/tests/it/container/batch3_core.rs |   4 +-
 crates/aep/tests/it/container/tree_index.rs  | 212 ++++
 crates/aep/tests/it/container/typed.rs       |   6 +-
 crates/aep/tests/it/export/effects.rs        |   2 +-
 crates/aep/tests/it/export/objects.rs        |   7 +-
 crates/aep/tests/it/export/styles.rs         |   2 +-
 crates/aep/tests/it/import/combined.rs       |   2 +-
 27 files changed, 1454 insertions(+), 132 deletions(-)
 create mode 100644 crates/aep/src/container/index.rs
 create mode 100644 crates/aep/tests/it/container/tree_index.rs

diff --git a/crates/aep/src/container.rs b/crates/aep/src/container.rs
index b6c3b4490..b8a6d1957 100644
--- a/crates/aep/src/container.rs
+++ b/crates/aep/src/container.rs
@@ -23,6 +23,7 @@ mod effects;
 mod error;
 mod footage;
 mod header;
+pub mod index;
 mod keys;
 mod masks;
 mod matte;
@@ -44,6 +45,7 @@ pub use effects::{DefinitionSource, Effect, EffectDefinitions, EffectParam, Laye
 pub use error::AepError;
 pub use footage::{Footage, SequenceInfo};
 pub use header::{BlendMode, CompHeader, LayerHeader, LayerType, LightType, Quality, Rational, Renderer};
+pub use index::{Node, NodeWalk, Nodes, TreeIndex};
 pub use keys::{ExpressionFlags, Interpolation, KeyEase, KeyframeKind, SpatialKey};
 pub use masks::{Mask, MaskAtom, MaskMode, PathVertex, ShapePath};
 pub use matte::{MatteMode, TrackMatte};
diff --git a/crates/aep/src/container/arbitrary.rs b/crates/aep/src/container/arbitrary.rs
index 5762da111..c3322ebdd 100644
--- a/crates/aep/src/container/arbitrary.rs
+++ b/crates/aep/src/container/arbitrary.rs
@@ -7,9 +7,9 @@
 //! Hue/Saturation (444-446) or a Levels value (512-516) changes only bytes of this `aRbp` (and stale
 //! UI bytes of `pard`); the visible parameters of the same names keep no record.
 
-use crate::container::Chunk;
 use crate::container::bytes::{be_f32, be_i32, be_u16, be_u32};
 use crate::container::effects::Effect;
+use crate::container::index::Node;
 
 impl<'f, 'a> Effect<'f, 'a> {
     /// The arbitrary data stored for the parameter with this match name (`<effect>-NNNN`): the
@@ -17,13 +17,13 @@ impl<'f, 'a> Effect<'f, 'a> {
     /// none.
     pub fn arbitrary_data(&self, match_name: &str) -> Option<&'f [u8]> {
         let values = self.chunk().child_list(b"tdgp")?;
-        let kids = values.children();
-        let at = kids.iter().position(|c| c.is(b"tdmn") && c.bytes().is_some_and(|b| name_is(b, match_name)))?;
-        // The value record, then the data list (no match name of its own).
-        let rest = kids.get(at.checked_add(1)?..)?;
-        let mut it = rest.iter().take(3);
+        let mut kids = values.children();
+        // Up to the parameter's match name, then the value record, then the data list (no match
+        // name of its own).
+        kids.find(|c| c.is(b"tdmn") && c.bytes().is_some_and(|b| name_is(b, match_name)))?;
+        let mut it = kids.take(3);
         let _record = it.next().filter(|c| c.is_list(b"tdbs"))?;
-        it.find(|c| c.is_list(b"aRbs")).and_then(|l| l.child(b"aRbp")).and_then(Chunk::bytes)
+        it.find(|c| c.is_list(b"aRbs")).and_then(|l| l.child(b"aRbp")).and_then(Node::bytes)
     }
 }
 
diff --git a/crates/aep/src/container/effects.rs b/crates/aep/src/container/effects.rs
index 2fa77d017..09a5b1ed6 100644
--- a/crates/aep/src/container/effects.rs
+++ b/crates/aep/src/container/effects.rs
@@ -20,8 +20,8 @@
 
 use std::collections::{HashMap, HashSet};
 
-use crate::container::Chunk;
 use crate::container::bytes::{array, be_f32, be_f64, be_i32, be_u16, be_u32, cstr, text, until_nul};
+use crate::container::index::Node;
 use crate::container::typed::{KeyList, Layer, Project, PropGroup, PropNode, Property};
 
 /// The parameter type, the `u32` at byte 12 of `pard`. The numbering matches the plug-in
@@ -132,7 +132,7 @@ pub enum LayerRef {
 #[derive(Debug, Clone)]
 pub struct Effect<'f, 'a> {
     match_name: String,
-    chunk: &'f Chunk<'a>,
+    chunk: Node<'f, 'a>,
 }
 
 /// Where the parameter definitions of an effect instance come from.
@@ -178,13 +178,13 @@ impl<'f, 'a> Effect<'f, 'a> {
     }
 
     /// The underlying `LIST sspc` chunk.
-    pub fn chunk(&self) -> &'f Chunk<'a> {
+    pub fn chunk(&self) -> Node<'f, 'a> {
         self.chunk
     }
 
     /// The instance name shown in the effect controls (`fnam`).
     pub fn name(&self) -> Option<String> {
-        self.chunk.child(b"fnam")?.children().iter().find(|c| c.is(b"Utf8"))?.bytes().map(text)
+        self.chunk.child(b"fnam")?.child(b"Utf8")?.bytes().map(text)
     }
 
     /// The name the user gave the instance: the `tdsn` of the instance's value group when it is
@@ -192,7 +192,7 @@ impl<'f, 'a> Effect<'f, 'a> {
     /// `None` while the instance shows the effect's name.
     pub fn user_name(&self) -> Option<String> {
         let values = self.chunk.child_list(b"tdgp")?;
-        let name = values.child(b"tdsn")?.children().iter().find(|c| c.is(b"Utf8"))?.bytes().map(text)?;
+        let name = values.child(b"tdsn")?.child(b"Utf8")?.bytes().map(text)?;
         (name != "-_0_/-" && !name.is_empty()).then_some(name)
     }
 
@@ -250,7 +250,7 @@ impl<'f, 'a> Effect<'f, 'a> {
     }
 
     /// The parameters described by `part` (a `LIST parT`) with the values of this instance.
-    fn params_from(&self, part: &'f Chunk<'a>, borrowed: bool) -> Vec<EffectParam<'f, 'a>> {
+    fn params_from(&self, part: Node<'f, 'a>, borrowed: bool) -> Vec<EffectParam<'f, 'a>> {
         let mut out: Vec<EffectParam<'f, 'a>> = Vec::new();
         // The stored values by match name: the first entry of a name, as `PropGroup::get` finds it
         // (a group of that name means no stored value). Indexed once: a lookup per parameter
@@ -280,7 +280,7 @@ impl<'f, 'a> Effect<'f, 'a> {
                 });
             } else if c.is(b"pdnm")
                 && let Some(last) = out.last_mut()
-                && let Some(u) = c.children().iter().find(|u| u.is(b"Utf8"))
+                && let Some(u) = c.child(b"Utf8")
                 && let Some(b) = u.bytes()
                 // An empty `pdnm` names nothing (EffectCraft's exports write one: the effect
                 // supplies its items).
@@ -293,8 +293,8 @@ impl<'f, 'a> Effect<'f, 'a> {
     }
 }
 
-fn has_pard(part: &Chunk<'_>) -> bool {
-    part.children().iter().any(|c| c.is(b"pard"))
+fn has_pard(part: Node<'_, '_>) -> bool {
+    part.children().any(|c| c.is(b"pard"))
 }
 
 impl<'f, 'a> Project<'f, 'a> {
@@ -302,18 +302,18 @@ impl<'f, 'a> Project<'f, 'a> {
     /// name and the `LIST parT` of the copied instance, in file order (the stack order of the
     /// types, 365/366). The `EfDC` count before them is little-endian and is not needed to read
     /// them. A type whose copy has no definitions is left out.
-    pub fn effect_definitions(&self) -> Vec<(String, &'f Chunk<'a>)> {
-        let mut out: Vec<(String, &'f Chunk<'a>)> = Vec::new();
+    pub fn effect_definitions(&self) -> Vec<(String, Node<'f, 'a>)> {
+        let mut out: Vec<(String, Node<'f, 'a>)> = Vec::new();
         let Some(defs) = self.effect_defs else { return out };
         let mut seen: HashSet<String> = HashSet::new();
-        for df in defs.children().iter().filter(|c| c.is_list(b"EfDf")) {
+        for df in defs.children().filter(|c| c.is_list(b"EfDf")) {
             let mut name: Option<String> = None;
             for c in df.children() {
                 if c.is(b"tdmn") {
                     name = c.bytes().map(|b| text(until_nul(b)));
                 } else if c.is_list(b"sspc")
                     && let Some(n) = name.take()
-                    && let Some(part) = c.child_list(b"parT").filter(|p| has_pard(p))
+                    && let Some(part) = c.child_list(b"parT").filter(|p| has_pard(*p))
                     && seen.insert(n.clone())
                 {
                     out.push((n, part));
@@ -328,8 +328,8 @@ impl<'f, 'a> Project<'f, 'a> {
     /// For a type without a project-level copy it also keeps the own `parT` of the first instance
     /// in the file (items, layers and effects in file order) that has one.
     pub fn effect_definition_index(&self) -> EffectDefinitions<'f, 'a> {
-        let by_name: HashMap<String, &'f Chunk<'a>> = self.effect_definitions().into_iter().collect();
-        let mut instances: HashMap<String, &'f Chunk<'a>> = HashMap::new();
+        let by_name: HashMap<String, Node<'f, 'a>> = self.effect_definitions().into_iter().collect();
+        let mut instances: HashMap<String, Node<'f, 'a>> = HashMap::new();
         for item in self.all_items() {
             let Some(comp) = item.comp() else { continue };
             for layer in comp.layers() {
@@ -337,7 +337,7 @@ impl<'f, 'a> Project<'f, 'a> {
                     if by_name.contains_key(&fx.match_name) || instances.contains_key(&fx.match_name) {
                         continue;
                     }
-                    if let Some(part) = fx.chunk.child_list(b"parT").filter(|p| has_pard(p)) {
+                    if let Some(part) = fx.chunk.child_list(b"parT").filter(|p| has_pard(*p)) {
                         instances.insert(fx.match_name, part);
                     }
                 }
@@ -363,9 +363,9 @@ impl<'f, 'a> Project<'f, 'a> {
 #[derive(Debug, Clone, Default)]
 pub struct EffectDefinitions<'f, 'a> {
     /// The project-level copies (`EfdG`).
-    by_name: HashMap<String, &'f Chunk<'a>>,
+    by_name: HashMap<String, Node<'f, 'a>>,
     /// For a type without a project-level copy: the own `parT` of the first instance that has one.
-    instances: HashMap<String, &'f Chunk<'a>>,
+    instances: HashMap<String, Node<'f, 'a>>,
 }
 
 impl<'f, 'a> EffectDefinitions<'f, 'a> {
@@ -392,7 +392,7 @@ impl<'f, 'a> EffectDefinitions<'f, 'a> {
             return effect.params();
         }
         match self.by_name.get(effect.match_name()).or_else(|| self.instances.get(effect.match_name())) {
-            Some(part) => effect.params_from(part, true),
+            Some(part) => effect.params_from(*part, true),
             None => Vec::new(),
         }
     }
@@ -638,6 +638,7 @@ impl<'f, 'a> Layer<'f, 'a> {
 #[cfg(test)]
 mod tests {
     use super::*;
+    use crate::container::Chunk;
 
     fn tdmn(name: &str) -> Chunk<'static> {
         let mut b = name.as_bytes().to_vec();
@@ -670,11 +671,11 @@ mod tests {
             ("A".to_string(), Chunk::list(*b"tdbs", vec![Chunk::data(*b"cdat", vec![0u8; 8])])),
         ];
         let chunk = instance(&names, &stored);
-        let fx = Effect { match_name: "X".into(), chunk: &chunk };
+        let fx = Effect { match_name: "X".into(), chunk: Node::from(&chunk) };
         let params = fx.params();
         assert_eq!(params.iter().map(|p| p.match_name.as_str()).collect::<Vec<_>>(), ["A", "B", "C"]);
         let first = params.first().and_then(|p| p.stored).expect("A stored");
-        assert!(first.chunk.children().is_empty(), "the first A (the second has a cdat)");
+        assert!(first.chunk.children().next().is_none(), "the first A (the second has a cdat)");
         assert!(params.get(1).is_some_and(|p| p.stored.is_none()), "a group of that name is no stored value");
         assert!(params.get(2).is_some_and(|p| p.stored.is_none()));
     }
@@ -687,7 +688,7 @@ mod tests {
         let names: Vec<String> = (0..n).map(|i| format!("P{i}")).collect();
         let stored: Vec<(String, Chunk<'static>)> = names.iter().map(|m| (m.clone(), tdbs())).collect();
         let chunk = instance(&names, &stored);
-        let fx = Effect { match_name: "X".into(), chunk: &chunk };
+        let fx = Effect { match_name: "X".into(), chunk: Node::from(&chunk) };
         let params = fx.params();
         assert_eq!(params.len(), n);
         assert!(params.iter().all(|p| p.stored.is_some()));
@@ -707,19 +708,19 @@ mod tests {
         }
         let efdg = Chunk::list(*b"EfdG", defs);
         let fold = Chunk::list(*b"Fold", Vec::new());
-        let project = Project { fold: &fold, effect_defs: Some(&efdg) };
+        let project = Project { fold: Node::from(&fold), effect_defs: Some(Node::from(&efdg)) };
         let all = project.effect_definitions();
         assert_eq!(all.len(), n);
         let index = project.effect_definition_index();
         let bare = Chunk::list(*b"sspc", vec![Chunk::list(*b"parT", Vec::new())]);
         for i in (0..n).step_by(50) {
-            let fx = Effect { match_name: format!("FX{i}"), chunk: &bare };
+            let fx = Effect { match_name: format!("FX{i}"), chunk: Node::from(&bare) };
             assert_eq!(index.source(&fx), DefinitionSource::Project);
             let params = index.params(&fx);
             assert_eq!(params.iter().map(|p| p.match_name.as_str()).collect::<Vec<_>>(), ["R0"], "the first copy's definitions");
             assert!(params.iter().all(|p| p.borrowed_definition));
         }
-        let unknown = Effect { match_name: "nope".into(), chunk: &bare };
+        let unknown = Effect { match_name: "nope".into(), chunk: Node::from(&bare) };
         assert_eq!(index.source(&unknown), DefinitionSource::Missing);
         assert!(index.params(&unknown).is_empty());
         assert_eq!(project.definition_source(&unknown), DefinitionSource::Missing);
diff --git a/crates/aep/src/container/footage.rs b/crates/aep/src/container/footage.rs
index c1007fce5..ce7c8e6c5 100644
--- a/crates/aep/src/container/footage.rs
+++ b/crates/aep/src/container/footage.rs
@@ -2,8 +2,8 @@
 //! of a layer's source.
 
 use crate::container::bytes::{be_f32, be_f64, be_u32, cstr, le_u32, text};
-use crate::container::chunk::Chunk;
 use crate::container::header::Rational;
+use crate::container::index::Node;
 use crate::container::typed::{Item, ItemKind, Layer, Project};
 
 /// The footage data of an item (`LIST Pin ` with `sspc`, `opti` and, for files, `Als2/alas`).
@@ -201,14 +201,13 @@ impl SequenceInfo {
 /// is unreadable (empty). A name that is not a plain file name (holding `/`, `\`, `:` or a control
 /// character such as NUL, or being `.` or `..`) makes the whole list unreadable (empty): the names
 /// are joined to the folder.
-fn sequence_file_list(list: &Chunk<'_>) -> Vec<String> {
+fn sequence_file_list(list: Node<'_, '_>) -> Vec<String> {
     // After Effects writes the count first (the one sample); a list without a readable count is
     // not read rather than guessed.
     let Some(count) = list.child(b"StVS").and_then(|c| c.bytes()).and_then(|b| le_u32(b, 0)).and_then(|n| usize::try_from(n).ok()) else {
         return Vec::new();
     };
-    let names: Vec<String> =
-        list.children().iter().filter(|c| c.is(b"Utf8")).filter_map(|c| c.bytes()).take(count).map(text).filter(|n| !n.is_empty()).collect();
+    let names: Vec<String> = list.children().filter(|c| c.is(b"Utf8")).filter_map(Node::bytes).take(count).map(text).filter(|n| !n.is_empty()).collect();
     if names.iter().any(|n| n.contains(|c: char| matches!(c, '/' | '\\' | ':') || c.is_control()) || n == "." || n == "..") {
         return Vec::new();
     }
@@ -240,9 +239,8 @@ impl<'f, 'a> Item<'f, 'a> {
         }
         let pin = self.chunk.child_list(b"Pin ")?;
         let sspc = pin.child(b"sspc")?.bytes()?;
-        let kids = pin.children();
-        let after = kids.iter().position(|c| c.is_list(b"Als2"))?;
-        let naming = || kids.iter().skip(after.saturating_add(1)).take_while(|c| !c.is(b"opti"));
+        let after = pin.children().position(|c| c.is_list(b"Als2"))?;
+        let naming = || pin.children().skip(after.saturating_add(1)).take_while(|c| !c.is(b"opti"));
         let (start, end, digits) = (be_u32(sspc, 172)?, be_u32(sspc, 176)?, be_u32(sspc, 180)?);
         // Force alphabetical order: the file list replaces the numbering.
         if let Some(list) = naming().find(|c| c.is_list(b"StVc")) {
@@ -252,7 +250,7 @@ impl<'f, 'a> Item<'f, 'a> {
             }
             return Some(SequenceInfo { prefix: String::new(), suffix: String::new(), start, end, digits, files });
         }
-        let names: Vec<String> = naming().filter(|c| c.is(b"Utf8")).filter_map(|c| c.bytes()).map(text).take(2).collect();
+        let names: Vec<String> = naming().filter(|c| c.is(b"Utf8")).filter_map(Node::bytes).map(text).take(2).collect();
         let (prefix, suffix) = match names.as_slice() {
             [prefix, suffix] => (prefix.clone(), suffix.clone()),
             // An empty prefix is not stored (`0001.png` has only `.png`).
diff --git a/crates/aep/src/container/index.rs b/crates/aep/src/container/index.rs
new file mode 100644
index 000000000..cb9621e94
--- /dev/null
+++ b/crates/aep/src/container/index.rs
@@ -0,0 +1,955 @@
+//! A read-only, flat index of the chunk tree for readers that only look (the importer).
+//!
+//! [`TreeIndex`] holds every chunk of a file in one `Vec` in depth-first order (a chunk, then its
+//! whole subtree, then its next sibling). Each entry keeps its id, list type, pad byte, the bytes of
+//! its body (borrowed from the input) and the index one past its subtree, so:
+//! - a chunk's subtree is the index range `at + 1 .. end`,
+//! - its direct children are found by stepping from `at + 1` to each child's `end`,
+//! - the whole tree is one array, grown a few times while it is built and freed at once; it never
+//!   holds more slots than the input has room for chunk headers or the chunk limit allows.
+//!
+//! [`crate::container::parse`] builds the owned [`Chunk`] tree instead (one `Vec` per list), which
+//! the exporter and editors need. [`TreeIndex::to_file`] and [`Node::to_chunk`] convert the index
+//! into that tree where an owned one is needed.
+//!
+//! [`TreeIndex::parse_with_limits`] walks the input exactly as the [`Chunk`] parser does: the same
+//! chunks are counted against [`Limits::max_chunks`] in the same order, the same lists are kept
+//! opaque at [`Limits::max_depth`] or when damaged, and the same errors come back. A test compares
+//! the two on the corpus and on generated and damaged trees. Two errors are its own, and both are
+//! stricter than the [`Chunk`] parser (which would abort or could not address the tree):
+//! [`AepError::TooLarge`] when the array cannot grow (a failed `try_reserve`), and
+//! [`AepError::TooManyChunks`] for a tree of more than `u32::MAX` chunks.
+//!
+//! [`Node`] is the handle the typed view ([`crate::container::Project`] and the types below it)
+//! reads through: a chunk of either tree. The view works the same on both.
+
+use std::borrow::Cow;
+use std::fmt;
+
+use crate::container::bytes::be_u32;
+use crate::container::chunk::{AepFile, Body, Chunk, LIST, NESTED_IDS, Walk};
+use crate::container::error::AepError;
+use crate::container::read::{Limits, container_end, id4};
+
+/// What an entry's body is (the [`Body`] variants).
+#[derive(Debug, Clone, Copy, PartialEq, Eq)]
+enum Kind {
+    Data,
+    /// [`Body::Chunks`].
+    Nested,
+    List,
+    OpaqueList,
+}
+
+/// One chunk of a [`TreeIndex`].
+#[derive(Debug, Clone, Copy)]
+struct Entry<'a> {
+    /// The body bytes of a data chunk, or the bytes after the list type of an opaque list; empty
+    /// for a list or nested chunk (their content is their children).
+    data: &'a [u8],
+    id: [u8; 4],
+    /// The list type of a `LIST` (parsed or opaque); zero otherwise.
+    list_type: [u8; 4],
+    /// One past the last entry of this chunk's subtree.
+    end: u32,
+    kind: Kind,
+    pad: Option<u8>,
+}
+
+impl<'a> Entry<'a> {
+    fn placeholder(id: [u8; 4]) -> Self {
+        Self { data: &[], id, list_type: [0; 4], end: 0, kind: Kind::Data, pad: None }
+    }
+}
+
+/// The chunk tree of a file as one flat, read-only array (see the module documentation).
+#[derive(Clone)]
+pub struct TreeIndex<'a> {
+    nodes: Vec<Entry<'a>>,
+    trailer: &'a [u8],
+}
+
+impl fmt::Debug for TreeIndex<'_> {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        f.debug_struct("TreeIndex").field("chunks", &self.nodes.len()).field("trailer", &self.trailer.len()).finish()
+    }
+}
+
+/// An index that does not fit a `u32` (more than 4 billion chunks) is refused as too many chunks.
+fn index_u32(at: usize) -> Result<u32, AepError> {
+    u32::try_from(at).map_err(|_| AepError::TooManyChunks)
+}
+
+impl<'a> TreeIndex<'a> {
+    /// Indexes an `.aep` with the default [`Limits`].
+    ///
+    /// # Errors
+    /// The errors of [`crate::container::parse`], for the same inputs.
+    pub fn parse(data: &'a [u8]) -> Result<Self, AepError> {
+        Self::parse_with_limits(data, Limits::default())
+    }
+
+    /// Indexes an `.aep` with explicit [`Limits`].
+    ///
+    /// # Errors
+    /// The errors of [`crate::container::parse_with_limits`], for the same inputs and limits; also
+    /// [`AepError::TooManyChunks`] for a tree of more than `u32::MAX` chunks and
+    /// [`AepError::TooLarge`] when the array cannot be allocated.
+    pub fn parse_with_limits(data: &'a [u8], limits: Limits) -> Result<Self, AepError> {
+        let end = container_end(data)?;
+        // Every chunk header takes 8 bytes of its own and is counted once, so the tree never has
+        // more chunks than this.
+        let bound = (end.saturating_sub(12) / 8).min(limits.max_chunks);
+        let mut builder = Builder { data, limits, count: 0, nodes: Vec::new(), bound };
+        // A small start; [`Builder::push`] doubles it as chunks arrive, never past the bound, so
+        // the array stays proportional to the chunk count (a file of a few large chunks gets a few
+        // slots, not one per 32 bytes). `try_reserve_exact` so it fails nothing here.
+        let _ = builder.nodes.try_reserve_exact(bound.min(INITIAL_SLOTS));
+        builder.sequence(12, end, 1)?;
+        let trailer = data.get(end..).unwrap_or(&[]);
+        Ok(Self { nodes: builder.nodes, trailer })
+    }
+
+    /// Indexes an already parsed (or built, or `.aepx`) chunk tree. The index borrows the file's
+    /// bytes.
+    ///
+    /// # Errors
+    /// [`AepError::TooManyChunks`] for a tree of more than `u32::MAX` chunks.
+    pub fn from_file(file: &'a AepFile<'_>) -> Result<Self, AepError> {
+        // Sized once, to the chunks the tree holds.
+        let mut nodes: Vec<Entry<'a>> = Vec::new();
+        nodes.try_reserve_exact(file.walk().count()).map_err(|_| AepError::TooLarge)?;
+        // Each frame: the siblings still to visit and the entry whose subtree they fill.
+        let mut stack: Vec<(std::slice::Iter<'a, Chunk<'_>>, Option<usize>)> = vec![(file.chunks.iter(), None)];
+        while let Some((iter, parent)) = stack.last_mut() {
+            let parent = *parent;
+            match iter.next() {
+                Some(chunk) => {
+                    let at = nodes.len();
+                    // The entry after this one must still have a `u32` index.
+                    let next = index_u32(at.checked_add(1).ok_or(AepError::TooManyChunks)?)?;
+                    let (kind, data, list_type) = match &chunk.body {
+                        Body::Data(d) => (Kind::Data, &d[..], [0; 4]),
+                        Body::Chunks(_) => (Kind::Nested, &[][..], [0; 4]),
+                        Body::List { list_type, .. } => (Kind::List, &[][..], *list_type),
+                        Body::OpaqueList { list_type, data } => (Kind::OpaqueList, &data[..], *list_type),
+                    };
+                    nodes.push(Entry { data, id: chunk.id, list_type, end: next, kind, pad: chunk.pad });
+                    let kids = chunk.children();
+                    if !kids.is_empty() {
+                        stack.push((kids.iter(), Some(at)));
+                    }
+                }
+                None => {
+                    stack.pop();
+                    if let Some(p) = parent {
+                        let end = index_u32(nodes.len())?;
+                        if let Some(e) = nodes.get_mut(p) {
+                            e.end = end;
+                        }
+                    }
+                }
+            }
+        }
+        Ok(Self { nodes, trailer: &file.trailer[..] })
+    }
+
+    /// The number of chunks in the tree (at every depth).
+    pub fn len(&self) -> usize {
+        self.nodes.len()
+    }
+
+    /// True when the container holds no chunks.
+    pub fn is_empty(&self) -> bool {
+        self.nodes.is_empty()
+    }
+
+    /// The bytes after the container's declared end (see [`AepFile::trailer`]).
+    pub fn trailer(&self) -> &'a [u8] {
+        self.trailer
+    }
+
+    /// The top-level chunks.
+    pub fn chunks(&self) -> Nodes<'_, 'a> {
+        Nodes(NodesRepr::Index { tree: self, next: 0, end: u32::try_from(self.nodes.len()).unwrap_or(u32::MAX) })
+    }
+
+    /// The first top-level chunk with this id.
+    pub fn chunk(&self, id: &[u8; 4]) -> Option<Node<'_, 'a>> {
+        self.chunks().find(|c| c.is(id))
+    }
+
+    /// The first top-level `LIST` of this type.
+    pub fn list(&self, list_type: &[u8; 4]) -> Option<Node<'_, 'a>> {
+        self.chunks().find(|c| c.is_list(list_type))
+    }
+
+    /// Visits every chunk depth-first with its nesting depth (the top level is 1), as
+    /// [`AepFile::walk`] does.
+    pub fn walk(&self) -> NodeWalk<'_, 'a> {
+        NodeWalk(WalkRepr::Index { tree: self, next: 0, end: u32::try_from(self.nodes.len()).unwrap_or(u32::MAX), open: Vec::new() })
+    }
+
+    /// The owned chunk tree (the bodies stay borrowed from the input): what
+    /// [`crate::container::parse`] gives for the same file.
+    pub fn to_file(&self) -> AepFile<'a> {
+        AepFile { chunks: self.build(0, u32::try_from(self.nodes.len()).unwrap_or(u32::MAX)), trailer: Cow::Borrowed(self.trailer) }
+    }
+
+    fn entry(&self, at: u32) -> Option<&Entry<'a>> {
+        self.nodes.get(usize::try_from(at).ok()?)
+    }
+
+    /// The end of the subtree at `at`; never before `at + 1`, so walks always move on.
+    fn end_of(&self, at: u32) -> u32 {
+        self.entry(at).map_or(u32::MAX, |e| e.end).max(at.saturating_add(1))
+    }
+
+    /// The owned chunks for the siblings that start at `next` and fill `next..end`, without
+    /// recursion.
+    fn build(&self, next: u32, end: u32) -> Vec<Chunk<'a>> {
+        struct Frame<'a> {
+            /// The list or nested chunk being filled; `None` for the outermost range.
+            at: Option<u32>,
+            kids: Vec<Chunk<'a>>,
+            next: u32,
+            end: u32,
+        }
+        let mut stack = vec![Frame { at: None, kids: Vec::new(), next, end }];
+        loop {
+            let Some(top) = stack.last_mut() else { return Vec::new() };
+            if top.next < top.end {
+                let at = top.next;
+                top.next = self.end_of(at);
+                let Some(e) = self.entry(at).copied() else {
+                    top.next = top.end;
+                    continue;
+                };
+                match e.kind {
+                    Kind::List | Kind::Nested => {
+                        let sub_end = self.end_of(at);
+                        stack.push(Frame { at: Some(at), kids: Vec::new(), next: at.saturating_add(1), end: sub_end });
+                    }
+                    Kind::Data => top.kids.push(Chunk { id: e.id, body: Body::Data(Cow::Borrowed(e.data)), pad: e.pad }),
+                    Kind::OpaqueList => {
+                        top.kids.push(Chunk { id: e.id, body: Body::OpaqueList { list_type: e.list_type, data: Cow::Borrowed(e.data) }, pad: e.pad });
+                    }
+                }
+            } else {
+                let Some(frame) = stack.pop() else { return Vec::new() };
+                let Some(at) = frame.at else { return frame.kids };
+                let Some(e) = self.entry(at).copied() else { continue };
+                let body = match e.kind {
+                    Kind::Nested => Body::Chunks(frame.kids),
+                    Kind::List | Kind::Data | Kind::OpaqueList => Body::List { list_type: e.list_type, children: frame.kids },
+                };
+                let chunk = Chunk { id: e.id, body, pad: e.pad };
+                match stack.last_mut() {
+                    Some(parent) => parent.kids.push(chunk),
+                    None => return vec![chunk],
+                }
+            }
+        }
+    }
+}
+
+/// The slots a [`TreeIndex`] starts with (32 KiB); it doubles from there.
+const INITIAL_SLOTS: usize = 1024;
+
+/// Builds a [`TreeIndex`]; mirrors `read::Parser` step for step (see the module documentation).
+struct Builder<'a> {
+    data: &'a [u8],
+    limits: Limits,
+    count: usize,
+    nodes: Vec<Entry<'a>>,
+    /// The most chunks the input can hold under the limits: `nodes` never reserves past it.
+    bound: usize,
+}
+
+impl<'a> Builder<'a> {
+    /// Appends an entry. A full array grows by its length (at least 16), but never past
+    /// [`Self::bound`]; an allocation the target cannot make is an error, not an abort.
+    fn push(&mut self, entry: Entry<'a>) -> Result<(), AepError> {
+        let len = self.nodes.len();
+        if len == self.nodes.capacity() {
+            let more = len.max(16).min(self.bound.saturating_sub(len)).max(1);
+            self.nodes.try_reserve_exact(more).map_err(|_| AepError::TooLarge)?;
+        }
+        self.nodes.push(entry);
+        Ok(())
+    }
+
+    /// Appends the sibling chunks that exactly fill `start..end`, each followed by its subtree.
+    fn sequence(&mut self, start: usize, end: usize, depth: usize) -> Result<(), AepError> {
+        let mut pos = start;
+        while pos < end {
+            let short = AepError::Malformed { offset: pos, what: "bytes left over that are too short for a chunk header" };
+            let body_start = pos.checked_add(8).filter(|b| *b <= end).ok_or(short)?;
+            let id = id4(self.data, pos).ok_or(AepError::Malformed { offset: pos, what: "short read" })?;
+            let size = be_u32(self.data, pos + 4).ok_or(AepError::Malformed { offset: pos, what: "short read" })? as usize;
+            let avail = end - body_start;
+            if size > avail {
+                return Err(AepError::ChunkTooLarge { offset: pos, size: size as u64, available: avail as u64 });
+            }
+            self.count = self.count.saturating_add(1);
+            if self.count > self.limits.max_chunks {
+                return Err(AepError::TooManyChunks);
+            }
+            let at = self.nodes.len();
+            // This entry and the one after it must have `u32` indices.
+            index_u32(at.checked_add(1).ok_or(AepError::TooManyChunks)?)?;
+            self.push(Entry::placeholder(id))?;
+            let body_end = body_start + size;
+            self.body(at, id, body_start, body_end, depth)?;
+            let mut next = body_end;
+            let mut pad = None;
+            if size % 2 == 1 && next < end {
+                pad = Some(self.data.get(next).copied().ok_or(AepError::Malformed { offset: next, what: "missing pad byte" })?);
+                next += 1;
+            }
+            let subtree_end = index_u32(self.nodes.len())?;
+            if let Some(e) = self.nodes.get_mut(at) {
+                e.pad = pad;
+                e.end = subtree_end;
+            }
+            pos = next;
+        }
+        Ok(())
+    }
+
+    /// Like [`Self::sequence`] but a structural problem yields `false` and removes what the
+    /// attempt appended (the caller keeps bytes). The chunk count keeps the attempt's chunks, as
+    /// the [`Chunk`] parser's does.
+    fn tentative(&mut self, start: usize, end: usize, depth: usize) -> Result<bool, AepError> {
+        let mark = self.nodes.len();
+        match self.sequence(start, end, depth) {
+            Ok(()) => Ok(true),
+            Err(e) if e.is_structural() => {
+                self.nodes.truncate(mark);
+                Ok(false)
+            }
+            Err(e) => Err(e),
+        }
+    }
+
+    fn slice(&self, start: usize, end: usize) -> &'a [u8] {
+        self.data.get(start..end).unwrap_or(&[])
+    }
+
+    fn set(&mut self, at: usize, kind: Kind, data: &'a [u8], list_type: [u8; 4]) {
+        if let Some(e) = self.nodes.get_mut(at) {
+            e.kind = kind;
+            e.data = data;
+            e.list_type = list_type;
+        }
+    }
+
+    /// Fills in the entry at `at` for the body `start..end` and appends its subtree.
+    fn body(&mut self, at: usize, id: [u8; 4], start: usize, end: usize, depth: usize) -> Result<(), AepError> {
+        let len = end - start;
+        if id == LIST && len >= 4 {
+            let list_type = id4(self.data, start).ok_or(AepError::Malformed { offset: start, what: "short read" })?;
+            if depth < self.limits.max_depth && self.tentative(start + 4, end, depth + 1)? {
+                self.set(at, Kind::List, &[], list_type);
+            } else {
+                let data = self.slice(start + 4, end);
+                self.set(at, Kind::OpaqueList, data, list_type);
+            }
+            return Ok(());
+        }
+        if NESTED_IDS.contains(&id) && len >= 8 && depth < self.limits.max_depth {
+            let mark = self.nodes.len();
+            if self.tentative(start, end, depth + 1)? && self.nodes.len() > mark {
+                self.set(at, Kind::Nested, &[], [0; 4]);
+                return Ok(());
+            }
+        }
+        let data = self.slice(start, end);
+        self.set(at, Kind::Data, data, [0; 4]);
+        Ok(())
+    }
+}
+
+/// A chunk of either tree: an owned [`Chunk`] or an entry of a [`TreeIndex`]. The typed view
+/// reads through it, so it works the same on both. Cheap to copy.
+#[derive(Clone, Copy)]
+pub struct Node<'f, 'a>(NodeRepr<'f, 'a>);
+
+#[derive(Clone, Copy)]
+enum NodeRepr<'f, 'a> {
+    Chunk(&'f Chunk<'a>),
+    Index(&'f TreeIndex<'a>, u32),
+}
+
+impl<'f, 'a> From<&'f Chunk<'a>> for Node<'f, 'a> {
+    fn from(chunk: &'f Chunk<'a>) -> Self {
+        Node(NodeRepr::Chunk(chunk))
+    }
+}
+
+/// Prints the chunk as [`Chunk`]'s `Debug` does, whichever tree it is in, without copying the
+/// subtree.
+impl fmt::Debug for Node<'_, '_> {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        match self.0 {
+            NodeRepr::Chunk(c) => fmt::Debug::fmt(c, f),
+            NodeRepr::Index(..) => f.debug_struct("Chunk").field("id", &self.id()).field("body", &BodyDebug(*self)).field("pad", &self.pad()).finish(),
+        }
+    }
+}
+
+/// The body of an index [`Node`], printed as [`Body`]'s `Debug` prints it.
+struct BodyDebug<'f, 'a>(Node<'f, 'a>);
+
+/// The children of a [`Node`], printed as a list.
+struct ChildrenDebug<'f, 'a>(Node<'f, 'a>);
+
+impl fmt::Debug for BodyDebug<'_, '_> {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        let Some(e) = self.0.entry() else { return f.write_str("?") };
+        match e.kind {
+            Kind::Data => f.debug_tuple("Data").field(&e.data).finish(),
+            Kind::Nested => f.debug_tuple("Chunks").field(&ChildrenDebug(self.0)).finish(),
+            Kind::List => f.debug_struct("List").field("list_type", &e.list_type).field("children", &ChildrenDebug(self.0)).finish(),
+            Kind::OpaqueList => f.debug_struct("OpaqueList").field("list_type", &e.list_type).field("data", &e.data).finish(),
+        }
+    }
+}
+
+impl fmt::Debug for ChildrenDebug<'_, '_> {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        f.debug_list().entries(self.0.children()).finish()
+    }
+}
+
+impl<'f, 'a> Node<'f, 'a> {
+    fn entry(self) -> Option<&'f Entry<'a>> {
+        match self.0 {
+            NodeRepr::Index(tree, at) => tree.entry(at),
+            NodeRepr::Chunk(_) => None,
+        }
+    }
+
+    /// The [`Chunk`] when this node is one of an owned tree; `None` for an index entry (see
+    /// [`Self::to_chunk`]).
+    pub fn as_chunk(self) -> Option<&'f Chunk<'a>> {
+        match self.0 {
+            NodeRepr::Chunk(c) => Some(c),
+            NodeRepr::Index(..) => None,
+        }
+    }
+
+    /// The chunk and its subtree as an owned [`Chunk`] (bodies stay borrowed).
+    pub fn to_chunk(self) -> Chunk<'a> {
+        match self.0 {
+            NodeRepr::Chunk(c) => c.clone(),
+            NodeRepr::Index(tree, at) => tree.build(at, tree.end_of(at)).into_iter().next().unwrap_or_else(|| Chunk::data(self.id(), &[][..])),
+        }
+    }
+
+    /// The 4-byte id (see [`Chunk::id`]).
+    pub fn id(self) -> [u8; 4] {
+        match self.0 {
+            NodeRepr::Chunk(c) => c.id,
+            NodeRepr::Index(..) => self.entry().map_or([0; 4], |e| e.id),
+        }
+    }
+
+    /// The pad byte (see [`Chunk::pad`]).
+    pub fn pad(self) -> Option<u8> {
+        match self.0 {
+            NodeRepr::Chunk(c) => c.pad,
+            NodeRepr::Index(..) => self.entry().and_then(|e| e.pad),
+        }
+    }
+
+    /// The raw bytes of a data chunk, or the bytes after the list type of an opaque list (see
+    /// [`Chunk::bytes`]).
+    pub fn bytes(self) -> Option<&'f [u8]> {
+        match self.0 {
+            NodeRepr::Chunk(c) => c.bytes(),
+            NodeRepr::Index(..) => self.entry().filter(|e| matches!(e.kind, Kind::Data | Kind::OpaqueList)).map(|e| e.data),
+        }
+    }
+
+    /// The child chunks of a list or nested chunk; none for data.
+    pub fn children(self) -> Nodes<'f, 'a> {
+        match self.0 {
+            NodeRepr::Chunk(c) => Nodes(NodesRepr::Slice(c.children().iter())),
+            NodeRepr::Index(tree, at) => {
+                let end = match tree.entry(at) {
+                    Some(e) if matches!(e.kind, Kind::List | Kind::Nested) => tree.end_of(at),
+                    _ => at.saturating_add(1),
+                };
+                Nodes(NodesRepr::Index { tree, next: at.saturating_add(1), end })
+            }
+        }
+    }
+
+    /// The list type when this is a `LIST` (parsed or opaque).
+    pub fn list_type(self) -> Option<[u8; 4]> {
+        match self.0 {
+            NodeRepr::Chunk(c) => c.list_type(),
+            NodeRepr::Index(..) => self.entry().filter(|e| matches!(e.kind, Kind::List | Kind::OpaqueList)).map(|e| e.list_type),
+        }
+    }
+
+    /// True when this is a `LIST` of the given type.
+    pub fn is_list(self, list_type: &[u8; 4]) -> bool {
+        match self.0 {
+            NodeRepr::Chunk(c) => c.is_list(list_type),
+            NodeRepr::Index(..) => self.entry().is_some_and(|e| e.id == LIST && matches!(e.kind, Kind::List | Kind::OpaqueList) && &e.list_type == list_type),
+        }
+    }
+
+    /// True when this is a `LIST` whose content could not be read as chunks.
+    pub fn is_opaque_list(self) -> bool {
+        match self.0 {
+            NodeRepr::Chunk(c) => c.is_opaque_list(),
+            NodeRepr::Index(..) => self.entry().is_some_and(|e| e.kind == Kind::OpaqueList),
+        }
+    }
+
+    /// True when this chunk has the given id.
+    pub fn is(self, id: &[u8; 4]) -> bool {
+        self.id() == *id
+    }
+
+    /// The first child chunk with this id.
+    pub fn child(self, id: &[u8; 4]) -> Option<Self> {
+        self.children().find(|c| c.is(id))
+    }
+
+    /// The first child `LIST` of this type.
+    pub fn child_list(self, list_type: &[u8; 4]) -> Option<Self> {
+        self.children().find(|c| c.is_list(list_type))
+    }
+
+    /// Every chunk below this one depth-first (children before later siblings), with the depth
+    /// counted from 1 for the children of this chunk.
+    pub fn descendants(self) -> NodeWalk<'f, 'a> {
+        match self.0 {
+            NodeRepr::Chunk(c) => NodeWalk(WalkRepr::Chunk(c.descendants())),
+            NodeRepr::Index(tree, at) => {
+                let end = match tree.entry(at) {
+                    Some(e) if matches!(e.kind, Kind::List | Kind::Nested) => tree.end_of(at),
+                    _ => at.saturating_add(1),
+                };
+                NodeWalk(WalkRepr::Index { tree, next: at.saturating_add(1), end, open: Vec::new() })
+            }
+        }
+    }
+
+    /// The first descendant `LIST` of this type, searching depth-first.
+    pub fn find_list(self, list_type: &[u8; 4]) -> Option<Self> {
+        match self.0 {
+            NodeRepr::Chunk(c) => c.find_list(list_type).map(Node::from),
+            // The subtree is a contiguous range in depth-first order: a plain scan.
+            NodeRepr::Index(tree, at) => {
+                let first = usize::try_from(at).ok()?.checked_add(1)?;
+                let end = usize::try_from(tree.end_of(at)).ok()?.min(tree.nodes.len());
+                let range = tree.nodes.get(first..end)?;
+                let i = range.iter().position(|e| e.id == LIST && matches!(e.kind, Kind::List | Kind::OpaqueList) && &e.list_type == list_type)?;
+                let found = u32::try_from(first.checked_add(i)?).ok()?;
+                Some(Node(NodeRepr::Index(tree, found)))
+            }
+        }
+    }
+}
+
+/// The children of a [`Node`] (or the top-level chunks of a [`TreeIndex`]), in file order.
+#[derive(Clone)]
+pub struct Nodes<'f, 'a>(NodesRepr<'f, 'a>);
+
+#[derive(Clone)]
+enum NodesRepr<'f, 'a> {
+    Slice(std::slice::Iter<'f, Chunk<'a>>),
+    Index { tree: &'f TreeIndex<'a>, next: u32, end: u32 },
+}
+
+impl<'f, 'a> Iterator for Nodes<'f, 'a> {
+    type Item = Node<'f, 'a>;
+
+    fn next(&mut self) -> Option<Self::Item> {
+        match &mut self.0 {
+            NodesRepr::Slice(it) => it.next().map(Node::from),
+            NodesRepr::Index { tree, next, end } => {
+                if *next >= *end {
+                    return None;
+                }
+                let (tree, at) = (*tree, *next);
+                tree.entry(at)?;
+                *next = tree.end_of(at);
+                Some(Node(NodeRepr::Index(tree, at)))
+            }
+        }
+    }
+}
+
+/// A depth-first walk over [`Node`]s with their depth; see [`Node::descendants`] and
+/// [`TreeIndex::walk`].
+pub struct NodeWalk<'f, 'a>(WalkRepr<'f, 'a>);
+
+enum WalkRepr<'f, 'a> {
+    Chunk(Walk<'f, 'a>),
+    /// `open` holds the subtree ends of the entries above the next one (its ancestors inside the
+    /// walked range); their count is the next entry's depth minus one.
+    Index {
+        tree: &'f TreeIndex<'a>,
+        next: u32,
+        end: u32,
+        open: Vec<u32>,
+    },
+}
+
+impl<'f, 'a> Iterator for NodeWalk<'f, 'a> {
+    type Item = (usize, Node<'f, 'a>);
+
+    fn next(&mut self) -> Option<Self::Item> {
+        match &mut self.0 {
+            WalkRepr::Chunk(w) => w.next().map(|(d, c)| (d, Node::from(c))),
+            WalkRepr::Index { tree, next, end, open } => {
+                if *next >= *end {
+                    return None;
+                }
+                let (tree, at) = (*tree, *next);
+                tree.entry(at)?;
+                while open.last().is_some_and(|e| *e <= at) {
+                    open.pop();
+                }
+                let depth = open.len().saturating_add(1);
+                let sub_end = tree.end_of(at);
+                if sub_end > at.saturating_add(1) {
+                    open.push(sub_end);
+                }
+                *next = at.saturating_add(1);
+                Some((depth, Node(NodeRepr::Index(tree, at))))
+            }
+        }
+    }
+}
+
+/// The top level of either tree: what the project settings and the version are read from.
+#[derive(Clone, Copy)]
+pub(crate) enum Root<'f, 'a> {
+    File(&'f AepFile<'a>),
+    Index(&'f TreeIndex<'a>),
+}
+
+impl<'f, 'a> From<&'f AepFile<'a>> for Root<'f, 'a> {
+    fn from(file: &'f AepFile<'a>) -> Self {
+        Root::File(file)
+    }
+}
+
+impl<'f, 'a> From<&'f TreeIndex<'a>> for Root<'f, 'a> {
+    fn from(index: &'f TreeIndex<'a>) -> Self {
+        Root::Index(index)
+    }
+}
+
+impl<'f, 'a> Root<'f, 'a> {
+    /// The top-level chunks.
+    pub(crate) fn chunks(self) -> Nodes<'f, 'a> {
+        match self {
+            Root::File(f) => Nodes(NodesRepr::Slice(f.chunks.iter())),
+            Root::Index(t) => t.chunks(),
+        }
+    }
+
+    /// The first top-level chunk with this id.
+    pub(crate) fn chunk(self, id: &[u8; 4]) -> Option<Node<'f, 'a>> {
+        self.chunks().find(|c| c.is(id))
+    }
+
+    /// The first top-level `LIST` of this type.
+    pub(crate) fn list(self, list_type: &[u8; 4]) -> Option<Node<'f, 'a>> {
+        self.chunks().find(|c| c.is_list(list_type))
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use crate::container::{parse_with_limits, write};
+
+    /// A tiny deterministic generator (xorshift64*), so the tests need no extra crate.
+    struct Rng(u64);
+
+    impl Rng {
+        fn next(&mut self) -> u64 {
+            let mut x = self.0;
+            x ^= x >> 12;
+            x ^= x << 25;
+            x ^= x >> 27;
+            self.0 = x;
+            x.wrapping_mul(0x2545_f491_4f6c_dd1d)
+        }
+
+        fn below(&mut self, n: u64) -> u64 {
+            if n == 0 { 0 } else { self.next() % n }
+        }
+    }
+
+    /// A random tree: lists, nested-id chunks holding a `Utf8`, data of odd and even sizes, opaque
+    /// lists, empty lists, deep chains.
+    fn tree(rng: &mut Rng, depth: usize, budget: &mut usize) -> Vec<Chunk<'static>> {
+        let n = rng.below(6);
+        let mut out = Vec::new();
+        for _ in 0..n {
+            if *budget == 0 {
+                break;
+            }
+            *budget -= 1;
+            let pick = rng.below(10);
+            let chunk = if depth < 12 && pick < 4 {
+                let types: [&[u8; 4]; 4] = [b"Fold", b"tdgp", b"tdbs", b"Layr"];
+                let t = *types[usize::try_from(rng.below(4)).expect("small")];
+                Chunk::list(t, tree(rng, depth + 1, budget))
+            } else if pick == 4 {
+                let ids: [&[u8; 4]; 3] = [b"tdsn", b"pdnm", b"fnam"];
+                let id = *ids[usize::try_from(rng.below(3)).expect("small")];
+                let text = vec![b'a'; usize::try_from(rng.below(5)).expect("small")];
+                Chunk { id, body: Body::Chunks(vec![Chunk::data(*b"Utf8", text)]), pad: None }
+            } else if pick == 5 {
+                let raw = vec![0x5a; usize::try_from(rng.below(9)).expect("small")];
+                Chunk { id: LIST, body: Body::OpaqueList { list_type: *b"btdk", data: raw.into() }, pad: None }
+            } else {
+                let ids: [&[u8; 4]; 4] = [b"cdat", b"tdmn", b"Utf8", b"idta"];
+                let id = *ids[usize::try_from(rng.below(4)).expect("small")];
+                Chunk::data(id, vec![u8::try_from(rng.below(256)).expect("byte"); usize::try_from(rng.below(13)).expect("small")])
+            };
+            out.push(chunk);
+        }
+        out
+    }
+
+    /// Both readers on the same bytes and limits: the same result, errors included; and the
+    /// index's walk visits the same chunks at the same depths as the tree's.
+    fn same(bytes: &[u8], limits: Limits) {
+        let old = parse_with_limits(bytes, limits);
+        let new = TreeIndex::parse_with_limits(bytes, limits);
+        match (&old, &new) {
+            (Ok(file), Ok(index)) => {
+                assert_eq!(&index.to_file(), file, "the index converts to the parsed tree");
+                let a: Vec<(usize, Chunk<'_>)> = file.walk().map(|(d, c)| (d, c.clone())).collect();
+                let b: Vec<(usize, Chunk<'_>)> = index.walk().map(|(d, n)| (d, n.to_chunk())).collect();
+                assert_eq!(a, b, "the walks agree");
+                assert_eq!(index.len(), a.len());
+                // Indexing the parsed tree gives the same index.
+                let again = TreeIndex::from_file(file).expect("index");
+                assert_eq!(again.to_file(), *file);
+            }
+            (Err(a), Err(b)) => assert_eq!(a, b, "the same error"),
+            _ => panic!("one reader failed: {:?} vs {:?}", old.as_ref().err(), new.as_ref().err()),
+        }
+    }
+
+    fn limits() -> [Limits; 5] {
+        [
+            Limits::default(),
+            Limits { max_depth: 1, max_chunks: 10_000_000 },
+            Limits { max_depth: 3, max_chunks: 10_000_000 },
+            Limits { max_depth: 64, max_chunks: 7 },
+            Limits { max_depth: 64, max_chunks: 40 },
+        ]
+    }
+
+    #[test]
+    fn the_index_matches_the_chunk_parser_on_generated_and_damaged_trees() {
+        let mut rng = Rng(0x9e37_79b9_7f4a_7c15);
+        for _ in 0..400 {
+            let mut budget = 120;
+            let chunks = tree(&mut rng, 0, &mut budget);
+            let file = AepFile { chunks, trailer: Cow::Borrowed(b"<?xpacket begin?>x<?xpacket end?>") };
+            let bytes = write(&file).expect("write");
+            for l in limits() {
+                same(&bytes, l);
+            }
+            // Damage: overwrite a few bytes past the container header (sizes, ids, list types).
+            for _ in 0..4 {
+                let mut bad = bytes.clone();
+                for _ in 0..1 + rng.below(3) {
+                    let at = 12 + usize::try_from(rng.below(u64::try_from(bad.len().saturating_sub(12)).expect("len"))).expect("index");
+                    if let Some(b) = bad.get_mut(at) {
+                        *b = u8::try_from(rng.below(256)).expect("byte");
+                    }
+                }
+                for l in limits() {
+                    same(&bad, l);
+                }
+            }
+            // Truncated inputs (the container size then no longer fits).
+            let cut = bytes.len().saturating_sub(usize::try_from(rng.below(8)).expect("small") + 1);
+            same(&bytes[..cut], Limits::default());
+        }
+    }
+
+    #[test]
+    fn header_errors_are_the_same() {
+        for bytes in [&b""[..], b"RIFX", b"RIFX\0\0\0\x04Egg", b"RIFX\0\0\0\x04Fnord", b"RIFX\0\0\0\x08Egg!", b"RIFX\0\0\0\x03Egg!", b"RIFF\0\0\0\x04Egg!"] {
+            same(bytes, Limits::default());
+        }
+    }
+
+    /// The typed accessors give the same answers through either tree.
+    #[test]
+    fn nodes_answer_alike_on_both_trees() {
+        let mut rng = Rng(42);
+        for _ in 0..100 {
+            let mut budget = 200;
+            let file = AepFile { chunks: tree(&mut rng, 0, &mut budget), trailer: Cow::Borrowed(&[]) };
+            let bytes = write(&file).expect("write");
+            let parsed = crate::container::parse(&bytes).expect("parse");
+            let index = TreeIndex::parse(&bytes).expect("index");
+            let a: Vec<Node<'_, '_>> = parsed.walk().map(|(_, c)| Node::from(c)).collect();
+            let b: Vec<Node<'_, '_>> = index.walk().map(|(_, n)| n).collect();
+            assert_eq!(a.len(), b.len());
+            for (x, y) in a.iter().zip(&b) {
+                assert_eq!((x.id(), x.pad(), x.bytes(), x.list_type(), x.is_opaque_list()), (y.id(), y.pad(), y.bytes(), y.list_type(), y.is_opaque_list()));
+                assert_eq!(x.children().map(Node::to_chunk).collect::<Vec<_>>(), y.children().map(Node::to_chunk).collect::<Vec<_>>());
+                for t in [b"Fold", b"tdgp", b"tdbs", b"Layr", b"btdk"] {
+                    assert_eq!(x.find_list(t).map(Node::to_chunk), y.find_list(t).map(Node::to_chunk));
+                    assert_eq!(x.child_list(t).map(Node::to_chunk), y.child_list(t).map(Node::to_chunk));
+                    assert_eq!(x.is_list(t), y.is_list(t));
+                }
+                for id in [b"cdat", b"Utf8", b"tdsn"] {
+                    assert_eq!(x.child(id).map(Node::to_chunk), y.child(id).map(Node::to_chunk));
+                }
+                let dx: Vec<(usize, Chunk<'_>)> = x.descendants().map(|(d, n)| (d, n.to_chunk())).collect();
+                let dy: Vec<(usize, Chunk<'_>)> = y.descendants().map(|(d, n)| (d, n.to_chunk())).collect();
+                assert_eq!(dx, dy);
+                assert_eq!(format!("{x:?}"), format!("{y:?}"));
+            }
+        }
+    }
+
+    #[test]
+    fn the_index_never_reserves_more_than_the_input_or_the_limit_allows() {
+        // 1000 empty headers: the most chunks the bytes can hold.
+        let mut data = b"RIFX\0\0\0\0Egg!".to_vec();
+        data.extend(std::iter::repeat_n(*b"abcd\0\0\0\0", 1000).flatten());
+        let declared = u32::try_from(data.len() - 8).expect("small");
+        data[4..8].copy_from_slice(&declared.to_be_bytes());
+        let index = TreeIndex::parse(&data).expect("index");
+        assert_eq!(index.len(), 1000);
+        // The start (1024 slots) is cut to what the input can hold.
+        assert!(index.nodes.capacity() <= 1000, "{} slots for at most 1000 headers", index.nodes.capacity());
+        // A short tail or a header that runs past the end does not raise the bound.
+        let mut big = data.clone();
+        big[16..20].copy_from_slice(&u32::MAX.to_be_bytes());
+        assert!(TreeIndex::parse(&big).is_err() && crate::container::parse(&big).is_err());
+        // Under a tighter limit the parse fails as the chunk parser does, and the guess never
+        // exceeds the limit.
+        let tight = Limits { max_depth: 64, max_chunks: 10 };
+        assert_eq!(TreeIndex::parse_with_limits(&data, tight).err(), Some(AepError::TooManyChunks));
+        let small = Limits { max_depth: 64, max_chunks: 1000 };
+        let index = TreeIndex::parse_with_limits(&data, small).expect("exactly at the limit");
+        assert_eq!(index.len(), 1000);
+        // A limit below what the input holds bounds the reservation: 100 chunks, never more slots.
+        let mut wide = b"RIFX\0\0\0\0Egg!".to_vec();
+        wide.extend_from_slice(b"LIST");
+        wide.extend_from_slice(&u32::try_from(4 + 8 * 99).expect("small").to_be_bytes());
+        wide.extend_from_slice(b"Fold");
+        wide.extend(std::iter::repeat_n(*b"abcd\0\0\0\0", 99).flatten());
+        let declared = u32::try_from(wide.len() - 8).expect("small");
+        wide[4..8].copy_from_slice(&declared.to_be_bytes());
+        let index = TreeIndex::parse_with_limits(&wide, Limits { max_depth: 64, max_chunks: 100 }).expect("100 chunks");
+        assert_eq!(index.len(), 100);
+        assert!(index.nodes.capacity() <= 100);
+        // `from_file` is sized exactly.
+        let file = crate::container::parse(&wide).expect("parse");
+        assert_eq!(TreeIndex::from_file(&file).expect("index").nodes.capacity(), 100);
+    }
+
+    /// A file of `n` data chunks of `size` bytes each.
+    fn flat(n: usize, size: usize) -> Vec<u8> {
+        let mut data = b"RIFX\0\0\0\0Egg!".to_vec();
+        for _ in 0..n {
+            data.extend_from_slice(b"cdat");
+            data.extend_from_slice(&u32::try_from(size).expect("small").to_be_bytes());
+            data.extend(std::iter::repeat_n(0u8, size));
+        }
+        let declared = u32::try_from(data.len() - 8).expect("small");
+        data[4..8].copy_from_slice(&declared.to_be_bytes());
+        data
+    }
+
+    #[test]
+    fn the_index_grows_with_the_chunk_count_not_the_byte_size() {
+        // 4 MB in 4 chunks: a few slots, not one per 32 bytes (that would be 131 072 slots, 4 MB).
+        let big = flat(4, 1 << 20);
+        let index = TreeIndex::parse(&big).expect("index");
+        assert_eq!(index.len(), 4);
+        assert!(index.nodes.capacity() <= INITIAL_SLOTS, "{} slots for 4 chunks", index.nodes.capacity());
+        // Many small chunks: at most twice the count (it doubles).
+        let many = flat(10_000, 2);
+        let index = TreeIndex::parse(&many).expect("index");
+        assert_eq!(index.len(), 10_000);
+        assert!(index.nodes.capacity() <= 2 * 10_000, "{} slots for 10 000 chunks", index.nodes.capacity());
+        same(&big, Limits::default());
+        same(&many, Limits::default());
+    }
+
+    /// `LIST Fold` around `inner`, followed by 6 bytes too short for a header, so the list's
+    /// sequence fails and the list is kept opaque.
+    fn broken_level(inner: &[u8]) -> Vec<u8> {
+        let mut body = b"Fold".to_vec();
+        body.extend_from_slice(inner);
+        body.extend_from_slice(&[0xee; 6]);
+        let mut out = b"LIST".to_vec();
+        out.extend_from_slice(&u32::try_from(body.len()).expect("small").to_be_bytes());
+        out.extend_from_slice(&body);
+        out
+    }
+
+    #[test]
+    fn failed_attempts_count_once_and_leave_nothing_behind() {
+        let mut wide = b"Fold".to_vec();
+        wide.extend(std::iter::repeat_n(*b"abcd\0\0\0\0", 1000).flatten());
+        let mut level = b"LIST".to_vec();
+        level.extend_from_slice(&u32::try_from(wide.len()).expect("small").to_be_bytes());
+        level.extend_from_slice(&wide);
+        for _ in 0..50 {
+            level = broken_level(&level);
+        }
+        let mut data = b"RIFX\0\0\0\0Egg!".to_vec();
+        data.extend_from_slice(&level);
+        let declared = u32::try_from(data.len() - 8).expect("small");
+        data[4..8].copy_from_slice(&declared.to_be_bytes());
+        let headers = 1 + 50 + 1000;
+        let index = TreeIndex::parse_with_limits(&data, Limits { max_depth: 64, max_chunks: headers }).expect("parse");
+        assert_eq!(TreeIndex::parse_with_limits(&data, Limits { max_depth: 64, max_chunks: headers - 1 }).err(), Some(AepError::TooManyChunks));
+        // Only the outermost list is left, opaque: every failed attempt was rolled back.
+        assert_eq!(index.len(), 1);
+        let top = index.chunks().next().expect("one top-level chunk");
+        assert!(top.is_opaque_list() && top.bytes().map(<[u8]>::len) == Some(level.len() - 12));
+        assert_eq!(write(&index.to_file()).expect("write"), data);
+        same(&data, Limits::default());
+    }
+
+    #[test]
+    fn depth_beyond_the_limit_stays_opaque_without_recursion_past_it() {
+        // 5000 nested lists: far deeper than the limit; everything below depth 64 stays bytes.
+        let mut level = b"LIST\0\0\0\x04tdgp".to_vec();
+        for _ in 0..5000 {
+            let mut out = b"LIST".to_vec();
+            out.extend_from_slice(&u32::try_from(level.len() + 4).expect("small").to_be_bytes());
+            out.extend_from_slice(b"tdgp");
+            out.extend_from_slice(&level);
+            level = out;
+        }
+        let mut data = b"RIFX\0\0\0\0Egg!".to_vec();
+        data.extend_from_slice(&level);
+        let declared = u32::try_from(data.len() - 8).expect("small");
+        data[4..8].copy_from_slice(&declared.to_be_bytes());
+        let index = TreeIndex::parse(&data).expect("parse");
+        assert_eq!(index.len(), 64);
+        assert_eq!(index.walk().map(|(d, _)| d).max(), Some(64));
+        assert!(index.walk().last().is_some_and(|(_, n)| n.is_opaque_list()));
+        same(&data, Limits::default());
+        // Converting and indexing a deep owned tree uses no recursion either.
+        let file = index.to_file();
+        assert_eq!(TreeIndex::from_file(&file).expect("index").len(), 64);
+    }
+}
diff --git a/crates/aep/src/container/masks.rs b/crates/aep/src/container/masks.rs
index 6246fc1f5..7f00c07eb 100644
--- a/crates/aep/src/container/masks.rs
+++ b/crates/aep/src/container/masks.rs
@@ -6,8 +6,8 @@
 //! property (`tdbs`, with a key list when animated) and `omks` with one `LIST shap` per keyframe (a
 //! single one when the path is static).
 
-use crate::container::Chunk;
 use crate::container::bytes::{be_f32, be_u32, until_nul};
+use crate::container::index::Node;
 use crate::container::typed::{KeyList, Layer, PropGroup, PropNode, Property};
 use crate::container::values::{Tracked, read};
 
@@ -93,8 +93,10 @@ pub struct ShapePath {
 }
 
 impl ShapePath {
-    /// Decodes a `LIST shap`; `None` when `shph` or the point list is malformed.
-    pub fn from_chunk(shap: &Chunk<'_>) -> Option<Self> {
+    /// Decodes a `LIST shap` (a [`Chunk`](crate::container::Chunk) or a [`Node`]); `None` when
+    /// `shph` or the point list is malformed.
+    pub fn from_chunk<'f, 'a: 'f>(shap: impl Into<Node<'f, 'a>>) -> Option<Self> {
+        let shap = shap.into();
         let shph = shap.child(b"shph")?.bytes()?;
         let bbox = [be_f32(shph, 4)?, be_f32(shph, 8)?, be_f32(shph, 12)?, be_f32(shph, 16)?];
         let closed_flag = *shph.get(20)?;
@@ -187,7 +189,7 @@ fn mask_from_atom(atom: &PropGroup<'_, '_>, mkif: Option<&[u8]>) -> Mask {
             }
         }
         if let Some(omks) = oms.child_list(b"omks") {
-            mask.shapes = omks.children().iter().filter(|c| c.is_list(b"shap")).filter_map(ShapePath::from_chunk).collect();
+            mask.shapes = omks.children().filter(|c| c.is_list(b"shap")).filter_map(ShapePath::from_chunk).collect();
         }
     }
     mask
@@ -236,7 +238,7 @@ impl<'f, 'a> Layer<'f, 'a> {
                     if let Some(PropNode::Other(oms)) = atom.get("ADBE Mask Shape") {
                         path = oms.child_list(b"tdbs").and_then(Property::from_chunk);
                         if let Some(omks) = oms.child_list(b"omks") {
-                            path_shapes = omks.children().iter().filter(|c| c.is_list(b"shap")).map(ShapePath::from_chunk).collect();
+                            path_shapes = omks.children().filter(|c| c.is_list(b"shap")).map(ShapePath::from_chunk).collect();
                         }
                     }
                     masks.push(MaskAtom { mask, atom, path, path_shapes });
diff --git a/crates/aep/src/container/read.rs b/crates/aep/src/container/read.rs
index 8c43d9314..a47d06684 100644
--- a/crates/aep/src/container/read.rs
+++ b/crates/aep/src/container/read.rs
@@ -37,6 +37,16 @@ pub fn parse(data: &[u8]) -> Result<AepFile<'_>, AepError> {
 /// # Errors
 /// See [`parse`]; also fails with [`AepError::TooManyChunks`].
 pub fn parse_with_limits(data: &[u8], limits: Limits) -> Result<AepFile<'_>, AepError> {
+    let end = container_end(data)?;
+    let mut parser = Parser { data, limits, count: 0 };
+    let chunks = parser.sequence(12, end, 1)?;
+    let trailer = data.get(end..).unwrap_or(&[]);
+    Ok(AepFile { chunks, trailer: Cow::Borrowed(trailer) })
+}
+
+/// Checks the `RIFX`/`Egg!` header and returns where the container ends (its chunks fill
+/// `12..end`; the trailer follows). Shared with [`crate::container::index::TreeIndex::parse`].
+pub(super) fn container_end(data: &[u8]) -> Result<usize, AepError> {
     if id4(data, 0) != Some(*b"RIFX") {
         return Err(AepError::NotRifx);
     }
@@ -50,14 +60,10 @@ pub fn parse_with_limits(data: &[u8], limits: Limits) -> Result<AepFile<'_>, Aep
         return Err(AepError::Truncated { declared, available });
     }
     // `declared <= available < data.len()`, so the end is inside the input.
-    let end = usize::try_from(declared).map_err(|_| AepError::TooLarge)?.checked_add(8).ok_or(AepError::TooLarge)?;
-    let mut parser = Parser { data, limits, count: 0 };
-    let chunks = parser.sequence(12, end, 1)?;
-    let trailer = data.get(end..).unwrap_or(&[]);
-    Ok(AepFile { chunks, trailer: Cow::Borrowed(trailer) })
+    usize::try_from(declared).map_err(|_| AepError::TooLarge)?.checked_add(8).ok_or(AepError::TooLarge)
 }
 
-fn id4(data: &[u8], at: usize) -> Option<[u8; 4]> {
+pub(super) fn id4(data: &[u8], at: usize) -> Option<[u8; 4]> {
     array::<4>(data, at)
 }
 
diff --git a/crates/aep/src/container/settings.rs b/crates/aep/src/container/settings.rs
index a39f09dff..3079d5c7d 100644
--- a/crates/aep/src/container/settings.rs
+++ b/crates/aep/src/container/settings.rs
@@ -5,6 +5,7 @@
 use crate::container::bytes::be_u32;
 use crate::container::chunk::AepFile;
 use crate::container::footage::json_string;
+use crate::container::index::{Node, Root, TreeIndex};
 
 /// The time display style (`nhed` byte 8, feet + frames byte 11, film type byte 13).
 #[derive(Debug, Clone, Copy, PartialEq, Eq)]
@@ -55,7 +56,16 @@ pub struct ProjectSettings {
 impl ProjectSettings {
     /// Reads the settings from the top-level chunks.
     pub fn read(file: &AepFile<'_>) -> ProjectSettings {
-        let nhed = file.chunk(b"nhed").and_then(|c| c.bytes());
+        Self::of(Root::from(file))
+    }
+
+    /// Reads the settings from the top-level chunks of an indexed file.
+    pub fn read_index(index: &TreeIndex<'_>) -> ProjectSettings {
+        Self::of(Root::from(index))
+    }
+
+    pub(crate) fn of(file: Root<'_, '_>) -> ProjectSettings {
+        let nhed = file.chunk(b"nhed").and_then(Node::bytes);
         let byte = |i: usize| nhed.and_then(|b| b.get(i).copied());
         let bits_per_channel = byte(15).and_then(|v| match v {
             0 => Some(8),
@@ -74,9 +84,9 @@ impl ProjectSettings {
             1 => Some(1),
             _ => None,
         });
-        let flag = |id: &[u8; 4]| file.chunk(id).and_then(|c| c.bytes()).and_then(|b| b.first().copied()) == Some(1);
-        let working_gamma_24 = file.chunk(b"dwga").and_then(|c| c.bytes()).and_then(|b| b.get(..4)).map(|b| b != [0, 0, 0, 0]);
-        let scene_compensation = file.chunk(b"acer").and_then(|c| c.bytes()).and_then(|b| b.first().copied()).map(|v| v != 0);
+        let flag = |id: &[u8; 4]| file.chunk(id).and_then(Node::bytes).and_then(|b| b.first().copied()) == Some(1);
+        let working_gamma_24 = file.chunk(b"dwga").and_then(Node::bytes).and_then(|b| b.get(..4)).map(|b| b != [0, 0, 0, 0]);
+        let scene_compensation = file.chunk(b"acer").and_then(Node::bytes).and_then(|b| b.first().copied()).map(|v| v != 0);
         ProjectSettings {
             bits_per_channel,
             working_space: working_space(file),
@@ -91,9 +101,10 @@ impl ProjectSettings {
 }
 
 /// The working space: the `Utf8` right after `PwCs`.
-fn working_space(file: &AepFile<'_>) -> Option<WorkingSpace> {
-    let at = file.chunks.iter().position(|c| c.is(b"PwCs"))?;
-    let json = file.chunks.get(at.checked_add(1)?).filter(|c| c.is(b"Utf8"))?.bytes()?;
+fn working_space(file: Root<'_, '_>) -> Option<WorkingSpace> {
+    let mut chunks = file.chunks();
+    chunks.find(|c| c.is(b"PwCs"))?;
+    let json = chunks.next().filter(|c| c.is(b"Utf8"))?.bytes()?;
     let trimmed: Vec<u8> = json.iter().copied().filter(|b| !b.is_ascii_whitespace() && *b != 0).collect();
     if trimmed == b"{}" {
         return Some(WorkingSpace::None);
diff --git a/crates/aep/src/container/shapes.rs b/crates/aep/src/container/shapes.rs
index 8aad83d3f..dee01bb22 100644
--- a/crates/aep/src/container/shapes.rs
+++ b/crates/aep/src/container/shapes.rs
@@ -140,7 +140,7 @@ fn number(group: &PropGroup<'_, '_>, name: &str) -> Option<Tracked<f64>> {
 fn paths_of(group: &PropGroup<'_, '_>) -> Vec<ShapePath> {
     let Some(PropNode::Other(oms)) = group.get("ADBE Vector Shape") else { return Vec::new() };
     let Some(omks) = oms.child_list(b"omks") else { return Vec::new() };
-    omks.children().iter().filter(|c| c.is_list(b"shap")).filter_map(ShapePath::from_chunk).collect()
+    omks.children().filter(|c| c.is_list(b"shap")).filter_map(ShapePath::from_chunk).collect()
 }
 
 fn item(match_name: String, group: &PropGroup<'_, '_>) -> ShapeItem {
diff --git a/crates/aep/src/container/textdoc.rs b/crates/aep/src/container/textdoc.rs
index 28e581909..2de5d8eb2 100644
--- a/crates/aep/src/container/textdoc.rs
+++ b/crates/aep/src/container/textdoc.rs
@@ -8,8 +8,8 @@
 use std::borrow::Cow;
 use std::sync::LazyLock;
 
-use crate::container::Chunk;
 use crate::container::bytes::{be_u32, text};
+use crate::container::index::Node;
 use crate::container::typed::{Comp, Layer, Property};
 
 /// How deep dictionaries and arrays may nest before the parser gives up.
@@ -1012,9 +1012,9 @@ impl<'f, 'a> Layer<'f, 'a> {
     /// `ADBE Text Properties` group, which is a direct child of the layer's root `tdgp`
     /// (`Layr/tdgp/tdgp/btds` in every sample, and where the exporter writes it), so only that
     /// level is searched rather than the whole layer.
-    fn source_text_record(&self) -> Option<&'f Chunk<'a>> {
+    fn source_text_record(&self) -> Option<Node<'f, 'a>> {
         let root = self.chunk.child_list(b"tdgp")?;
-        root.children().iter().filter(|g| g.is_list(b"tdgp")).find_map(|g| g.child_list(b"btds"))
+        root.children().filter(|g| g.is_list(b"tdgp")).find_map(|g| g.child_list(b"btds"))
     }
 
     /// The text document of a text layer: the first `LIST btdk` in the Source Text record `btds`
@@ -1078,13 +1078,13 @@ pub enum CueType {
     Other(u32),
 }
 
-impl<'a> Chunk<'a> {
+impl<'f, 'a> Node<'f, 'a> {
     /// The marker list `LIST mrst` of a marker holder: a layer (`LIST Layr`) or a composition's
     /// `SecL` list. A layer's `mrst` is a direct child of its root `tdgp` (`ADBE Marker`, where
     /// After Effects and the exporter write it), so only that place is looked at; most layers have
     /// none, and searching their whole property tree for it was a large part of an import. Any
     /// other holder is searched depth-first.
-    pub(crate) fn marker_list(&self) -> Option<&Chunk<'a>> {
+    pub(crate) fn marker_list(self) -> Option<Node<'f, 'a>> {
         if self.is_list(b"Layr") {
             return self.child_list(b"tdgp")?.child_list(b"mrst");
         }
@@ -1094,7 +1094,7 @@ impl<'a> Chunk<'a> {
 
 /// Reads the markers below `holder` (a layer or the composition's `SecL` list): the `mrst` list has a
 /// property whose 16-byte records give the times and one `Nmrd` list per marker with the strings.
-fn markers_in(holder: &Chunk<'_>) -> Vec<Marker> {
+fn markers_in(holder: Node<'_, '_>) -> Vec<Marker> {
     let Some(mrst) = holder.marker_list() else { return Vec::new() };
     let Some(prop) = mrst.child_list(b"tdbs").and_then(Property::from_chunk) else { return Vec::new() };
     let Some(keys) = prop.keys() else { return Vec::new() };
@@ -1105,11 +1105,11 @@ fn markers_in(holder: &Chunk<'_>) -> Vec<Marker> {
         .filter_map(|(k, nmrd)| {
             let time_units = k.time_units()?;
             // The five strings, in the order comment, chapter, URL, frame target, cue point name.
-            let mut strings = nmrd.children().iter().filter(|c| c.is(b"Utf8")).map(|c| c.bytes().map(text).unwrap_or_default());
+            let mut strings = nmrd.children().filter(|c| c.is(b"Utf8")).map(|c| c.bytes().map(text).unwrap_or_default());
             let mut next = || strings.next().unwrap_or_default();
             let (comment, chapter, url, frame_target, cue_point_name) = (next(), next(), next(), next(), next());
             let extras: Vec<String> = strings.collect();
-            let header = nmrd.child(b"NmHd").and_then(Chunk::bytes);
+            let header = nmrd.child(b"NmHd").and_then(Node::bytes);
             let duration_seconds = header.and_then(|h| {
                 let (duration, per_second) = (be_u32(h, 8)?, be_u32(h, 12)?);
                 (per_second != 0).then(|| f64::from(duration) / f64::from(per_second))
@@ -1432,6 +1432,7 @@ mod oracle {
 #[cfg(test)]
 mod tests {
     use super::*;
+    use crate::container::Chunk;
 
     fn list(t: &[u8; 4], kids: Vec<Chunk<'static>>) -> Chunk<'static> {
         Chunk::list(*t, kids)
@@ -1725,15 +1726,15 @@ mod tests {
         let marked = |tag: u8| list(b"mrst", vec![Chunk::data(*b"test", vec![tag])]);
         // The stored place: `Layr/tdgp/mrst`.
         let layer = list(b"Layr", vec![list(b"tdgp", vec![list(b"tdgp", vec![]), marked(1)])]);
-        assert_eq!(layer.marker_list().and_then(|m| m.child(b"test")).and_then(Chunk::bytes), Some(&[1u8][..]));
+        assert_eq!(Node::from(&layer).marker_list().and_then(|m| m.child(b"test")).and_then(Node::bytes), Some(&[1u8][..]));
         // A list deeper in the layer is not the layer's marker list (the old depth-first search
         // found it); a layer without a marker list in its root group has no markers.
         let deep = list(b"Layr", vec![list(b"tdgp", vec![list(b"tdgp", vec![marked(2)])])]);
-        assert!(deep.marker_list().is_none());
-        assert!(Layer { chunk: &deep }.markers().is_empty());
+        assert!(Node::from(&deep).marker_list().is_none());
+        assert!(Layer { chunk: Node::from(&deep) }.markers().is_empty());
         // Any other holder (a composition's `SecL`) is still searched depth-first.
         let secl = list(b"SecL", vec![list(b"tdgp", vec![list(b"tdgp", vec![marked(3)])])]);
-        assert_eq!(secl.marker_list().and_then(|m| m.child(b"test")).and_then(Chunk::bytes), Some(&[3u8][..]));
+        assert_eq!(Node::from(&secl).marker_list().and_then(|m| m.child(b"test")).and_then(Node::bytes), Some(&[3u8][..]));
     }
 
     #[test]
@@ -1743,13 +1744,13 @@ mod tests {
         let btdk = || Chunk { id: *b"LIST", body: crate::container::Body::OpaqueList { list_type: *b"btdk", data: doc.to_vec().into() }, pad: None };
         let btds_real = |n: usize| list(b"btds", std::iter::once(list(b"tdbs", vec![])).chain((0..n).map(|_| btdk())).collect());
         let layer = list(b"Layr", vec![list(b"tdgp", vec![list(b"tdgp", vec![]), list(b"tdgp", vec![btds_real(2)])])]);
-        let view = Layer { chunk: &layer };
+        let view = Layer { chunk: Node::from(&layer) };
         assert_eq!(view.text_document().map(|d| d.text), Some("H".to_string()));
         assert!(view.source_text_property().is_some());
         assert_eq!(view.text_document_count(), 2);
         // A record anywhere else in the layer is not its Source Text.
         let elsewhere = list(b"Layr", vec![list(b"tdgp", vec![list(b"tdgp", vec![list(b"tdgp", vec![btds_real(1)])])])]);
-        let view = Layer { chunk: &elsewhere };
+        let view = Layer { chunk: Node::from(&elsewhere) };
         assert!(view.text_document().is_none() && view.source_text_property().is_none());
         assert_eq!(view.text_document_count(), 0);
     }
diff --git a/crates/aep/src/container/typed.rs b/crates/aep/src/container/typed.rs
index 592a074d5..8cd35aced 100644
--- a/crates/aep/src/container/typed.rs
+++ b/crates/aep/src/container/typed.rs
@@ -4,42 +4,56 @@
 //!
 //! Only facts that were established from our own one-change-per-file corpus and are checked by
 //! tests against it are decoded (see `docs/aep-format.md` for the evidence). Everything else
-//! stays reachable through the raw [`Chunk`] tree. Views borrow the file and never fail loudly:
-//! a chunk that does not have the expected shape yields `None` or is skipped.
+//! stays reachable through the raw chunk tree ([`Node`]). Views borrow the file and never fail
+//! loudly: a chunk that does not have the expected shape yields `None` or is skipped.
+//!
+//! A view reads either tree: the owned [`Chunk`](crate::container::Chunk) tree
+//! ([`Project::new`]) or the flat [`TreeIndex`] the importer builds ([`Project::from_index`]);
+//! both give the same answers.
 
 use crate::container::bytes::{be_f64, be_u16, be_u32, text, until_nul};
-use crate::container::chunk::{AepFile, Chunk};
+use crate::container::chunk::AepFile;
+use crate::container::index::{Node, Root, TreeIndex};
 
 /// The name a user gave a property or group: the `Utf8` inside its `tdsn` chunk. `None` for the
 /// sentinel `-_0_/-` ("no custom name") and for empty names.
-pub(crate) fn user_name(chunk: &Chunk<'_>) -> Option<String> {
-    let name = chunk.child(b"tdsn")?.children().iter().find(|c| c.is(b"Utf8"))?.bytes().map(text)?;
+pub(crate) fn user_name(chunk: Node<'_, '_>) -> Option<String> {
+    let name = chunk.child(b"tdsn")?.child(b"Utf8")?.bytes().map(text)?;
     (!name.is_empty() && name != "-_0_/-").then_some(name)
 }
 
 /// The content of a `Utf8` child as text (not trimmed).
-pub(crate) fn utf8_child(chunk: &Chunk<'_>) -> Option<String> {
-    chunk.child(b"Utf8").and_then(Chunk::bytes).map(text)
+pub(crate) fn utf8_child(chunk: Node<'_, '_>) -> Option<String> {
+    chunk.child(b"Utf8").and_then(Node::bytes).map(text)
 }
 
 /// The project: the top-level `LIST Fold`, which holds the project items.
 #[derive(Debug, Clone, Copy)]
 pub struct Project<'f, 'a> {
-    pub(crate) fold: &'f Chunk<'a>,
+    pub(crate) fold: Node<'f, 'a>,
     /// The top-level `LIST EfdG` (project-level effect definitions), when there is one.
-    pub(crate) effect_defs: Option<&'f Chunk<'a>>,
+    pub(crate) effect_defs: Option<Node<'f, 'a>>,
 }
 
 impl<'f, 'a> Project<'f, 'a> {
     /// The project view of a file, or `None` when it has no `LIST Fold`.
     pub fn new(file: &'f AepFile<'a>) -> Option<Self> {
-        file.list(b"Fold").map(|fold| Self { fold, effect_defs: file.list(b"EfdG") })
+        Self::of(Root::from(file))
+    }
+
+    /// The project view of an indexed file ([`TreeIndex`]), or `None` when it has no `LIST Fold`.
+    pub fn from_index(index: &'f TreeIndex<'a>) -> Option<Self> {
+        Self::of(Root::from(index))
+    }
+
+    pub(crate) fn of(root: Root<'f, 'a>) -> Option<Self> {
+        root.list(b"Fold").map(|fold| Self { fold, effect_defs: root.list(b"EfdG") })
     }
 
     /// The top-level items (the project panel's root; folders hold their children, see
     /// [`Item::children`]).
     pub fn items(&self) -> impl Iterator<Item = Item<'f, 'a>> + 'f {
-        self.fold.children().iter().filter(|c| c.is_list(b"Item")).map(|chunk| Item { chunk })
+        self.fold.children().filter(|c| c.is_list(b"Item")).map(|chunk| Item { chunk })
     }
 
     /// True when the `LIST Fold` could not be read as chunks (damaged): its items cannot be seen.
@@ -78,12 +92,12 @@ pub enum ItemKind {
 /// A project item (`LIST Item`).
 #[derive(Debug, Clone, Copy)]
 pub struct Item<'f, 'a> {
-    pub(crate) chunk: &'f Chunk<'a>,
+    pub(crate) chunk: Node<'f, 'a>,
 }
 
 impl<'f, 'a> Item<'f, 'a> {
     /// The underlying chunk.
-    pub fn chunk(&self) -> &'f Chunk<'a> {
+    pub fn chunk(&self) -> Node<'f, 'a> {
         self.chunk
     }
 
@@ -106,7 +120,7 @@ impl<'f, 'a> Item<'f, 'a> {
 
     /// The items inside a folder (`LIST Sfdr`).
     pub fn children(&self) -> impl Iterator<Item = Item<'f, 'a>> + 'f {
-        self.chunk.child_list(b"Sfdr").into_iter().flat_map(|sfdr| sfdr.children().iter()).filter(|c| c.is_list(b"Item")).map(|chunk| Item { chunk })
+        self.chunk.child_list(b"Sfdr").into_iter().flat_map(Node::children).filter(|c| c.is_list(b"Item")).map(|chunk| Item { chunk })
     }
 
     /// Whether the item has the `LIST Sfdr` of a folder's contents (After Effects writes an empty
@@ -117,7 +131,7 @@ impl<'f, 'a> Item<'f, 'a> {
 
     /// True when the folder's `LIST Sfdr` is there but could not be read as chunks (damaged).
     pub fn folder_contents_unreadable(&self) -> bool {
-        self.chunk.child_list(b"Sfdr").is_some_and(Chunk::is_opaque_list)
+        self.chunk.child_list(b"Sfdr").is_some_and(Node::is_opaque_list)
     }
 
     /// The composition view when this item has composition data (`cdta`).
@@ -158,7 +172,7 @@ impl TimeBase {
 /// A composition item (an [`Item`] with `cdta`).
 #[derive(Debug, Clone, Copy)]
 pub struct Comp<'f, 'a> {
-    pub(crate) item: &'f Chunk<'a>,
+    pub(crate) item: Node<'f, 'a>,
 }
 
 impl<'f, 'a> Comp<'f, 'a> {
@@ -172,19 +186,19 @@ impl<'f, 'a> Comp<'f, 'a> {
     /// The layers, top layer first (`LIST Layr`; the `DLay`/`SLay`/`CLay`/`SecL` lists next to
     /// them are not layers).
     pub fn layers(&self) -> impl Iterator<Item = Layer<'f, 'a>> + 'f {
-        self.item.children().iter().filter(|c| c.is_list(b"Layr")).map(|chunk| Layer { chunk })
+        self.item.children().filter(|c| c.is_list(b"Layr")).map(|chunk| Layer { chunk })
     }
 }
 
 /// A layer (`LIST Layr`).
 #[derive(Debug, Clone, Copy)]
 pub struct Layer<'f, 'a> {
-    pub(crate) chunk: &'f Chunk<'a>,
+    pub(crate) chunk: Node<'f, 'a>,
 }
 
 impl<'f, 'a> Layer<'f, 'a> {
     /// The underlying chunk.
-    pub fn chunk(&self) -> &'f Chunk<'a> {
+    pub fn chunk(&self) -> Node<'f, 'a> {
         self.chunk
     }
 
@@ -214,12 +228,12 @@ pub enum PropNode<'f, 'a> {
     /// A property (`LIST tdbs`).
     Property(Property<'f, 'a>),
     /// Any other list that follows a match name (observed: `otst`, the effect instance `sspc`).
-    Other(&'f Chunk<'a>),
+    Other(Node<'f, 'a>),
 }
 
 impl<'f, 'a> PropNode<'f, 'a> {
     /// The node a `LIST` after a match name is.
-    fn of(c: &'f Chunk<'a>) -> Self {
+    fn of(c: Node<'f, 'a>) -> Self {
         if c.is_list(b"tdgp") {
             PropNode::Group(PropGroup { chunk: c })
         } else if c.is_list(b"tdbs") {
@@ -242,17 +256,18 @@ pub struct PropEntry<'f, 'a> {
 /// `ADBE Group End` closes the group and names nothing.
 #[derive(Debug, Clone, Copy)]
 pub struct PropGroup<'f, 'a> {
-    pub(crate) chunk: &'f Chunk<'a>,
+    pub(crate) chunk: Node<'f, 'a>,
 }
 
 impl<'f, 'a> PropGroup<'f, 'a> {
-    /// A group view of a `LIST tdgp` chunk.
-    pub fn from_chunk(chunk: &'f Chunk<'a>) -> Option<Self> {
+    /// A group view of a `LIST tdgp` chunk (a [`Chunk`](crate::container::Chunk) or a [`Node`]).
+    pub fn from_chunk(chunk: impl Into<Node<'f, 'a>>) -> Option<Self> {
+        let chunk = chunk.into();
         chunk.is_list(b"tdgp").then_some(Self { chunk })
     }
 
     /// The underlying chunk.
-    pub fn chunk(&self) -> &'f Chunk<'a> {
+    pub fn chunk(&self) -> Node<'f, 'a> {
         self.chunk
     }
 
@@ -273,7 +288,7 @@ impl<'f, 'a> PropGroup<'f, 'a> {
         for c in self.chunk.children() {
             if c.is(b"tdmn") {
                 pending = c.bytes().map(match_name);
-            } else if c.id == crate::container::chunk::LIST
+            } else if c.is(&crate::container::chunk::LIST)
                 && let Some(name) = pending.take()
             {
                 out.push(PropEntry { match_name: name, node: PropNode::of(c) });
@@ -294,7 +309,7 @@ impl<'f, 'a> PropGroup<'f, 'a> {
         for c in self.chunk.children() {
             if c.is(b"tdmn") {
                 pending = c.bytes();
-            } else if c.id == crate::container::chunk::LIST
+            } else if c.is(&crate::container::chunk::LIST)
                 && let Some(body) = pending.take()
                 && match_name_is(body, name)
             {
@@ -335,17 +350,18 @@ fn match_name_is(body: &[u8], name: &str) -> bool {
 /// value `cdat` or a keyframe `LIST list`.
 #[derive(Debug, Clone, Copy)]
 pub struct Property<'f, 'a> {
-    pub(crate) chunk: &'f Chunk<'a>,
+    pub(crate) chunk: Node<'f, 'a>,
 }
 
 impl<'f, 'a> Property<'f, 'a> {
-    /// A property view of a `LIST tdbs` chunk.
-    pub fn from_chunk(chunk: &'f Chunk<'a>) -> Option<Self> {
+    /// A property view of a `LIST tdbs` chunk (a [`Chunk`](crate::container::Chunk) or a [`Node`]).
+    pub fn from_chunk(chunk: impl Into<Node<'f, 'a>>) -> Option<Self> {
+        let chunk = chunk.into();
         chunk.is_list(b"tdbs").then_some(Self { chunk })
     }
 
     /// The underlying chunk.
-    pub fn chunk(&self) -> &'f Chunk<'a> {
+    pub fn chunk(&self) -> Node<'f, 'a> {
         self.chunk
     }
 
@@ -453,12 +469,13 @@ pub struct KeyLayout {
 impl<'f> KeyList<'f> {
     /// A view of a `LIST list` chunk. `None` when `lhd3` is not 52 bytes or `ldat` is not exactly
     /// `count * record_size` bytes (a list without `ldat` must have no records).
-    pub fn from_chunk<'a>(chunk: &'f Chunk<'a>) -> Option<Self> {
+    pub fn from_chunk<'a: 'f>(chunk: impl Into<Node<'f, 'a>>) -> Option<Self> {
+        let chunk = chunk.into();
         if !chunk.is_list(b"list") {
             return None;
         }
         let header = ListHeader::parse(chunk.child(b"lhd3")?.bytes()?)?;
-        let ldat: &[u8] = chunk.child(b"ldat").and_then(Chunk::bytes).unwrap_or(&[]);
+        let ldat: &[u8] = chunk.child(b"ldat").and_then(Node::bytes).unwrap_or(&[]);
         let expected = usize::try_from(header.count).ok()?.checked_mul(usize::try_from(header.record_size).ok()?)?;
         (ldat.len() == expected).then_some(Self { header, ldat, layout: None })
     }
@@ -517,6 +534,7 @@ impl<'f> Keyframe<'f> {
 #[cfg(test)]
 mod tests {
     use super::*;
+    use crate::container::Chunk;
 
     fn key_list(count: u32, record_size: u32, ldat: &[u8]) -> Chunk<'static> {
         let mut lhd3 = vec![0u8; 52];
diff --git a/crates/aep/src/container/values.rs b/crates/aep/src/container/values.rs
index 4a001ee1e..ddd5caa75 100644
--- a/crates/aep/src/container/values.rs
+++ b/crates/aep/src/container/values.rs
@@ -223,7 +223,6 @@ impl<'f, 'a> Layer<'f, 'a> {
             .child_list(b"otky")
             .map(|k| {
                 k.children()
-                    .iter()
                     .filter(|c| c.is(b"otda"))
                     .map(|c| {
                         let b = c.bytes()?;
diff --git a/crates/aep/src/container/version.rs b/crates/aep/src/container/version.rs
index 1c859cdac..407c7046c 100644
--- a/crates/aep/src/container/version.rs
+++ b/crates/aep/src/container/version.rs
@@ -10,6 +10,7 @@ use std::fmt;
 
 use crate::container::bytes::be_u32;
 use crate::container::chunk::AepFile;
+use crate::container::index::{Root, TreeIndex};
 
 /// An After Effects version as packed in `head` / `svap`: `26.2.1x2` is major 26, minor 2, bug-fix
 /// 1, build 2 (the form of the scripting API's `app.version`).
@@ -71,13 +72,35 @@ impl AepFile<'_> {
     /// version there, and the older version for File ▸ Save a Copy As 25.x / 24.x. `None` when the
     /// chunk is missing, short or holds no version.
     pub fn file_version(&self) -> Option<AeVersion> {
-        AeVersion::from_word(be_u32(self.chunk(b"head")?.bytes()?, 4)?)
+        Root::from(self).file_version()
     }
 
     /// The version of the After Effects that wrote the file: `svap` bytes 0 to 3 (the same word in a
     /// down-saved copy as in a normal save). `None` when the chunk is missing (After Effects opens such
     /// a file), short or holds no version.
     pub fn saved_by_version(&self) -> Option<AeVersion> {
+        Root::from(self).saved_by_version()
+    }
+}
+
+impl TreeIndex<'_> {
+    /// [`AepFile::file_version`] of the indexed file.
+    pub fn file_version(&self) -> Option<AeVersion> {
+        Root::from(self).file_version()
+    }
+
+    /// [`AepFile::saved_by_version`] of the indexed file.
+    pub fn saved_by_version(&self) -> Option<AeVersion> {
+        Root::from(self).saved_by_version()
+    }
+}
+
+impl Root<'_, '_> {
+    pub(crate) fn file_version(self) -> Option<AeVersion> {
+        AeVersion::from_word(be_u32(self.chunk(b"head")?.bytes()?, 4)?)
+    }
+
+    pub(crate) fn saved_by_version(self) -> Option<AeVersion> {
         AeVersion::from_word(be_u32(self.chunk(b"svap")?.bytes()?, 0)?)
     }
 }
diff --git a/crates/aep/src/import.rs b/crates/aep/src/import.rs
index 956e3b1c5..8662e182c 100644
--- a/crates/aep/src/import.rs
+++ b/crates/aep/src/import.rs
@@ -40,6 +40,8 @@ mod time;
 
 use effectcraft_project::{ItemId, Project, ProjectSettings};
 
+use crate::container::index::{Root, TreeIndex};
+
 pub use effects::supported_effects;
 pub use report::{AeVersionInfo, ImportReport, Imported, LIMITATIONS, Loss, LossCategory, MAX_DETAILS, TESTED_MAJORS, UNKNOWN};
 
@@ -113,17 +115,29 @@ pub struct ImportResult {
 /// [`AepImportError::Refused`] when something would be lost and `allow_losses` is not set. On any
 /// error `project` is unchanged.
 pub fn import(project: &mut Project, bytes: &[u8], options: &ImportOptions<'_>) -> Result<ImportResult, AepImportError> {
-    let file = crate::parse_any(bytes)?;
-    let view = crate::Project::new(&file).ok_or(AepImportError::NoProject)?;
+    // The importer only reads: an `.aep` is indexed in place (one flat array that borrows the
+    // bytes); an `.aepx` is read into the chunk tree, which the view reads directly.
+    if crate::is_aepx(bytes) {
+        let file = crate::read_aepx(bytes)?;
+        import_root(project, Root::from(&file), options)
+    } else {
+        let index = TreeIndex::parse(bytes)?;
+        import_root(project, Root::from(&index), options)
+    }
+}
+
+/// [`import`] of a file read into either tree.
+fn import_root(project: &mut Project, file: Root<'_, '_>, options: &ImportOptions<'_>) -> Result<ImportResult, AepImportError> {
+    let view = crate::Project::of(file).ok_or(AepImportError::NoProject)?;
     // Work on a copy so a refusal leaves the project untouched (compositions are shared, cheap).
     let mut work = project.clone();
     let (folder, comps, items, mut report) = build::run(&mut work, &view, options);
-    report.ae_version = report::AeVersionInfo::of(&file);
+    report.ae_version = report::AeVersionInfo::of_root(file);
     if let Some(line) = report.ae_version.limitation() {
         report.limitations.push(line);
     }
     let mut col = report::Collector::default();
-    let settings = settings::map(&file, &work.settings, &mut col);
+    let settings = settings::map(file, &work.settings, &mut col);
     for loss in col.finish().losses.into_iter().filter(|_| options.settings) {
         let at = report.losses.iter().position(|l| l.category > loss.category).unwrap_or(report.losses.len());
         report.losses.insert(at, loss);
@@ -155,3 +169,74 @@ pub fn analyze_with(bytes: &[u8], options: &ImportOptions<'_>) -> Result<ImportR
     let options = ImportOptions { allow_losses: true, ..*options };
     Ok(import(&mut scratch, bytes, &options)?.report)
 }
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use crate::container::{AepFile, Body, Chunk, parse, write};
+
+    /// Imports `bytes` through the owned chunk tree and through the index: the same project, report
+    /// and settings, or the same error.
+    fn both(bytes: &[u8], name: &str) {
+        let exists = |_: &str| true;
+        let options = ImportOptions { allow_losses: true, ..ImportOptions::new(&exists) };
+        match (parse(bytes), TreeIndex::parse(bytes)) {
+            (Ok(file), Ok(index)) => {
+                let a = import_root(&mut Project::default(), Root::from(&file), &options);
+                let b = import_root(&mut Project::default(), Root::from(&index), &options);
+                assert!(a == b, "{name}: the import differs through the index");
+            }
+            (Err(a), Err(b)) => assert_eq!(a, b, "{name}"),
+            (a, b) => panic!("{name}: {:?} vs {:?}", a.err(), b.err()),
+        }
+    }
+
+    fn tdmn(name: &str) -> Chunk<'static> {
+        let mut b = name.as_bytes().to_vec();
+        b.resize(40, 0);
+        Chunk::data(*b"tdmn", b)
+    }
+
+    #[test]
+    fn a_synthetic_project_imports_the_same_through_the_index() {
+        // A composition with a layer whose effect stores arbitrary data and a named value group.
+        let utf8 = |id: [u8; 4], t: &str| Chunk { id, body: Body::Chunks(vec![Chunk::data(*b"Utf8", t.as_bytes().to_vec())]), pad: None };
+        let record = Chunk::list(*b"tdbs", vec![Chunk::data(*b"tdsb", vec![0, 0, 0, 1]), Chunk::data(*b"cdat", vec![0, 0, 0, 1])]);
+        let values = Chunk::list(
+            *b"tdgp",
+            vec![
+                utf8(*b"tdsn", "Mine"),
+                tdmn("ADBE Easy Levels2-0001"),
+                record,
+                Chunk::list(*b"aRbs", vec![Chunk::data(*b"aRbp", vec![0u8; 108])]),
+                tdmn("ADBE Group End"),
+            ],
+        );
+        let part = Chunk::list(*b"parT", vec![Chunk::data(*b"parn", vec![0, 0, 0, 2]), tdmn("ADBE Easy Levels2-0001"), Chunk::data(*b"pard", vec![0u8; 148])]);
+        let sspc = Chunk::list(*b"sspc", vec![utf8(*b"fnam", "Levels"), part, values]);
+        let parade = Chunk::list(*b"tdgp", vec![tdmn("ADBE Easy Levels2"), sspc, tdmn("ADBE Group End")]);
+        let root = Chunk::list(*b"tdgp", vec![tdmn("ADBE Effect Parade"), parade, tdmn("ADBE Group End")]);
+        let layer = Chunk::list(*b"Layr", vec![Chunk::data(*b"ldta", vec![0u8; 160]), Chunk::data(*b"Utf8", b"Layer".to_vec()), root]);
+        let mut idta = vec![0u8; 64];
+        idta[..2].copy_from_slice(&4u16.to_be_bytes());
+        let mut cdta = vec![0u8; 200];
+        cdta[4..12].copy_from_slice(&[0, 0, 0, 1, 0, 0, 0, 30]);
+        let item = Chunk::list(*b"Item", vec![Chunk::data(*b"idta", idta), Chunk::data(*b"Utf8", b"Comp".to_vec()), Chunk::data(*b"cdta", cdta), layer]);
+        let file = AepFile { chunks: vec![Chunk::data(*b"head", vec![0u8; 20]), Chunk::list(*b"Fold", vec![item])], trailer: std::borrow::Cow::Borrowed(&[]) };
+        both(&write(&file).expect("write"), "synthetic");
+    }
+
+    /// Every `.aep` of the fixture directory (skipped without `EFFECTCRAFT_AEP_FIXTURES`).
+    #[test]
+    fn every_fixture_imports_the_same_through_the_index() {
+        let Some(dir) = std::env::var_os("EFFECTCRAFT_AEP_FIXTURES").filter(|d| !d.is_empty()) else { return };
+        let Ok(entries) = std::fs::read_dir(dir) else { return };
+        let mut paths: Vec<std::path::PathBuf> =
+            entries.filter_map(Result::ok).map(|e| e.path()).filter(|p| p.extension().is_some_and(|x| x == "aep")).collect();
+        paths.sort();
+        for path in paths {
+            let bytes = std::fs::read(&path).unwrap_or_else(|e| panic!("{}: {e}", path.display()));
+            both(&bytes, &path.display().to_string());
+        }
+    }
+}
diff --git a/crates/aep/src/import/markers.rs b/crates/aep/src/import/markers.rs
index 93faea90a..7767bfca4 100644
--- a/crates/aep/src/import/markers.rs
+++ b/crates/aep/src/import/markers.rs
@@ -11,7 +11,8 @@
 //! EffectCraft's `timeRemap` property (seconds, keys in layer time) at the top of the layer's
 //! properties, where the engine's Enable Time Remapping puts it.
 
-use crate::{Chunk, CueType, Layer as AepLayer, Marker as AepMarker, PropNode, Property as AepProp};
+use crate::container::index::Node as AepNode;
+use crate::{CueType, Layer as AepLayer, Marker as AepMarker, PropNode, Property as AepProp};
 use effectcraft_color::Label;
 use effectcraft_keyframe::Value;
 use effectcraft_project::build::Ids;
@@ -23,12 +24,12 @@ use crate::import::report::{Collector, LossCategory};
 use crate::import::time::TimeMap;
 
 /// The time scale of the marker list below `holder` (the layer, or the composition's `SecL`).
-fn marker_scale(holder: &Chunk<'_>) -> Option<u32> {
+fn marker_scale(holder: AepNode<'_, '_>) -> Option<u32> {
     holder.marker_list()?.child_list(b"tdbs").and_then(AepProp::from_chunk)?.time_scale().filter(|s| *s != 0)
 }
 
 /// The markers of a layer (`holder` = the layer chunk) or a composition (`holder` = its `SecL`).
-pub(crate) fn import_markers(list: Vec<AepMarker>, holder: &Chunk<'_>, what: &str, tm: &TimeMap, col: &mut Collector) -> Vec<Marker> {
+pub(crate) fn import_markers(list: Vec<AepMarker>, holder: AepNode<'_, '_>, what: &str, tm: &TimeMap, col: &mut Collector) -> Vec<Marker> {
     let scale = marker_scale(holder).unwrap_or(tm.timescale);
     let mut out: Vec<Marker> = Vec::with_capacity(list.len());
     for m in list {
diff --git a/crates/aep/src/import/report.rs b/crates/aep/src/import/report.rs
index d7dbfe898..c72fb8528 100644
--- a/crates/aep/src/import/report.rs
+++ b/crates/aep/src/import/report.rs
@@ -8,6 +8,7 @@ use std::collections::BTreeMap;
 use serde::{Deserialize, Serialize};
 
 use crate::container::AepFile;
+use crate::container::index::Root;
 
 /// Most example lines kept per loss category (the count is always exact).
 pub const MAX_DETAILS: usize = 20;
@@ -247,6 +248,10 @@ pub const UNKNOWN: &str = "unknown";
 impl AeVersionInfo {
     /// Reads the versions of a parsed file.
     pub fn of(file: &AepFile<'_>) -> Self {
+        Self::of_root(Root::from(file))
+    }
+
+    pub(crate) fn of_root(file: Root<'_, '_>) -> Self {
         let file_version = file.file_version();
         Self {
             file_version: file_version.map_or_else(|| UNKNOWN.to_string(), |v| v.text()),
diff --git a/crates/aep/src/import/settings.rs b/crates/aep/src/import/settings.rs
index 29d520c39..70e245d78 100644
--- a/crates/aep/src/import/settings.rs
+++ b/crates/aep/src/import/settings.rs
@@ -1,7 +1,8 @@
 //! Project settings (colour depth, working space, working gamma, linear-light switches, time
 //! display, frame count start) from [`crate::ProjectSettings`] (cases 620-634).
 
-use crate::{AepFile, TimeDisplay, WorkingSpace};
+use crate::container::index::{Node, Root};
+use crate::{TimeDisplay, WorkingSpace};
 use effectcraft_color::ColorSpace;
 use effectcraft_project::{BitDepth, ProjectSettings, TimeDisplayStyle};
 
@@ -22,9 +23,9 @@ pub(crate) fn color_space(name: &str) -> Option<ColorSpace> {
 /// holds in an unknown form) keeps the current value. The two linear-light switches are always
 /// held: After Effects writes their chunk only when on (626, 627), so a file without it has them off. A working space EffectCraft does not have is
 /// reported.
-pub(crate) fn map(file: &AepFile<'_>, current: &ProjectSettings, col: &mut Collector) -> ProjectSettings {
-    let s = crate::ProjectSettings::read(file);
-    let nhed = file.chunk(b"nhed").and_then(|c| c.bytes());
+pub(crate) fn map(file: Root<'_, '_>, current: &ProjectSettings, col: &mut Collector) -> ProjectSettings {
+    let s = crate::ProjectSettings::of(file);
+    let nhed = file.chunk(b"nhed").and_then(Node::bytes);
     let mut out = current.clone();
     match s.bits_per_channel {
         Some(8) => out.bit_depth = BitDepth::Bpc8,
diff --git a/crates/aep/src/import/shapes.rs b/crates/aep/src/import/shapes.rs
index 345346a6f..aa06201ac 100644
--- a/crates/aep/src/import/shapes.rs
+++ b/crates/aep/src/import/shapes.rs
@@ -394,7 +394,7 @@ fn path(g: &AepGroup<'_, '_>, cx: &mut Cx<'_, '_>) -> Option<PropGroup> {
         return None;
     };
     let shapes: Vec<Option<AepPath>> =
-        oms.child_list(b"omks").map(|k| k.children().iter().filter(|c| c.is_list(b"shap")).map(AepPath::from_chunk).collect()).unwrap_or_default();
+        oms.child_list(b"omks").map(|k| k.children().filter(|c| c.is_list(b"shap")).map(AepPath::from_chunk).collect()).unwrap_or_default();
     let first = match shapes.first() {
         Some(Some(s)) => to_path(s, (1, 1)),
         Some(None) => Err("its path is unreadable"),
diff --git a/crates/aep/tests/it/common/mod.rs b/crates/aep/tests/it/common/mod.rs
index 01054ba24..634df7f4c 100644
--- a/crates/aep/tests/it/common/mod.rs
+++ b/crates/aep/tests/it/common/mod.rs
@@ -132,7 +132,7 @@ pub fn resolve(name: &str) -> Option<PathBuf> {
 /// the little-endian `u32` of each `idpi` chunk (the importer does not read them; the exporter
 /// writes them).
 pub fn used_item_ids(item: &effectcraft_aep::Item<'_, '_>) -> Vec<u32> {
-    item.chunk().children().iter().filter(|c| c.is(b"idpi")).filter_map(|c| Some(u32::from_le_bytes(c.bytes()?.get(..4)?.try_into().ok()?))).collect()
+    item.chunk().children().filter(|c| c.is(b"idpi")).filter_map(|c| Some(u32::from_le_bytes(c.bytes()?.get(..4)?.try_into().ok()?))).collect()
 }
 
 /// The bytes of a case (see the module comment), or `None` when it is missing.
diff --git a/crates/aep/tests/it/container.rs b/crates/aep/tests/it/container.rs
index 5031a11dc..4fc6d804e 100644
--- a/crates/aep/tests/it/container.rs
+++ b/crates/aep/tests/it/container.rs
@@ -25,5 +25,6 @@ mod shapes;
 mod text_fields;
 mod text_markers_footage;
 mod text_style_slots;
+mod tree_index;
 mod typed;
 mod values;
diff --git a/crates/aep/tests/it/container/batch3_core.rs b/crates/aep/tests/it/container/batch3_core.rs
index 1813e2df8..7b9699e36 100644
--- a/crates/aep/tests/it/container/batch3_core.rs
+++ b/crates/aep/tests/it/container/batch3_core.rs
@@ -117,8 +117,8 @@ fn a_transform_set_to_its_default_adds_no_record() {
         assert_eq!(t.opacity_percent.source, ValueSource::Default);
         assert!(layer.properties().unwrap().find(&["ADBE Transform Group", "ADBE Position"]).is_none());
         // The two cases are layers of one file: they differ in the layer id only.
-        let a = without_layer_id(layer.chunk());
-        skip!(with_layer("299-save-noise.aep", L, |_, other| assert_eq!(a, without_layer_id(other.chunk()))));
+        let a = without_layer_id(&layer.chunk().to_chunk());
+        skip!(with_layer("299-save-noise.aep", L, |_, other| assert_eq!(a, without_layer_id(&other.chunk().to_chunk()))));
     }));
 }
 
diff --git a/crates/aep/tests/it/container/tree_index.rs b/crates/aep/tests/it/container/tree_index.rs
new file mode 100644
index 000000000..e49d641a0
--- /dev/null
+++ b/crates/aep/tests/it/container/tree_index.rs
@@ -0,0 +1,212 @@
+//! The flat tree index the importer reads ([`TreeIndex`]) against the owned chunk tree, on every
+//! file of the fixture directory: the same tree, and the same answers from the typed view.
+
+use std::fmt::Write as _;
+
+use effectcraft_aep::container::index::TreeIndex;
+use effectcraft_aep::{
+    AepFile, Chunk, CryptomatteData, CurvesData, Effect, HueSaturationData, LevelsData, Limits, MeshData, Project, PropGroup, PropNode, is_aepx, parse,
+    parse_with_limits, read_aepx, write,
+};
+
+/// Every `.aep` and `.aepx` in the fixture directory (the real projects included), sorted.
+fn every_file() -> Vec<std::path::PathBuf> {
+    let Some(dir) = crate::common::dir() else {
+        crate::common::skipped("*.aep");
+        return Vec::new();
+    };
+    let Ok(entries) = std::fs::read_dir(&dir) else {
+        crate::common::skipped("*.aep");
+        return Vec::new();
+    };
+    let mut out: Vec<std::path::PathBuf> =
+        entries.filter_map(Result::ok).map(|e| e.path()).filter(|p| p.extension().is_some_and(|x| x == "aep" || x == "aepx")).collect();
+    out.sort();
+    out
+}
+
+/// What the typed view reads from a project, as text: items, compositions, layers with their
+/// headers, transforms, masks, effects with every parameter value, text, markers, the whole
+/// property tree with static values and key records, settings and versions.
+fn dump(view: &Project<'_, '_>) -> String {
+    let mut s = String::new();
+    let defs = view.effect_definition_index();
+    for item in view.all_items() {
+        let _ = writeln!(s, "item {:?} {:?} {:?} {:?} {:?}", item.kind(), item.name(), item.display_name(), item.id(), item.label());
+        let _ = writeln!(s, "  footage {:?} {:?} {:?}", item.footage(), item.sequence_info(), item.conform_frame_rate());
+        let _ = writeln!(s, "  folder {} {}", item.has_folder_contents(), item.folder_contents_unreadable());
+        let Some(comp) = item.comp() else { continue };
+        let _ = writeln!(s, "  comp {:?} {:?} {:?}", comp.time_base(), comp.header(), comp.markers());
+        for layer in comp.layers() {
+            let _ = writeln!(s, "  layer {:?} {:?} {:?} {:?}", layer.name(), layer.id(), layer.header(), layer.track_matte());
+            let _ = writeln!(s, "    transform {:?}", layer.transform(1920, 1080));
+            let _ = writeln!(s, "    time remap {:?} orientation {:?} {:?}", layer.time_remap(), layer.orientation(), layer.orientation_keys());
+            let _ = writeln!(s, "    masks {:?}", layer.mask_atoms().iter().map(|m| (&m.mask, &m.path_shapes)).collect::<Vec<_>>());
+            let _ = writeln!(s, "    shapes {:?}", layer.shape_groups());
+            let _ =
+                writeln!(s, "    text {:?} {} {:?}", layer.text_document(), layer.text_document_count(), layer.source_text_property().map(|p| p.is_animated()));
+            let _ = writeln!(s, "    markers {:?} source {:?}", layer.markers(), view.layer_source(&layer).map(|i| i.id()));
+            for fx in layer.effects() {
+                let _ =
+                    writeln!(s, "    fx {} {:?} {:?} {:?} {:?}", fx.match_name(), fx.display_name(), fx.enabled(), defs.source(&fx), fx.value_record_names());
+                let _ = writeln!(s, "      names {:?} {:?} {:?} {:?}", fx.name(), fx.user_name(), fx.declared_param_count(), fx.has_own_definitions());
+                for p in defs.params(&fx) {
+                    let _ = writeln!(s, "      {} {:?} {:?} {:?} {:?}", p.match_name, p.kind, p.name, p.items, p.value());
+                    arbitrary(&fx, &p.match_name, &mut s);
+                }
+                for name in fx.value_record_names() {
+                    arbitrary(&fx, &name, &mut s);
+                }
+            }
+            if let Some(root) = layer.properties() {
+                tree(&root, 0, &mut s);
+            }
+        }
+    }
+    s
+}
+
+/// The arbitrary data stored for a parameter and what each decoder reads from it.
+fn arbitrary(fx: &Effect<'_, '_>, name: &str, s: &mut String) {
+    let Some(data) = fx.arbitrary_data(name) else { return };
+    let _ = writeln!(s, "        arbitrary {name} {data:?}");
+    let _ = writeln!(s, "        {:?} {:?}", HueSaturationData::parse(data), LevelsData::parse(data));
+    let _ = writeln!(s, "        {:?} {:?} {:?}", CurvesData::parse(data), MeshData::parse(data), CryptomatteData::parse(data));
+}
+
+fn tree(group: &PropGroup<'_, '_>, depth: usize, s: &mut String) {
+    if depth > 32 {
+        return;
+    }
+    let _ = writeln!(s, "{:depth$}group {:?} {:?}", "", group.user_name(), group.flags());
+    for e in group.entries() {
+        match e.node {
+            PropNode::Group(g) => tree(&g, depth + 1, s),
+            PropNode::Property(p) => {
+                let keys: Option<Vec<Vec<u8>>> = p.keys().map(|k| k.records().map(<[u8]>::to_vec).collect());
+                let _ = writeln!(s, "{:depth$} {} {:?} {:?} {:?} {:?}", "", e.match_name, p.user_name(), p.header(), p.static_value(), keys);
+            }
+            PropNode::Other(c) => {
+                let _ = writeln!(s, "{:depth$} {} other {:?} {}", "", e.match_name, c.list_type(), c.descendants().count());
+            }
+        }
+    }
+}
+
+#[test]
+fn the_index_is_the_parsed_tree_and_the_view_reads_the_same_on_every_file() {
+    for path in every_file() {
+        let name = path.display().to_string();
+        let bytes = std::fs::read(&path).unwrap_or_else(|e| panic!("{name}: {e}"));
+        // `.aepx` is read into the chunk tree and indexed from it; `.aep` is indexed in place.
+        // A file that does not read (a damaged sample) must fail the index the same way.
+        let file: AepFile<'_> = match if is_aepx(&bytes) { read_aepx(&bytes) } else { parse(&bytes) } {
+            Ok(file) => file,
+            Err(e) => {
+                if !is_aepx(&bytes) {
+                    assert_eq!(TreeIndex::parse(&bytes).err(), Some(e), "{name}");
+                }
+                continue;
+            }
+        };
+        let index = (if is_aepx(&bytes) { TreeIndex::from_file(&file) } else { TreeIndex::parse(&bytes) }).unwrap_or_else(|e| panic!("{name}: {e}"));
+        assert!(index.to_file() == file, "{name}: the index is not the parsed tree");
+        assert_eq!(index.len(), file.walk().count(), "{name}");
+        assert_eq!(index.file_version(), file.file_version(), "{name}");
+        assert_eq!(index.saved_by_version(), file.saved_by_version(), "{name}");
+        assert_eq!(effectcraft_aep::ProjectSettings::read_index(&index), effectcraft_aep::ProjectSettings::read(&file), "{name}");
+        let (Some(a), Some(b)) = (Project::new(&file), Project::from_index(&index)) else {
+            assert!(Project::new(&file).is_none() && Project::from_index(&index).is_none(), "{name}");
+            continue;
+        };
+        let (da, db) = (dump(&a), dump(&b));
+        assert!(da == db, "{name}: the view reads differently through the index");
+    }
+}
+
+#[test]
+fn the_index_and_the_parser_fail_alike_under_tight_limits() {
+    for path in every_file().into_iter().filter(|p| p.extension().is_some_and(|x| x == "aep")) {
+        let name = path.display().to_string();
+        let bytes = std::fs::read(&path).unwrap_or_else(|e| panic!("{name}: {e}"));
+        let total = parse(&bytes).map(|f| f.walk().count()).unwrap_or(0);
+        for limits in [
+            Limits { max_depth: 2, max_chunks: 10_000_000 },
+            Limits { max_depth: 6, max_chunks: 10_000_000 },
+            Limits { max_depth: 64, max_chunks: total },
+            Limits { max_depth: 64, max_chunks: total.saturating_sub(1) },
+            Limits { max_depth: 64, max_chunks: total / 2 },
+        ] {
+            let old = parse_with_limits(&bytes, limits);
+            let new = TreeIndex::parse_with_limits(&bytes, limits);
+            match (old, new) {
+                (Ok(f), Ok(i)) => assert!(i.to_file() == f, "{name}: {limits:?}"),
+                (Err(a), Err(b)) => assert_eq!(a, b, "{name}: {limits:?}"),
+                (a, b) => panic!("{name}: {limits:?}: {:?} vs {:?}", a.err(), b.err()),
+            }
+        }
+    }
+}
+
+/// A 40-byte NUL-padded match name.
+fn tdmn(name: &str) -> Chunk<'static> {
+    let mut b = name.as_bytes().to_vec();
+    b.resize(40, 0);
+    Chunk::data(*b"tdmn", b)
+}
+
+fn utf8(id: [u8; 4], text: &str) -> Chunk<'static> {
+    Chunk { id, body: effectcraft_aep::Body::Chunks(vec![Chunk::data(*b"Utf8", text.as_bytes().to_vec())]), pad: None }
+}
+
+/// A project with one composition, one layer and one effect whose five parameters carry arbitrary
+/// data in the sizes the decoders read (Hue/Saturation, Levels, Curves, a 2 x 2 mesh, Cryptomatte),
+/// so the arbitrary-data path runs without the fixture directory.
+fn synthetic() -> Vec<u8> {
+    let mut mesh = vec![0u8; 180];
+    mesh[..8].copy_from_slice(&[0, 0, 0, 2, 0, 0, 0, 2]);
+    let mut cry = vec![0u8; 200];
+    cry[..4].copy_from_slice(b"cry1");
+    cry[32..37].copy_from_slice(b"Layer");
+    let mut levels = vec![0u8; 108];
+    levels[8..16].copy_from_slice(&1.0f64.to_be_bytes());
+    let payloads: [Vec<u8>; 5] = [vec![7u8; 180], levels, vec![0u8; CurvesData::SIZE], mesh, cry];
+    let (mut part, mut values) =
+        (vec![Chunk::data(*b"parn", 6u32.to_be_bytes().to_vec())], vec![Chunk::data(*b"tdsb", 1u32.to_be_bytes().to_vec()), utf8(*b"tdsn", "Mine")]);
+    for (i, data) in payloads.into_iter().enumerate() {
+        let name = format!("FX-{:04}", i + 1);
+        let mut pard = vec![0u8; 148];
+        pard[12..16].copy_from_slice(&11u32.to_be_bytes());
+        part.extend([tdmn(&name), Chunk::data(*b"pard", pard)]);
+        let record = Chunk::list(*b"tdbs", vec![Chunk::data(*b"tdsb", 1u32.to_be_bytes().to_vec()), Chunk::data(*b"cdat", vec![0, 0, 0, 1])]);
+        values.extend([tdmn(&name), record, Chunk::list(*b"aRbs", vec![Chunk::data(*b"aRbp", data)])]);
+    }
+    values.push(tdmn("ADBE Group End"));
+    let sspc = Chunk::list(*b"sspc", vec![utf8(*b"fnam", "Effect"), Chunk::list(*b"parT", part), Chunk::list(*b"tdgp", values)]);
+    let parade = Chunk::list(*b"tdgp", vec![tdmn("FX"), sspc, tdmn("ADBE Group End")]);
+    let root = Chunk::list(*b"tdgp", vec![tdmn("ADBE Effect Parade"), parade, tdmn("ADBE Group End")]);
+    let layer = Chunk::list(*b"Layr", vec![Chunk::data(*b"ldta", vec![0u8; 160]), Chunk::data(*b"Utf8", b"Layer".to_vec()), root]);
+    let mut idta = vec![0u8; 64];
+    idta[..2].copy_from_slice(&4u16.to_be_bytes());
+    idta[16..20].copy_from_slice(&2u32.to_be_bytes());
+    let mut cdta = vec![0u8; 200];
+    cdta[4..12].copy_from_slice(&[0, 0, 0, 1, 0, 0, 0, 30]);
+    let item = Chunk::list(*b"Item", vec![Chunk::data(*b"idta", idta), Chunk::data(*b"Utf8", b"Comp".to_vec()), Chunk::data(*b"cdta", cdta), layer]);
+    let file = AepFile { chunks: vec![Chunk::data(*b"head", vec![0u8; 20]), Chunk::list(*b"Fold", vec![item])], trailer: std::borrow::Cow::Borrowed(&[]) };
+    write(&file).expect("write")
+}
+
+#[test]
+fn the_view_reads_arbitrary_effect_data_the_same_through_the_index() {
+    let bytes = synthetic();
+    let file = parse(&bytes).expect("parse");
+    let index = TreeIndex::parse(&bytes).expect("index");
+    let (a, b) = (Project::new(&file).expect("project"), Project::from_index(&index).expect("project"));
+    let (da, db) = (dump(&a), dump(&b));
+    assert_eq!(da, db);
+    // The synthetic effect really reaches every decoder (the dump is not empty of them).
+    assert_eq!(da.matches("arbitrary FX-").count(), 10, "{da}");
+    assert!(da.contains("Some(HueSaturationData") && da.contains("Some(LevelsData") && da.contains("Some(CurvesData"), "{da}");
+    assert!(da.contains("Some(MeshData") && da.contains("Some(CryptomatteData"), "{da}");
+    assert!(da.contains("Some(\"Mine\")"), "the user name is read: {da}");
+}
diff --git a/crates/aep/tests/it/container/typed.rs b/crates/aep/tests/it/container/typed.rs
index 381f86796..e85391e0f 100644
--- a/crates/aep/tests/it/container/typed.rs
+++ b/crates/aep/tests/it/container/typed.rs
@@ -111,7 +111,7 @@ fn match_names_come_from_the_tdmn_chunks() {
     assert!(!names.iter().any(|n| n == "ADBE Group End"));
     assert!(root.find(&["ADBE Transform Group", "ADBE Nonexistent"]).is_none());
     // The raw tdmn body is 40 bytes, NUL padded.
-    let raw = root.chunk().children().iter().find(|c| c.is(b"tdmn")).unwrap();
+    let raw = root.chunk().children().find(|c| c.is(b"tdmn")).unwrap();
     assert_eq!(raw.bytes().unwrap().len(), 40);
 }
 
@@ -150,8 +150,8 @@ fn effect_parameter_value() {
     assert!(instance.is_list(b"sspc"));
     // The effect's name is in a nested fnam chunk.
     let fnam = instance.child(b"fnam").unwrap();
-    assert!(matches!(fnam.body, Body::Chunks(_)));
-    assert_eq!(fnam.children()[0].bytes(), Some(&b"Slider Control"[..]));
+    assert!(matches!(fnam.to_chunk().body, Body::Chunks(_)));
+    assert_eq!(fnam.children().next().unwrap().bytes(), Some(&b"Slider Control"[..]));
     // The parameters are a property group inside the instance.
     let params = PropGroup::from_chunk(instance.child_list(b"tdgp").unwrap()).unwrap();
     assert_eq!(params.names(), ["ADBE Slider Control-0000", "ADBE Slider Control-0001", "ADBE Effect Built In Params"]);
diff --git a/crates/aep/tests/it/export/effects.rs b/crates/aep/tests/it/export/effects.rs
index 7a684705a..51b0226a6 100644
--- a/crates/aep/tests/it/export/effects.rs
+++ b/crates/aep/tests/it/export/effects.rs
@@ -390,7 +390,7 @@ fn static_records(file: &AepFile<'_>) -> std::collections::BTreeMap<(String, usi
         for (li, layer) in comp.layers().enumerate() {
             for (ei, e) in layer.effects().into_iter().enumerate() {
                 let Some(spec) = effectcraft_aep::effect_map::by_match_name(e.match_name()) else { continue };
-                let Some(values) = e.chunk().child_list(b"tdgp") else { continue };
+                let Some(values) = e.chunk().child_list(b"tdgp").map(|v| v.to_chunk()) else { continue };
                 let k = values.children();
                 for (i, c) in k.iter().enumerate() {
                     let Some(name) =
diff --git a/crates/aep/tests/it/export/objects.rs b/crates/aep/tests/it/export/objects.rs
index f9de6e836..692c87630 100644
--- a/crates/aep/tests/it/export/objects.rs
+++ b/crates/aep/tests/it/export/objects.rs
@@ -493,7 +493,7 @@ fn shape_records(bytes: &[u8]) -> std::collections::BTreeMap<(usize, String), ef
     for item in view.all_items() {
         let Some(comp) = item.comp() else { continue };
         for (li, layer) in comp.layers().enumerate() {
-            if let Some(g) = layer.chunk().child_list(b"tdgp") {
+            if let Some(g) = layer.chunk().child_list(b"tdgp").map(|g| g.to_chunk()) {
                 walk(g.children(), "", li, false, &mut out);
             }
         }
@@ -618,7 +618,7 @@ fn keyed_shape_records(bytes: &[u8]) -> Vec<(String, Vec<u8>, Vec<u8>, Vec<u8>,
     for item in view.all_items() {
         let Some(comp) = item.comp() else { continue };
         for layer in comp.layers() {
-            if let Some(g) = layer.chunk().child_list(b"tdgp") {
+            if let Some(g) = layer.chunk().child_list(b"tdgp").map(|g| g.to_chunk()) {
                 walk(g.children(), "", false, &mut out);
             }
         }
@@ -853,7 +853,8 @@ fn a_camera_transform_group_ends_with_its_group_end() {
     let view = effectcraft_aep::Project::new(&file).expect("project");
     let comp = view.all_items().into_iter().find_map(|i| i.comp()).expect("comp");
     let layer = comp.layers().next().expect("camera");
-    let root = layer.chunk().child_list(b"tdgp").expect("tree").children();
+    let tree = layer.chunk().child_list(b"tdgp").expect("tree").to_chunk();
+    let root = tree.children();
     let name =
         |c: &effectcraft_aep::Chunk<'_>| String::from_utf8_lossy(c.bytes().unwrap_or_default().split(|b| *b == 0).next().unwrap_or_default()).into_owned();
     let at = root.iter().position(|c| c.is(b"tdmn") && name(c) == "ADBE Transform Group").expect("transform");
diff --git a/crates/aep/tests/it/export/styles.rs b/crates/aep/tests/it/export/styles.rs
index ee3524a36..a3fca75ca 100644
--- a/crates/aep/tests/it/export/styles.rs
+++ b/crates/aep/tests/it/export/styles.rs
@@ -53,7 +53,7 @@ fn stored_group(bytes: &[u8]) -> Vec<u8> {
             {
                 // As far as the exporter writes records (`decoded`).
                 let mut f2 = effectcraft_aep::AepFile {
-                    chunks: vec![crate::export::helpers::decoded(&g.chunk().clone().into_owned())],
+                    chunks: vec![crate::export::helpers::decoded(&g.chunk().to_chunk().into_owned())],
                     trailer: std::borrow::Cow::Owned(vec![]),
                 };
                 f2.trailer = std::borrow::Cow::Owned(vec![]);
diff --git a/crates/aep/tests/it/import/combined.rs b/crates/aep/tests/it/import/combined.rs
index e6897e004..476c57a95 100644
--- a/crates/aep/tests/it/import/combined.rs
+++ b/crates/aep/tests/it/import/combined.rs
@@ -67,7 +67,7 @@ fn graft<'a>(file: &mut AepFile<'a>, pair: &[Chunk<'a>]) {
 /// target's project copy does not hold the donor's types.
 fn own_definitions<'a>(pair: &mut [Chunk<'a>], donor: &AepFile<'_>) {
     let defs: Vec<(String, Chunk<'static>)> = effectcraft_aep::Project::new(donor)
-        .map(|p| p.effect_definitions().into_iter().map(|(m, part)| (m, part.clone().into_owned())).collect())
+        .map(|p| p.effect_definitions().into_iter().map(|(m, part)| (m, part.to_chunk().into_owned())).collect())
         .unwrap_or_default();
     let Some(effectcraft_aep::Body::List { children, .. }) = pair.get_mut(1).map(|g| &mut g.body) else { return };
     let mut name: Option<String> = None;

From 4aabf112b6ccd1eedab69cb6c4dd78dc1f5650e9 Mon Sep 17 00:00:00 2001
From: vangel76 <vangel1976@googlemail.com>
Date: Sun, 8 Nov 2026 15:09:45 +0100
Subject: [PATCH 23/30] #3299: aep import/export: linear hostile-input bounds,
 reported losses, deduplicated export code

Import: precomp loop check by candidate-graph components (no search
without a loop), one LayerId -> index map for mattes, parents and effect
layer references, popup mapping linear in the file's items, lazy loss
details (lose_with), orientation keys at one time reported, mask path
ease speeds under the property limit, Blending Options nested past the
read depth reported.

Export: precomp loops by components, parent loops found once, cached
natural sort keys, one exported-layer set, parameter definitions built
from the effect table (old encode-and-parse path kept as a test
reference), shared key-time loop, key-list rewrite, spatial record,
tdmn/tdsn helpers, unreadable curve and mesh entries reported.

Corpus import and export dumps are byte-identical to the base.
---
 crates/aep/src/container/effect_map.rs |  61 ++-
 crates/aep/src/export/effects.rs       | 567 +++++++++++++++----------
 crates/aep/src/export/emit.rs          |   6 +-
 crates/aep/src/export/fxsynth.rs       |  16 +-
 crates/aep/src/export/plan.rs          | 410 +++++++++++++++---
 crates/aep/src/import.rs               |   2 +-
 crates/aep/src/import/build.rs         | 401 ++++++++++++++---
 crates/aep/src/import/effects.rs       | 193 +++++----
 crates/aep/src/import/masks.rs         |  71 ++--
 crates/aep/src/import/props.rs         |  77 ++--
 crates/aep/src/import/styles.rs        |  76 +++-
 crates/aep/tests/it/export.rs          |   1 +
 crates/aep/tests/it/export/bounds.rs   |  72 ++++
 crates/aep/tests/it/import.rs          |   1 +
 crates/aep/tests/it/import/bounds.rs   | 316 ++++++++++++++
 15 files changed, 1776 insertions(+), 494 deletions(-)
 create mode 100644 crates/aep/tests/it/export/bounds.rs
 create mode 100644 crates/aep/tests/it/import/bounds.rs

diff --git a/crates/aep/src/container/effect_map.rs b/crates/aep/src/container/effect_map.rs
index aea320395..e25456bec 100644
--- a/crates/aep/src/container/effect_map.rs
+++ b/crates/aep/src/container/effect_map.rs
@@ -1143,8 +1143,25 @@ pub const GLOW_MIDPOINT_MAX: f64 = 0.990_005_493_164_062_5;
 /// The key a popup item is matched by between the two programs: trimmed, lower case, and
 /// Set Matte's "Red Channel" ... "Alpha Channel" are EffectCraft's "Red" ... "Alpha" (904 E24).
 pub fn popup_key(item: &str) -> String {
-    let s = item.trim().to_ascii_lowercase();
-    s.strip_suffix(" channel").map(str::to_string).unwrap_or(s)
+    popup_stem(item).to_ascii_lowercase()
+}
+
+/// [`popup_key`] before the lower-casing, borrowed: `item` trimmed, without a final ` channel`
+/// in any case (the suffix is ASCII, so the cut is on a character boundary).
+pub(crate) fn popup_stem(item: &str) -> &str {
+    let t = item.trim();
+    let cut = t.len().saturating_sub(SUFFIX.len());
+    match (t.as_bytes().get(cut..), t.get(..cut)) {
+        (Some(end), Some(stem)) if t.len() >= SUFFIX.len() && end.eq_ignore_ascii_case(SUFFIX) => stem,
+        _ => t,
+    }
+}
+
+const SUFFIX: &[u8] = b" channel";
+
+/// Whether two popup items have the same [`popup_key`], without building either key.
+pub(crate) fn popup_keys_match(a: &str, b: &str) -> bool {
+    popup_stem(a).eq_ignore_ascii_case(popup_stem(b))
 }
 
 /// The table row of an After Effects match name.
@@ -1164,3 +1181,43 @@ pub const HUE_SATURATION_MASTER: [&str; 3] = ["hue", "saturation", "lightness"];
 /// The EffectCraft parameters Levels' RGB channel values (`Extra::Levels`) go to, in the order of
 /// the data (input black, input white, gamma, output black, output white: 512-516).
 pub const LEVELS_RGB: [&str; 5] = ["inBlack", "inWhite", "gamma", "outBlack", "outWhite"];
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    /// The key as it was built before the borrowed form (the reference for the differential test).
+    fn old_key(item: &str) -> String {
+        let s = item.trim().to_ascii_lowercase();
+        s.strip_suffix(" channel").map(str::to_string).unwrap_or(s)
+    }
+
+    #[test]
+    fn the_borrowed_popup_key_matches_the_owned_one() {
+        let items = [
+            "",
+            " ",
+            "(-",
+            "Red",
+            "red channel",
+            "Red Channel",
+            " Alpha CHANNEL ",
+            "channel",
+            " channel",
+            "x channel",
+            "Xchannel",
+            "Ä channel",
+            "Grün Channel",
+            "é",
+            "Ünit  channel",
+            "a channel channel",
+            "Luminance",
+        ];
+        for a in items {
+            assert_eq!(popup_key(a), old_key(a), "{a:?}");
+            for b in items {
+                assert_eq!(popup_keys_match(a, b), old_key(a) == old_key(b), "{a:?} {b:?}");
+            }
+        }
+    }
+}
diff --git a/crates/aep/src/export/effects.rs b/crates/aep/src/export/effects.rs
index f3335650c..a94ab47c6 100644
--- a/crates/aep/src/export/effects.rs
+++ b/crates/aep/src/export/effects.rs
@@ -29,14 +29,17 @@
 use std::collections::HashMap;
 use std::sync::OnceLock;
 
-use crate::effect_map::{Conv, EffectMap, Extra, HUE_SATURATION_MASTER, LEVELS_RGB, by_effect, by_match_name, popup_key};
-use crate::{AepFile, Body, CURVE_IDENTITY, Chunk, CurvesData, MeshData, ParamKind};
-use effectcraft_keyframe::{Interp, Keyframe, Value};
+use crate::effect_map::{Conv, EffectMap, Extra, HUE_SATURATION_MASTER, LEVELS_RGB, by_effect, by_match_name, popup_keys_match};
+use crate::{AepFile, CURVE_IDENTITY, Chunk, CurvesData, MeshData, ParamKind};
+use effectcraft_keyframe::{Interp, Value};
 use effectcraft_project::{GroupKind, Layer, LayerId, Node, ParamUi, PropGroup, Property};
 
+use crate::export::fx_defs::{FX_DEFS, FxDef, PDef};
+use crate::export::keys::{fill_key_list, replace_cdat, spatial_record, timed_keys};
 use crate::export::plan::{CompPlan, EaseSlot, KeyPlan, LIMIT};
 use crate::export::report::{Collector, LossCategory};
-use crate::export::tree::{R, child_data, child_mut, data_mut, kids_mut, list_mut, put, put_f64, put_u8, put_u16, put_u32, tpl};
+use crate::export::synth::{NO_NAME, is_tdmn, tdmn, tdmn_name, tdsn, utf8_in};
+use crate::export::tree::{R, child_data, child_mut, data_mut, kids_mut, list_mut, put, put_f64, put_u8, put_u32, tpl};
 
 /// How a parameter is stored in its value record.
 #[derive(Clone, Copy, Debug, PartialEq)]
@@ -154,10 +157,6 @@ pub(crate) struct ParDef {
     pub record: String,
     /// `pard@12`.
     pub code: u32,
-    /// `pard@16`, or a checkbox's `pdnm` label.
-    pub name: String,
-    /// The popup items (`pdnm`, separated by `|`).
-    pub items: Vec<String>,
     /// The default in stored units (`pard@56`).
     pub default: Vec<f64>,
     /// The slider range a value record repeats as `tdum` / `tduM`.
@@ -168,114 +167,76 @@ pub(crate) struct ParDef {
     pub data: Option<Vec<u8>>,
 }
 
-fn be_i32(d: &[u8], at: usize) -> Option<i32> {
-    Some(i32::from_be_bytes(d.get(at..at.checked_add(4)?)?.try_into().ok()?))
-}
-fn be_u32(d: &[u8], at: usize) -> Option<u32> {
-    Some(u32::from_be_bytes(d.get(at..at.checked_add(4)?)?.try_into().ok()?))
-}
-fn be_f32(d: &[u8], at: usize) -> Option<f64> {
-    Some(f64::from(f32::from_be_bytes(d.get(at..at.checked_add(4)?)?.try_into().ok()?)))
-}
-fn be_f64(d: &[u8], at: usize) -> Option<f64> {
-    Some(f64::from_be_bytes(d.get(at..at.checked_add(8)?)?.try_into().ok()?))
-}
-
-fn cname(d: &[u8]) -> String {
-    d.iter().take_while(|b| **b != 0).map(|b| char::from(*b)).collect()
+/// A fixed slider's or angle's value as its 16.16 `pard` copy holds it (`fxsynth::pard`).
+fn fixed(v: f64) -> f64 {
+    f64::from(crate::export::fxsynth::fixed_i32(v)) / 65536.0
 }
 
 impl ParDef {
-    fn from_pard(pard: &[u8], pdnm: Option<&str>, data: Option<&[u8]>) -> ParDef {
-        let code = be_u32(pard, 12).unwrap_or(u32::MAX);
-        let fx = |at: usize| be_i32(pard, at).map(|v| f64::from(v) / 65536.0);
-        let default: Vec<f64> = match code {
-            10 => be_f64(pard, 56).into_iter().collect(),
-            2 | 3 => fx(56).into_iter().collect(),
-            1 => be_i32(pard, 56).map(f64::from).into_iter().collect(),
-            4 | 7 => be_u32(pard, 56).map(f64::from).into_iter().collect(),
+    /// The definition of parameter `p` of the table row `fx`, in the stored units the
+    /// prototype's `pard` holds (`fxsynth::default_sspc` writes it from the same row): fixed
+    /// sliders, angles and points at 16.16, integers, checkboxes and popups rounded, colours as
+    /// bytes, float slider ranges as `f32`. Read straight from the table; the round trip through
+    /// the encoded `pard` that this replaces is the reference in the tests.
+    fn from_table(fx: &FxDef, p: &PDef) -> ParDef {
+        let d = |i: usize| p.default.get(i).copied().unwrap_or(0.0);
+        let int = |v: f64| f64::from(crate::export::fxsynth::int_i32(v));
+        let f32_of = |v: f64| f64::from(v as f32);
+        let default: Vec<f64> = match p.code {
+            10 => vec![d(0)],
+            2 | 3 => vec![fixed(d(0))],
+            1 => vec![int(d(0))],
+            4 => vec![f64::from(d(0).round().max(0.0) as u32)],
+            7 => vec![f64::from(d(0).round().clamp(0.0, f64::from(u16::MAX)) as u32)],
             // Fractions of the layer, or percent after an After Effects re-save (see the reader).
             6 => {
-                let p: Vec<f64> = [fx(56), fx(60)].into_iter().flatten().collect();
-                if p.iter().any(|c| c.abs() > 1.0 + 1e-9) { p.iter().map(|c| c / 100.0).collect() } else { p }
+                let pt = [fixed(d(0)), fixed(d(1))];
+                if pt.iter().any(|c| c.abs() > 1.0 + 1e-9) { pt.iter().map(|c| c / 100.0).collect() } else { pt.to_vec() }
             }
-            5 => pard.get(56..60).map(|c| c.iter().map(|b| f64::from(*b)).collect()).unwrap_or_default(),
+            5 => (0..4).map(|i| f64::from(d(i).round().clamp(0.0, 255.0) as u8)).collect(),
             _ => Vec::new(),
         };
-        let range = match code {
-            10 => be_f32(pard, 112).zip(be_f32(pard, 116)),
-            2 => fx(132).zip(fx(136)),
-            1 => be_i32(pard, 132).map(f64::from).zip(be_i32(pard, 136).map(f64::from)),
-            _ => None,
+        // A slider without a range or valid maximum in the table stores zeros there.
+        let (lo, hi) = p.range.unwrap_or((0.0, 0.0));
+        let max = p.valid_max.unwrap_or(0.0);
+        let (range, valid_max) = match p.code {
+            10 => (Some((f32_of(lo), f32_of(hi))), Some(f32_of(max))),
+            2 => (Some((fixed(lo), fixed(hi))), Some(fixed(max))),
+            1 => (Some((int(lo), int(hi))), Some(int(max))),
+            _ => (None, None),
         };
-        let valid_max = match code {
-            10 => be_f32(pard, 108),
-            2 => fx(128),
-            1 => be_i32(pard, 128).map(f64::from),
-            _ => None,
-        };
-        let pname = pard.get(16..48).map(cname).unwrap_or_default();
-        let (name, items) = match (code, pdnm) {
-            (7, Some(p)) if !p.is_empty() => (pname, p.split('|').map(str::to_string).collect()),
-            (4, Some(p)) if pname.trim().is_empty() => (p.to_string(), Vec::new()),
-            _ => (pname, Vec::new()),
-        };
-        ParDef { record: String::new(), code, name, items, default, range, valid_max, data: data.map(<[u8]>::to_vec) }
+        // The record is the text of its `tdmn` as the exporter reads it back (`synth::tdmn_name`),
+        // so the instance finds its records by it.
+        let record = tdmn_name(&tdmn(&fx.record(p))).unwrap_or_default();
+        // The prototype's `pard` holds no name and its `pdnm` is empty: no name, no popup items.
+        let data = if p.code == 11 { crate::export::fxsynth::default_data(fx.match_name) } else { None };
+        ParDef { record, code: u32::from(p.code), default, range, valid_max, data }
+    }
+
+    /// The definitions of the table row `fx`, by position (the table's index).
+    fn of_effect(fx: &FxDef) -> HashMap<u16, ParDef> {
+        let mut out = HashMap::with_capacity(fx.params.len());
+        let mut position = 0u16;
+        for p in fx.params {
+            out.insert(position, ParDef::from_table(fx, p));
+            position = position.saturating_add(1);
+        }
+        out
     }
 }
 
-/// The parameter definitions of an instance's `parT`, by position (the table's index).
-fn par_defs(sspc: &Chunk<'_>) -> HashMap<u16, ParDef> {
-    let mut out = HashMap::new();
-    let Some(part) = sspc.child_list(b"parT") else { return out };
-    let k = part.children();
-    let mut i = 0usize;
-    let mut position = 0u16;
-    while i < k.len() {
-        let (Some(m), Some(p)) = (k.get(i), k.get(i + 1)) else { break };
-        if !(m.is(b"tdmn") && p.is(b"pard")) {
-            i += 1;
-            continue;
-        }
-        let name = tdmn_name(m).unwrap_or_default();
-        let mut j = i + 2;
-        let mut pdnm = None;
-        let mut data = None;
-        while let Some(c) = k.get(j) {
-            if c.is(b"tdmn") {
-                break;
-            }
-            if c.is(b"pdnm") {
-                pdnm = c.children().iter().find(|u| u.is(b"Utf8")).and_then(|u| u.bytes()).map(|b| String::from_utf8_lossy(b).to_string());
-            }
-            if c.is(b"aRbp") {
-                data = c.bytes();
-            }
-            j += 1;
-        }
-        if let Some(bytes) = p.bytes() {
-            out.insert(position, ParDef { record: name, ..ParDef::from_pard(bytes, pdnm.as_deref(), data) });
-        }
-        position = position.saturating_add(1);
-        i = j;
-    }
-    out
-}
-
-/// The parameter definitions of every effect type, by match name (read from the default
-/// instances built from the effect table).
+/// The parameter definitions of every effect type, by match name (from the effect table the
+/// default instances are built from).
 fn defs() -> &'static HashMap<String, HashMap<u16, ParDef>> {
     static DEFS: OnceLock<HashMap<String, HashMap<u16, ParDef>>> = OnceLock::new();
-    DEFS.get_or_init(|| {
-        crate::export::fx_defs::FX_DEFS.iter().map(|fx| (fx.match_name.to_string(), par_defs(&crate::export::fxsynth::default_sspc(fx)))).collect()
-    })
+    DEFS.get_or_init(|| FX_DEFS.iter().map(|fx| (fx.match_name.to_string(), ParDef::of_effect(fx))).collect())
 }
 
 // ---------------------------------------------------------------------------------------------
 // Planning.
 
 /// The stored components of an EffectCraft value, `None` when it does not fit.
-fn stored(conv: Conv, kind: PKind, v: &Value, size: (f64, f64), ui: &ParamUi, def: &ParDef) -> Option<Vec<f64>> {
+fn stored(conv: Conv, kind: PKind, v: &Value, size: (f64, f64), ui: &ParamUi) -> Option<Vec<f64>> {
     let c = v.components();
     let g = |i: usize| c.get(i).copied().and_then(sane);
     let one = |x: f64| -> Vec<f64> {
@@ -306,8 +267,8 @@ fn stored(conv: Conv, kind: PKind, v: &Value, size: (f64, f64), ui: &ParamUi, de
             };
             let ParamUi::Popup { options } = ui else { return None };
             let name = options.get(i)?;
-            let file: Vec<&str> = if def.items.is_empty() { items.to_vec() } else { def.items.iter().map(String::as_str).collect() };
-            let at = file.iter().position(|f| f.trim() != "(-" && popup_key(f) == popup_key(name))?;
+            // The prototype's `pdnm` names no items: the table's are After Effects'.
+            let at = items.iter().position(|f| f.trim() != "(-" && popup_keys_match(f, name))?;
             vec![f64::from(u32::try_from(at).ok()?.checked_add(1)?)]
         }
         // Not a value record (layer parameters, histograms).
@@ -317,16 +278,15 @@ fn stored(conv: Conv, kind: PKind, v: &Value, size: (f64, f64), ui: &ParamUi, de
 
 /// Whether a popup's items are After Effects' items in the same order (separators included, as
 /// After Effects counts them), so an expression's 1-based result picks the same item in both.
-fn same_popup_order(items: &[&str], ui: &ParamUi, def: &ParDef) -> bool {
+fn same_popup_order(items: &[&str], ui: &ParamUi) -> bool {
     let ParamUi::Popup { options } = ui else { return false };
-    let file: Vec<&str> = if def.items.is_empty() { items.to_vec() } else { def.items.iter().map(String::as_str).collect() };
-    file.len() == options.len() && file.iter().zip(options).all(|(f, o)| f.trim() != "(-" && popup_key(f) == popup_key(o))
+    items.len() == options.len() && items.iter().zip(options).all(|(f, o)| f.trim() != "(-" && popup_keys_match(f, o))
 }
 
 /// [`stored`], reporting what it changes in a value it can store: a colour channel outside 0 to 1
 /// (written as the nearest limit) and a fraction on an integer parameter (rounded).
-fn stored_reported(conv: Conv, kind: PKind, v: &Value, (size, ui, def): ((f64, f64), &ParamUi, &ParDef), what: &str, col: &mut Collector) -> Option<Vec<f64>> {
-    let s = stored(conv, kind, v, size, ui, def)?;
+fn stored_reported(conv: Conv, kind: PKind, v: &Value, (size, ui): ((f64, f64), &ParamUi), what: &str, col: &mut Collector) -> Option<Vec<f64>> {
+    let s = stored(conv, kind, v, size, ui)?;
     if matches!(conv, Conv::Color) {
         let c = v.components();
         if c.iter().take(3).any(|x| !(0.0..=1.0).contains(x)) {
@@ -339,7 +299,7 @@ fn stored_reported(conv: Conv, kind: PKind, v: &Value, (size, ui, def): ((f64, f
         }
     }
     if kind == PKind::Int
-        && let Some(raw) = stored(conv, PKind::Fixed, v, size, ui, def)
+        && let Some(raw) = stored(conv, PKind::Fixed, v, size, ui)
         && raw.iter().zip(&s).any(|(a, b)| a.to_bits() != b.to_bits())
     {
         col.lose(LossCategory::Effects, format!("{what}: {raw:?} is written as the whole number {s:?}"));
@@ -501,16 +461,26 @@ fn plan_extra(spec: &EffectMap, g: &PropGroup, pdefs: &HashMap<u16, ParDef>, her
     (data != before).then_some((index, data))
 }
 
-/// `x,y` pairs (EffectCraft's curve points and mesh offsets; whitespace or `;` between pairs).
-fn pairs_of(s: &str) -> Vec<(f64, f64)> {
-    s.split(|c: char| c.is_whitespace() || c == ';')
+/// `x,y` pairs (EffectCraft's curve points; whitespace or `;` between pairs), and how many
+/// entries are not a pair of finite numbers (left out).
+fn pairs_of(s: &str) -> (Vec<(f64, f64)>, usize) {
+    let mut unreadable = 0usize;
+    let pairs = s
+        .split(|c: char| c.is_whitespace() || c == ';')
         .filter(|t| !t.is_empty())
         .filter_map(|t| {
-            let (x, y) = t.split_once(',')?;
-            let (x, y) = (x.trim().parse::<f64>().ok()?, y.trim().split(',').next()?.trim().parse::<f64>().ok()?);
-            (x.is_finite() && y.is_finite()).then_some((x, y))
+            let pair = (|| {
+                let (x, y) = t.split_once(',')?;
+                let (x, y) = (x.trim().parse::<f64>().ok()?, y.trim().split(',').next()?.trim().parse::<f64>().ok()?);
+                (x.is_finite() && y.is_finite()).then_some((x, y))
+            })();
+            if pair.is_none() {
+                unreadable = unreadable.saturating_add(1);
+            }
+            pair
         })
-        .collect()
+        .collect();
+    (pairs, unreadable)
 }
 
 /// The arbitrary-data parameter's index and default data.
@@ -537,7 +507,10 @@ fn static_str<'p>(g: &'p PropGroup, id: &str, here: &str, col: &mut Collector) -
 fn plan_curves(g: &PropGroup, pdefs: &HashMap<u16, ParDef>, here: &str, col: &mut Collector) -> Option<(u16, Vec<u8>)> {
     let mut curves: [Vec<(u8, u8)>; 5] = Default::default();
     for (slot, id) in curves.iter_mut().zip(["rgb", "red", "green", "blue", "alpha"]) {
-        let pts = static_str(g, id, here, col).map(pairs_of).unwrap_or_default();
+        let (pts, unreadable) = static_str(g, id, here, col).map(pairs_of).unwrap_or_default();
+        if unreadable > 0 {
+            col.lose(LossCategory::InvalidValues, format!("{here}: curve '{id}': {unreadable} entries are not an x,y pair of numbers and are not written"));
+        }
         let mut ints: Vec<(u8, u8)> = Vec::with_capacity(pts.len());
         let (mut rounded, mut clipped) = (false, false);
         for (x, y) in pts {
@@ -584,17 +557,25 @@ fn plan_mesh(g: &PropGroup, pdefs: &HashMap<u16, ParDef>, size: (f64, f64), here
     let (rows, columns) = (int("rows"), int("columns"));
     // Per vertex `dx,dy` (pixels), optionally followed by the eight pixel moves of its handles
     // (top, right, bottom, left) that the importer keeps.
+    let mut unreadable = 0usize;
     let offs: Vec<Vec<f64>> = static_str(g, "mesh", here, col)
         .map(|s| {
             s.split(|c: char| c.is_whitespace() || c == ';')
                 .filter(|t| !t.is_empty())
                 .filter_map(|t| {
-                    let v: Vec<f64> = t.split(',').map(|x| x.trim().parse::<f64>().ok().filter(|x| x.is_finite())).collect::<Option<_>>()?;
-                    (v.len() >= 2).then_some(v)
+                    let v: Option<Vec<f64>> = t.split(',').map(|x| x.trim().parse::<f64>().ok().filter(|x| x.is_finite())).collect();
+                    let v = v.filter(|v| v.len() >= 2);
+                    if v.is_none() {
+                        unreadable = unreadable.saturating_add(1);
+                    }
+                    v
                 })
                 .collect()
         })
         .unwrap_or_default();
+    if unreadable > 0 {
+        col.lose(LossCategory::InvalidValues, format!("{here}: the Distortion Mesh has {unreadable} entries that are not numbers, left out"));
+    }
     let count = usize::try_from((rows + 1) * (columns + 1)).ok()?;
     let moved = offs.iter().any(|v| v.iter().any(|x| *x != 0.0));
     if !moved && rows == 7 && columns == 7 {
@@ -714,7 +695,7 @@ fn plan_param(pin: ParamIn<'_>, index: u16, cp: &CompPlan, here: &str, col: &mut
         // factor parameter has other units) or a popup's items are in another order, its result
         // means something else in After Effects. Popups count from 1 in both programs' expressions.
         let other_units = match conv {
-            Conv::Popup { items, .. } => !same_popup_order(items, &prop.ui, def),
+            Conv::Popup { items, .. } => !same_popup_order(items, &prop.ui),
             Conv::Percent { valid_max } => (valid_max - 100.0).abs() > 1e-9,
             Conv::Factor { factor, .. } => (factor - 1.0).abs() > 1e-9,
             _ => false,
@@ -724,7 +705,7 @@ fn plan_param(pin: ParamIn<'_>, index: u16, cp: &CompPlan, here: &str, col: &mut
         }
     }
     if prop.keys.is_empty() {
-        let Some(s) = stored_reported(conv, kind, &prop.value, (size, &prop.ui, def), &what, col) else {
+        let Some(s) = stored_reported(conv, kind, &prop.value, (size, &prop.ui), &what, col) else {
             if matches!(conv, Conv::Popup { .. }) {
                 col.lose(LossCategory::Effects, format!("{what}: the popup item has no After Effects counterpart, the default was written"));
             } else {
@@ -744,7 +725,7 @@ fn plan_param(pin: ParamIn<'_>, index: u16, cp: &CompPlan, here: &str, col: &mut
             format!("{what}: keys on a popup, checkbox, angle or integer slider are not written (not sampled), the first key's value was written"),
         );
         let first = prop.keys.first().map(|k| &k.value).unwrap_or(&prop.value);
-        let s = stored_reported(conv, kind, first, (size, &prop.ui, def), &what, col)?;
+        let s = stored_reported(conv, kind, first, (size, &prop.ui), &what, col)?;
         return (!is_default(kind, &s, def) || expr.is_some()).then_some(ParamPlan { index, kind, value: ParamValue::Static(s), expr });
     }
     let keys = plan_keys(pin, cp, &what, col);
@@ -756,22 +737,8 @@ fn plan_param(pin: ParamIn<'_>, index: u16, cp: &CompPlan, here: &str, col: &mut
 }
 
 fn plan_keys(pin: ParamIn<'_>, cp: &CompPlan, what: &str, col: &mut Collector) -> Vec<KeyPlan> {
-    let ParamIn { conv, kind, def, prop, size } = pin;
-    let keys: &[Keyframe] = &prop.keys;
-    let mut timed: Vec<(i64, &Keyframe)> = Vec::with_capacity(keys.len());
-    for k in keys {
-        let (u, inexact) = cp.tb.units(k.time);
-        if inexact {
-            col.lose(LossCategory::RoundedTimes, format!("{what}: key at {:.4} s moved to the time base", k.time.seconds()));
-        }
-        timed.push((u, k));
-    }
-    timed.sort_by_key(|(u, _)| *u);
-    let before = timed.len();
-    timed.dedup_by_key(|(u, _)| *u);
-    if timed.len() != before {
-        col.lose(LossCategory::ApproximatedKeyframes, format!("{what}: keys at the same time were merged"));
-    }
+    let ParamIn { conv, kind, prop, size, .. } = pin;
+    let timed = timed_keys(&prop.keys, &cp.tb, what, "key", col);
     // The ease of colour keys is sampled only as speed 0 / influence 0, which After Effects
     // interpolates linearly (598): a colour key is written linear.
     let ease_ok = matches!(kind, PKind::Fixed | PKind::Float | PKind::Point);
@@ -790,7 +757,7 @@ fn plan_keys(pin: ParamIn<'_>, cp: &CompPlan, what: &str, col: &mut Collector) -
             col.lose(LossCategory::InvalidValues, format!("{what}: key time out of range, key dropped"));
             continue;
         };
-        let Some(value) = stored_reported(conv, kind, &k.value, (size, &prop.ui, def), what, col) else {
+        let Some(value) = stored_reported(conv, kind, &k.value, (size, &prop.ui), what, col) else {
             col.lose(LossCategory::InvalidValues, format!("{what}: a key value that cannot be stored, key dropped"));
             continue;
         };
@@ -884,11 +851,6 @@ fn keyed_kind(k: PKind) -> Option<KeyedKind> {
     }
 }
 
-pub(crate) fn tdmn_name(c: &Chunk<'_>) -> Option<String> {
-    let d = c.bytes()?;
-    Some(d.iter().take_while(|b| **b != 0).map(|b| char::from(*b)).collect())
-}
-
 impl FxProtos {
     /// The prototypes built in code from the effect table (`fx_defs`, `fxsynth`).
     pub(crate) fn build() -> FxProtos {
@@ -919,27 +881,10 @@ pub(crate) struct FxUse {
     pub types: Vec<&'static str>,
 }
 
-/// A `tdsn` chunk holding `text`.
-fn tdsn(text: &str) -> Chunk<'static> {
-    nested(*b"tdsn", text)
-}
-
-/// A chunk that holds one `Utf8` chunk (`tdsn`, `fnam`).
-fn nested(id: [u8; 4], text: &str) -> Chunk<'static> {
-    Chunk { id, body: Body::Chunks(vec![Chunk::data(*b"Utf8", text.as_bytes().to_vec())]), pad: None }
-}
-
 /// The value record of `p`, built from the record of its parameter type.
 pub(crate) fn value_record(protos: &FxProtos, p: &ParamPlan, def: &ParDef, source_size: (u32, u32)) -> R<(Chunk<'static>, Chunk<'static>)> {
     let mut rec = protos.kinds.get(&p.kind.code()).cloned().ok_or_else(|| tpl("effect value prototype missing"))?;
-    {
-        let kids = kids_mut(&mut rec)?;
-        if let Some(slot) = kids.iter_mut().find(|c| c.is(b"tdsn"))
-            && !def.name.is_empty()
-        {
-            *slot = tdsn(&def.name);
-        }
-    }
+    // The record keeps the prototype's `tdsn`: the prototypes name no parameter.
     if p.kind == PKind::Point {
         // The layer's aspect, as on the Anchor Point (369: 16 / 9, 383: 1 on 100 x 100).
         put_f64(child_data(&mut rec, b"tdb4")?, 24, f64::from(source_size.0) / f64::from(source_size.1.max(1)))?;
@@ -970,35 +915,22 @@ pub(crate) fn value_record(protos: &FxProtos, p: &ParamPlan, def: &ParDef, sourc
                     put_u8(tdb4, at, *ktdb4.get(at).ok_or_else(|| tpl("short tdb4"))?)?;
                 }
             }
-            let n = u32::try_from(keys.len()).map_err(|_| tpl("too many keys"))?;
             let dims = p.kind.dims();
             let size = match kk {
                 KeyedKind::Fixed | KeyedKind::Float => 8 + 40 * dims,
                 KeyedKind::Color | KeyedKind::Point => 56 + 24 * dims,
             };
-            {
-                let lhd3 = child_data(&mut list, b"lhd3")?;
-                crate::export::synth::put_key_counts(lhd3, n, u32::try_from(size).map_err(|_| tpl("record size"))?)?;
-            }
-            let mut ldat = Vec::with_capacity(size * keys.len());
+            let mut ldat = Vec::with_capacity(size.saturating_mul(keys.len()));
             for k in keys {
                 ldat.extend(match kk {
                     KeyedKind::Fixed | KeyedKind::Float => crate::export::emit::plain_record(1, k, size)?,
-                    KeyedKind::Color | KeyedKind::Point => spatial_record(kk, k, dims, size)?,
+                    // A colour (flags `0x0001`, 210, 364) or a point (flags `0x0007`, the
+                    // temporal ease in layer heights per second, 382, 598).
+                    KeyedKind::Color | KeyedKind::Point => spatial_record(k, dims, kk == KeyedKind::Point, size)?,
                 });
             }
-            {
-                let lk = kids_mut(&mut list)?;
-                match lk.iter_mut().find(|c| c.is(b"ldat")) {
-                    Some(c) => *c = Chunk::data(*b"ldat", ldat),
-                    None => lk.push(Chunk::data(*b"ldat", ldat)),
-                }
-            }
-            let kids = kids_mut(&mut rec)?;
-            let at = kids.iter().position(|c| c.is(b"cdat")).ok_or_else(|| tpl("value record without cdat"))?;
-            if let Some(slot) = kids.get_mut(at) {
-                *slot = list;
-            }
+            fill_key_list(&mut list, ldat, keys.len(), size)?;
+            replace_cdat(&mut rec, list)?;
         }
     }
     if let Some((text, enabled)) = &p.expr {
@@ -1013,46 +945,7 @@ pub(crate) fn value_record(protos: &FxProtos, p: &ParamPlan, def: &ParDef, sourc
         let at = kids.iter().position(|c| c.is(b"tdum")).unwrap_or(kids.len());
         kids.insert(at, Chunk::data(*b"Utf8", text.as_bytes().to_vec()));
     }
-    Ok((Chunk::data(*b"tdmn", tdmn_bytes(&def.record)), rec))
-}
-
-/// A key of a colour (flags `0x0001`, 210, 364) or point (flags `0x0007`, `u32@8` the automatic
-/// tangent switch, 382) parameter: the spatial layout with the value at 56.
-fn spatial_record(kk: KeyedKind, k: &KeyPlan, n: usize, size: usize) -> R<Vec<u8>> {
-    let mut r = vec![0u8; size];
-    put(&mut r, 0, &k.time.to_be_bytes())?;
-    put_u8(&mut r, 4, k.in_interp)?;
-    put_u8(&mut r, 5, k.out_interp)?;
-    let base: u16 = if kk == KeyedKind::Point { 0x0007 } else { 0x0001 };
-    put_u16(&mut r, 6, base | (u16::from(k.label) << 6))?;
-    if kk == KeyedKind::Point {
-        put_u32(&mut r, 8, u32::from(k.spatial_auto))?;
-        // The temporal ease (598): speed in layer heights per second, influence a fraction.
-        let (i, o) = (k.in_ease.first().copied().unwrap_or_default(), k.out_ease.first().copied().unwrap_or_default());
-        put_f64(&mut r, 24, i.speed)?;
-        put_f64(&mut r, 32, i.influence)?;
-        put_f64(&mut r, 40, o.speed)?;
-        put_f64(&mut r, 48, o.influence)?;
-    }
-    for j in 0..n {
-        put_f64(&mut r, 56 + 8 * j, k.value.get(j).copied().unwrap_or(0.0))?;
-        if kk == KeyedKind::Point {
-            put_f64(&mut r, 56 + 8 * n + 8 * j, k.spatial_in.get(j).copied().unwrap_or(0.0))?;
-            put_f64(&mut r, 56 + 16 * n + 8 * j, k.spatial_out.get(j).copied().unwrap_or(0.0))?;
-        }
-    }
-    Ok(r)
-}
-
-/// A match name padded to the 40 bytes of `tdmn`.
-fn tdmn_bytes(name: &str) -> Vec<u8> {
-    let mut v = vec![0u8; 40];
-    for (i, b) in name.bytes().take(39).enumerate() {
-        if let Some(slot) = v.get_mut(i) {
-            *slot = b;
-        }
-    }
-    v
+    Ok((tdmn(&def.record), rec))
 }
 
 /// The `tdmn` + `sspc` of one instance on the layer with id `layer_id`.
@@ -1066,14 +959,15 @@ fn instance(
 ) -> R<Vec<Chunk<'static>>> {
     let (tdmn, sspc, _) = protos.defaults.get(fx.match_name).ok_or_else(|| tpl("effect prototype missing"))?;
     let mut sspc = sspc.clone();
-    let pdefs = par_defs(&sspc);
+    // The prototype's definitions are the table's (the prototype is built from it).
+    let pdefs = defs().get(fx.match_name).ok_or_else(|| tpl("effect definitions missing"))?;
     // `fnam` keeps the effect's own name; a name of the user's goes into the value group's
     // `tdsn`, which holds the placeholder `-_0_/-` otherwise (610 against 609).
     let own = child_mut(&mut sspc, b"fnam")?.children().iter().find(|c| c.is(b"Utf8")).and_then(|c| c.bytes()).map(|b| String::from_utf8_lossy(b).to_string());
     if own.as_deref() != Some(fx.name.as_str()) && !fx.name.is_empty() {
         let values = list_mut(&mut sspc, b"tdgp")?;
         let slot = child_mut(values, b"tdsn")?;
-        *slot = nested(*b"tdsn", &fx.name);
+        *slot = utf8_in(*b"tdsn", &fx.name);
     }
     // The fx switch: the value group's `tdsb` (`fx-switch` cases).
     put_u32(child_data(list_mut(&mut sspc, b"tdgp")?, b"tdsb")?, 0, u32::from(fx.enabled))?;
@@ -1086,9 +980,7 @@ fn instance(
         let values = list_mut(&mut sspc, b"tdgp")?;
         let kids = kids_mut(values)?;
         // The input layer (`-0000`) names the layer that owns the effect (320).
-        let tdpi_of = |kids: &mut Vec<Chunk<'static>>, record: &str| -> Option<usize> {
-            kids.iter().position(|c| c.is(b"tdmn") && tdmn_name(c).as_deref() == Some(record)).map(|i| i + 1)
-        };
+        let tdpi_of = |kids: &mut Vec<Chunk<'static>>, record: &str| -> Option<usize> { kids.iter().position(|c| is_tdmn(c, record)).map(|i| i + 1) };
         let input = pdefs.get(&0).map(|d| d.record.clone()).unwrap_or_default();
         // The prototype's own layer id (its input layer), to tell "the owning layer" from None.
         let mut proto_owner = None;
@@ -1108,7 +1000,7 @@ fn instance(
         let mapped: Vec<u16> = by_match_name(fx.match_name)
             .map(|s| s.params.iter().filter(|p| matches!(p.conv, Conv::LayerRef { .. })).filter_map(|p| u16::try_from(p.index).ok()).collect())
             .unwrap_or_default();
-        for (index, def) in &pdefs {
+        for (index, def) in pdefs {
             if *index == 0 || def.code != 0 {
                 continue;
             }
@@ -1130,10 +1022,7 @@ fn instance(
         // Arbitrary data: the `aRbp` of the `LIST aRbs` after the parameter's record.
         if let Some((index, data)) = &fx.data {
             let want = pdefs.get(index).map(|d| d.record.clone()).unwrap_or_default();
-            let i = kids
-                .iter()
-                .position(|c| c.is(b"tdmn") && tdmn_name(c).as_deref() == Some(want.as_str()))
-                .ok_or_else(|| tpl("arbitrary data record missing"))?;
+            let i = kids.iter().position(|c| is_tdmn(c, &want)).ok_or_else(|| tpl("arbitrary data record missing"))?;
             let list = kids.iter_mut().skip(i + 1).take(3).find(|c| c.is_list(b"aRbs")).ok_or_else(|| tpl("arbitrary data missing"))?;
             let arbp = child_mut(list, b"aRbp")?;
             *data_mut(arbp)? = data.clone();
@@ -1161,7 +1050,7 @@ fn instance(
             let Some(sel) = v.first().map(|x| x.round()).filter(|x| *x >= 1.0 && *x <= 1000.0) else { continue };
             let want = pdefs.get(&p.index).map(|d| d.record.clone()).unwrap_or_default();
             let kids = kids_mut(part)?;
-            if let Some(i) = kids.iter().position(|c| c.is(b"tdmn") && tdmn_name(c).as_deref() == Some(want.as_str()))
+            if let Some(i) = kids.iter().position(|c| is_tdmn(c, &want))
                 && let Some(pard) = kids.get_mut(i + 1)
             {
                 put_u32(data_mut(pard)?, 56, sel as u32)?;
@@ -1187,12 +1076,12 @@ pub(crate) fn build_parade(
     source_size: (u32, u32),
     uses: &mut FxUse,
 ) -> R<Vec<Chunk<'static>>> {
-    let mut kids = vec![Chunk::data(*b"tdsb", vec![0, 0, 0, 1]), tdsn("-_0_/-")];
+    let mut kids = vec![Chunk::data(*b"tdsb", vec![0, 0, 0, 1]), tdsn(NO_NAME)];
     for fx in fxs {
         kids.extend(instance(protos, fx, layer_id, layer_ids, source_size, uses)?);
     }
-    kids.push(Chunk::data(*b"tdmn", tdmn_bytes("ADBE Group End")));
-    Ok(vec![Chunk::data(*b"tdmn", tdmn_bytes("ADBE Effect Parade")), Chunk::list(*b"tdgp", kids)])
+    kids.push(tdmn(crate::export::synth::GROUP_END));
+    Ok(vec![tdmn("ADBE Effect Parade"), Chunk::list(*b"tdgp", kids)])
 }
 
 /// Writes the project-level effect lists: `Pefl` (one `pjef` per type, sorted by match name, 365)
@@ -1219,3 +1108,221 @@ pub(crate) fn put_project_lists(protos: &FxProtos, file: &mut AepFile<'static>,
     file.chunks.insert(at + 1, Chunk::list(*b"EfdG", efdg));
     Ok(())
 }
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    /// The definitions as they were found before: the prototype's `parT` encoded from the table
+    /// and parsed back (the reference for [`ParDef::from_table`]).
+    mod reference {
+        use super::super::*;
+
+        fn be_i32(d: &[u8], at: usize) -> Option<i32> {
+            Some(i32::from_be_bytes(d.get(at..at.checked_add(4)?)?.try_into().ok()?))
+        }
+        fn be_u32(d: &[u8], at: usize) -> Option<u32> {
+            Some(u32::from_be_bytes(d.get(at..at.checked_add(4)?)?.try_into().ok()?))
+        }
+        fn be_f32(d: &[u8], at: usize) -> Option<f64> {
+            Some(f64::from(f32::from_be_bytes(d.get(at..at.checked_add(4)?)?.try_into().ok()?)))
+        }
+        fn be_f64(d: &[u8], at: usize) -> Option<f64> {
+            Some(f64::from_be_bytes(d.get(at..at.checked_add(8)?)?.try_into().ok()?))
+        }
+
+        fn cname(d: &[u8]) -> String {
+            d.iter().take_while(|b| **b != 0).map(|b| char::from(*b)).collect()
+        }
+
+        /// A definition as the decoder read it, with the name and popup items it also read.
+        pub(super) struct Old {
+            pub def: ParDef,
+            pub name: String,
+            pub items: Vec<String>,
+        }
+
+        /// The decoder of an encoded `pard` that `ParDef::from_table` replaces.
+        pub(super) fn from_pard(pard: &[u8], pdnm: Option<&str>, data: Option<&[u8]>) -> Old {
+            let code = be_u32(pard, 12).unwrap_or(u32::MAX);
+            let fx = |at: usize| be_i32(pard, at).map(|v| f64::from(v) / 65536.0);
+            let default: Vec<f64> = match code {
+                10 => be_f64(pard, 56).into_iter().collect(),
+                2 | 3 => fx(56).into_iter().collect(),
+                1 => be_i32(pard, 56).map(f64::from).into_iter().collect(),
+                4 | 7 => be_u32(pard, 56).map(f64::from).into_iter().collect(),
+                // Fractions of the layer, or percent after an After Effects re-save (see the reader).
+                6 => {
+                    let p: Vec<f64> = [fx(56), fx(60)].into_iter().flatten().collect();
+                    if p.iter().any(|c| c.abs() > 1.0 + 1e-9) { p.iter().map(|c| c / 100.0).collect() } else { p }
+                }
+                5 => pard.get(56..60).map(|c| c.iter().map(|b| f64::from(*b)).collect()).unwrap_or_default(),
+                _ => Vec::new(),
+            };
+            let range = match code {
+                10 => be_f32(pard, 112).zip(be_f32(pard, 116)),
+                2 => fx(132).zip(fx(136)),
+                1 => be_i32(pard, 132).map(f64::from).zip(be_i32(pard, 136).map(f64::from)),
+                _ => None,
+            };
+            let valid_max = match code {
+                10 => be_f32(pard, 108),
+                2 => fx(128),
+                1 => be_i32(pard, 128).map(f64::from),
+                _ => None,
+            };
+            let pname = pard.get(16..48).map(cname).unwrap_or_default();
+            let (name, items) = match (code, pdnm) {
+                (7, Some(p)) if !p.is_empty() => (pname, p.split('|').map(str::to_string).collect()),
+                (4, Some(p)) if pname.trim().is_empty() => (p.to_string(), Vec::new()),
+                _ => (pname, Vec::new()),
+            };
+            Old { def: ParDef { record: String::new(), code, default, range, valid_max, data: data.map(<[u8]>::to_vec) }, name, items }
+        }
+
+        /// The parameter definitions of an instance's `parT`, by position (the table's index).
+        pub(super) fn par_defs(sspc: &Chunk<'_>) -> HashMap<u16, Old> {
+            let mut out = HashMap::new();
+            let Some(part) = sspc.child_list(b"parT") else { return out };
+            let k = part.children();
+            let mut i = 0usize;
+            let mut position = 0u16;
+            while i < k.len() {
+                let (Some(m), Some(p)) = (k.get(i), k.get(i + 1)) else { break };
+                if !(m.is(b"tdmn") && p.is(b"pard")) {
+                    i += 1;
+                    continue;
+                }
+                let name = tdmn_name(m).unwrap_or_default();
+                let mut j = i + 2;
+                let mut pdnm = None;
+                let mut data = None;
+                while let Some(c) = k.get(j) {
+                    if c.is(b"tdmn") {
+                        break;
+                    }
+                    if c.is(b"pdnm") {
+                        pdnm = c.children().iter().find(|u| u.is(b"Utf8")).and_then(|u| u.bytes()).map(|b| String::from_utf8_lossy(b).to_string());
+                    }
+                    if c.is(b"aRbp") {
+                        data = c.bytes();
+                    }
+                    j += 1;
+                }
+                if let Some(bytes) = p.bytes() {
+                    let mut old = from_pard(bytes, pdnm.as_deref(), data);
+                    old.def.record = name;
+                    out.insert(position, old);
+                }
+                position = position.saturating_add(1);
+                i = j;
+            }
+            out
+        }
+    }
+
+    fn bits(v: &[f64]) -> Vec<u64> {
+        v.iter().map(|x| x.to_bits()).collect()
+    }
+
+    /// Every field equal, numbers bit for bit.
+    fn assert_same(a: &HashMap<u16, reference::Old>, b: &HashMap<u16, ParDef>, what: &str) {
+        let mut keys: Vec<&u16> = a.keys().collect();
+        keys.sort_unstable();
+        assert_eq!(keys.len(), b.len(), "{what}");
+        for k in keys {
+            let (old, y) = (&a[k], b.get(k).unwrap_or_else(|| panic!("{what}: {k}")));
+            // The prototypes name no parameter and no popup item.
+            assert!(old.name.is_empty() && old.items.is_empty(), "{what}: parameter {k}");
+            let x = &old.def;
+            let range = |r: Option<(f64, f64)>| r.map(|(lo, hi)| (lo.to_bits(), hi.to_bits()));
+            assert_eq!(
+                (&x.record, x.code, bits(&x.default), range(x.range), x.valid_max.map(f64::to_bits), &x.data),
+                (&y.record, y.code, bits(&y.default), range(y.range), y.valid_max.map(f64::to_bits), &y.data),
+                "{what}: parameter {k}"
+            );
+        }
+    }
+
+    #[test]
+    fn the_table_definitions_equal_the_encoded_and_parsed_ones() {
+        for fx in FX_DEFS {
+            let parsed = reference::par_defs(&crate::export::fxsynth::default_sspc(fx));
+            assert_same(&parsed, &ParDef::of_effect(fx), fx.match_name);
+        }
+    }
+
+    #[test]
+    fn a_record_name_that_is_not_ascii_is_found_in_its_prototype() {
+        static PARAMS: [PDef; 1] = [PDef { id: 1, code: 2, default: &[0.0], range: None, valid_max: None, valid_min: None, display: 0 }];
+        let fx = FxDef { match_name: "Effekt Größe", name: "x", params: &PARAMS };
+        let record = ParDef::of_effect(&fx).get(&0).map(|d| d.record.clone()).expect("the parameter");
+        assert_eq!(record, "Effekt Größe-0001");
+        let sspc = crate::export::fxsynth::default_sspc(&fx);
+        let part = sspc.child_list(b"parT").expect("parT");
+        assert!(part.children().iter().any(|c| is_tdmn(c, &record)));
+    }
+
+    #[test]
+    fn generated_definitions_equal_the_encoded_and_parsed_ones() {
+        // Every parameter type with defaults, ranges and maxima that are fractional, negative,
+        // huge, beyond the 16.16 and f32 ranges, and not numbers.
+        let values = [0.0, -0.0, 1.0, -1.0, 0.5, 1.0 / 3.0, 1.01, 100.0, 255.4, 255.6, 256.0, -3.7, 65535.6, 70000.0, 1e9, -1e9, 1e40, f64::NAN, f64::INFINITY];
+        let mut state = 7u64;
+        let mut pick = move |n: usize| {
+            state = state.wrapping_mul(6_364_136_223_846_793_005).wrapping_add(1_442_695_040_888_963_407);
+            usize::try_from(state >> 33).unwrap_or(0) % n
+        };
+        for round in 0..400 {
+            let params: Vec<PDef> = (0..16u16)
+                .map(|id| {
+                    let code = [0u8, 1, 2, 3, 4, 5, 6, 7, 9, 10, 11, 12, 13, 14, 15][pick(15)];
+                    let default: &'static [f64] = Box::leak((0..pick(5)).map(|_| values[pick(values.len())]).collect::<Vec<_>>().into_boxed_slice());
+                    let opt = |pick: &mut dyn FnMut(usize) -> usize| (pick(3) > 0).then(|| values[pick(values.len())]);
+                    let range = opt(&mut pick).map(|lo| (lo, values[pick(values.len())]));
+                    PDef { id, code, default, range, valid_max: opt(&mut pick), valid_min: opt(&mut pick), display: u32::try_from(pick(40)).unwrap_or(0) }
+                })
+                .collect();
+            let fx =
+                FxDef { match_name: Box::leak(format!("Generated {round}").into_boxed_str()), name: "Generated", params: Box::leak(params.into_boxed_slice()) };
+            let parsed = reference::par_defs(&crate::export::fxsynth::default_sspc(&fx));
+            assert_same(&parsed, &ParDef::of_effect(&fx), fx.match_name);
+        }
+    }
+
+    fn group(effect: &str, text: (&str, &str)) -> PropGroup {
+        let spec = effectcraft_effects::find(effect).expect("the effect");
+        let mut next = 1;
+        let mut g = effectcraft_effects::instantiate(spec, &mut effectcraft_project::build::Ids(&mut next), "fx", [100.0, 100.0]);
+        g.prop_mut(text.0).expect("the text parameter").value = Value::Str(text.1.to_string());
+        g
+    }
+
+    fn invalid(col: Collector) -> Vec<String> {
+        col.finish().losses.into_iter().filter(|l| l.category == LossCategory::InvalidValues).flat_map(|l| l.details).collect()
+    }
+
+    #[test]
+    fn unreadable_curve_points_are_reported() {
+        let pdefs = defs().get("ADBE CurvesCustom").expect("the Curves prototype");
+        let mut col = Collector::default();
+        plan_curves(&group("ec.color.curves", ("rgb", "0,0 junk 0.5,0.7 nan,1 1,1")), pdefs, "fx", &mut col);
+        let found = invalid(col);
+        assert!(found.iter().any(|d| d.contains("curve 'rgb': 2 entries")), "{found:?}");
+        let mut col = Collector::default();
+        plan_curves(&group("ec.color.curves", ("rgb", "0,0 0.5,0.7 1,1")), pdefs, "fx", &mut col);
+        assert_eq!(invalid(col), Vec::<String>::new());
+    }
+
+    #[test]
+    fn unreadable_mesh_entries_are_reported() {
+        let pdefs = defs().get("ADBE MESH WARP").expect("the Mesh Warp prototype");
+        let mut col = Collector::default();
+        plan_mesh(&group("ec.distort.meshwarp", ("mesh", "0,0 x,1 2")), pdefs, (100.0, 100.0), "fx", &mut col);
+        let found = invalid(col);
+        assert!(found.iter().any(|d| d.contains("2 entries that are not numbers")), "{found:?}");
+        let mut col = Collector::default();
+        plan_mesh(&group("ec.distort.meshwarp", ("mesh", "0,0 1,1")), pdefs, (100.0, 100.0), "fx", &mut col);
+        assert_eq!(invalid(col), Vec::<String>::new());
+    }
+}
diff --git a/crates/aep/src/export/emit.rs b/crates/aep/src/export/emit.rs
index e7423efe9..f3a4859be 100644
--- a/crates/aep/src/export/emit.rs
+++ b/crates/aep/src/export/emit.rs
@@ -7,6 +7,7 @@ use crate::{AepFile, Chunk};
 use effectcraft_project::{ItemId, LayerId};
 
 use crate::export::plan::{CompPlan, Entry, ItemPlan, KeyPlan, LayerPlan, LayerSrc, ProjectPlan, PropKind, PropPlan, SolidPlan, natural_key};
+use crate::export::synth::tdmn_name;
 use crate::export::template::Template;
 use crate::export::tree::{
     R, child_data, data_mut, kids_mut, list_mut, put, put_bits, put_cstr, put_f32, put_f64, put_i32, put_u8, put_u16, put_u32, set_utf8, tpl,
@@ -659,11 +660,6 @@ const GROUP_ORDER: [&str; 13] = [
     "ADBE Group End",
 ];
 
-fn tdmn_name(c: &Chunk<'_>) -> Option<String> {
-    let d = c.bytes()?;
-    Some(d.iter().take_while(|b| **b != 0).map(|b| char::from(*b)).collect())
-}
-
 /// Inserts the properties of `lp` into the layer's Transform group, in the order the file uses.
 fn put_properties(cx: &Cx<'_>, layr: &mut Chunk<'static>, lp: &LayerPlan, cp: &CompPlan) -> R<()> {
     if lp.props.is_empty() {
diff --git a/crates/aep/src/export/fxsynth.rs b/crates/aep/src/export/fxsynth.rs
index cce25b6f2..8b9eff5dc 100644
--- a/crates/aep/src/export/fxsynth.rs
+++ b/crates/aep/src/export/fxsynth.rs
@@ -39,7 +39,17 @@ pub(crate) fn value_spec(code: u8, range: Option<(f64, f64)>) -> Option<RecSpec>
 }
 
 fn fixed(v: f64) -> [u8; 4] {
-    ((v * 65536.0).round().clamp(f64::from(i32::MIN), f64::from(i32::MAX)) as i32).to_be_bytes()
+    fixed_i32(v).to_be_bytes()
+}
+
+/// A number as the 16.16 `i32` a `pard` stores it in (rounded, within the `i32` range).
+pub(crate) fn fixed_i32(v: f64) -> i32 {
+    (v * 65536.0).round().clamp(f64::from(i32::MIN), f64::from(i32::MAX)) as i32
+}
+
+/// A number as the `i32` of an integer slider's `pard` (rounded).
+pub(crate) fn int_i32(v: f64) -> i32 {
+    v.round() as i32
 }
 
 /// The 148-byte `pard` of a parameter: the type at 12, the default at 56 and the copies After
@@ -70,7 +80,7 @@ fn pard_layout(p: &PDef, popup_items: Option<u16>) -> Fixed {
             b.put(56, &fixed(d(0)));
             b.put(60, &fixed(d(0)));
         }
-        1 => b.put(56, &(d(0).round() as i32).to_be_bytes()),
+        1 => b.put(56, &int_i32(d(0)).to_be_bytes()),
         // A checkbox: the default again as a byte at 60.
         4 => {
             b.put(56, &(d(0).round().max(0.0) as u32).to_be_bytes());
@@ -115,7 +125,7 @@ fn pard_layout(p: &PDef, popup_items: Option<u16>) -> Fixed {
             }
         }
         1 | 2 => {
-            let enc = |v: f64| if p.code == 2 { fixed(v) } else { (v.round() as i32).to_be_bytes() };
+            let enc = |v: f64| if p.code == 2 { fixed(v) } else { int_i32(v).to_be_bytes() };
             if let Some(m) = p.valid_min {
                 b.put(124, &enc(m));
             }
diff --git a/crates/aep/src/export/plan.rs b/crates/aep/src/export/plan.rs
index f8aa2b3b8..5ba2c3879 100644
--- a/crates/aep/src/export/plan.rs
+++ b/crates/aep/src/export/plan.rs
@@ -2,7 +2,7 @@
 //! file's units, with everything that cannot be written already reported. Pure data; the chunks
 //! are built from it in `emit`.
 
-use std::collections::{BTreeMap, HashSet};
+use std::collections::{BTreeMap, HashMap, HashSet};
 
 use effectcraft_color::{BlendMode, Label};
 use effectcraft_keyframe::{Ease, Interp, Keyframe};
@@ -11,6 +11,7 @@ use effectcraft_time::{FrameRate, Tick};
 
 use crate::export::report::{Collector, LossCategory};
 use crate::export::timebase::{TimeBase, time_base};
+use crate::import::build::{closes_loop, components};
 
 /// No sensible coordinate, angle or percentage comes near this; larger numbers (and NaN
 /// or infinity) are written as the default.
@@ -352,24 +353,40 @@ pub(crate) fn natural_key(name: &str) -> Vec<(bool, String, u128)> {
     out
 }
 
-fn sort_entries(v: &mut [Entry]) {
-    v.sort_by(|a, b| {
-        let ka = natural_key(&a.name);
-        let kb = natural_key(&b.name);
-        let cmp = |x: &(bool, String, u128), y: &(bool, String, u128)| match (x.0, y.0) {
-            (true, true) => x.2.cmp(&y.2).then_with(|| x.1.cmp(&y.1)),
-            (false, false) => x.1.cmp(&y.1),
-            (true, false) => std::cmp::Ordering::Less,
-            (false, true) => std::cmp::Ordering::Greater,
-        };
-        for (x, y) in ka.iter().zip(kb.iter()) {
-            let c = cmp(x, y);
+/// A [`natural_key`] ordered segment by segment: a number before text, numbers by value and then
+/// by their digits, text by its lowercase string, and a key that is a prefix of the other first.
+/// (The derived order of the tuples is not this one: it puts text first and compares the digits
+/// before the value.)
+#[derive(PartialEq, Eq)]
+struct Natural(Vec<(bool, String, u128)>);
+
+impl Ord for Natural {
+    fn cmp(&self, other: &Self) -> std::cmp::Ordering {
+        for (x, y) in self.0.iter().zip(other.0.iter()) {
+            let c = match (x.0, y.0) {
+                (true, true) => x.2.cmp(&y.2).then_with(|| x.1.cmp(&y.1)),
+                (false, false) => x.1.cmp(&y.1),
+                (true, false) => std::cmp::Ordering::Less,
+                (false, true) => std::cmp::Ordering::Greater,
+            };
             if c != std::cmp::Ordering::Equal {
                 return c;
             }
         }
-        ka.len().cmp(&kb.len()).then_with(|| a.ec.0.cmp(&b.ec.0))
-    });
+        self.0.len().cmp(&other.0.len())
+    }
+}
+
+impl PartialOrd for Natural {
+    fn partial_cmp(&self, other: &Self) -> Option<std::cmp::Ordering> {
+        Some(self.cmp(other))
+    }
+}
+
+/// Sorts by name in natural order, then by project id. Each name's key is built once, not on
+/// every comparison (the sort is stable, as `sort_by` is).
+fn sort_entries(v: &mut [Entry]) {
+    v.sort_by_cached_key(|e| (Natural(natural_key(&e.name)), e.ec.0));
 }
 
 /// Plans the whole project.
@@ -408,7 +425,8 @@ pub(crate) fn plan(project: &Project, col: &mut Collector) -> ProjectPlan {
             by_parent.entry(item.parent.filter(|p| project.items.contains_key(p))).or_default().push(*id);
         }
     }
-    let cx = PlanCx { project, by_parent: &by_parent, ok: &ok };
+    let component = components(&precomp_links(project));
+    let cx = PlanCx { project, by_parent: &by_parent, ok: &ok, component: &component };
     let root = plan_children(&cx, None, col);
     // The base writes an empty render queue.
     for job in &project.render_queue {
@@ -422,6 +440,8 @@ struct PlanCx<'a> {
     project: &'a Project,
     by_parent: &'a BTreeMap<Option<ItemId>, Vec<ItemId>>,
     ok: &'a HashSet<ItemId>,
+    /// The component of each composition in the precomposition links ([`precomp_loop`]).
+    component: &'a HashMap<ItemId, usize>,
 }
 
 fn plan_children(cx: &PlanCx<'_>, parent: Option<ItemId>, col: &mut Collector) -> Vec<Entry> {
@@ -627,16 +647,17 @@ fn plan_comp(cx: &PlanCx<'_>, comp_id: ItemId, name: &str, comp: &Comp, col: &mu
             cp.layers.push(lp);
         }
     }
-    resolve_parents(&mut cp, name, col);
-    resolve_mattes(&mut cp, name, col);
-    resolve_effect_layers(&mut cp, name, col);
+    // The layers that are written; none of the three steps below adds or removes one.
+    let exported: HashSet<LayerId> = cp.layers.iter().map(|l| l.ec_id).collect();
+    resolve_parents(&mut cp, &exported, name, col);
+    resolve_mattes(&mut cp, &exported, name, col);
+    resolve_effect_layers(&mut cp, &exported, name, col);
     cp
 }
 
 /// An effect's layer parameter that names a layer that is not exported falls back to the owning
 /// layer (After Effects' default) and is reported.
-fn resolve_effect_layers(cp: &mut CompPlan, comp_name: &str, col: &mut Collector) {
-    let exported: HashSet<LayerId> = cp.layers.iter().map(|l| l.ec_id).collect();
+fn resolve_effect_layers(cp: &mut CompPlan, exported: &HashSet<LayerId>, comp_name: &str, col: &mut Collector) {
     for l in &mut cp.layers {
         for fx in &mut l.fx {
             let before = fx.layers.len();
@@ -655,8 +676,7 @@ fn resolve_effect_layers(cp: &mut CompPlan, comp_name: &str, col: &mut Collector
 }
 
 /// A track matte whose layer is not exported, or is the layer itself, is dropped and reported.
-fn resolve_mattes(cp: &mut CompPlan, comp_name: &str, col: &mut Collector) {
-    let exported: HashSet<LayerId> = cp.layers.iter().map(|l| l.ec_id).collect();
+fn resolve_mattes(cp: &mut CompPlan, exported: &HashSet<LayerId>, comp_name: &str, col: &mut Collector) {
     for l in &mut cp.layers {
         if let Some((m, _)) = l.matte
             && (m == l.ec_id || !exported.contains(&m))
@@ -668,17 +688,95 @@ fn resolve_mattes(cp: &mut CompPlan, comp_name: &str, col: &mut Collector) {
 }
 
 /// Parent links to a layer that was not exported, and links that lead into a loop, are cut.
-fn resolve_parents(cp: &mut CompPlan, comp_name: &str, col: &mut Collector) {
-    let exported: HashSet<LayerId> = cp.layers.iter().map(|l| l.ec_id).collect();
-    let mut links: std::collections::HashMap<LayerId, LayerId> = cp.layers.iter().filter_map(|l| l.parent.map(|p| (l.ec_id, p))).collect();
-    for l in &mut cp.layers {
-        let Some(p) = l.parent else { continue };
+fn resolve_parents(cp: &mut CompPlan, exported: &HashSet<LayerId>, comp_name: &str, col: &mut Collector) {
+    let links: Vec<(LayerId, Option<LayerId>)> = cp.layers.iter().map(|l| (l.ec_id, l.parent)).collect();
+    let cut = parents_to_cut(&links, exported);
+    for (l, cut) in cp.layers.iter_mut().zip(cut) {
+        if cut {
+            col.lose(LossCategory::ParentLinks, format!("{comp_name}: '{}' has a parent that was not exported or forms a loop", l.name));
+            l.parent = None;
+        }
+    }
+}
+
+/// Which parent links (`(layer, parent)` in stack order) are cut: one to a layer that is not
+/// exported, and, of each loop, the link of its first layer in stack order (cutting it opens
+/// the loop, so the others stay).
+///
+/// Each parent chain used to be walked from every layer (a chain of N layers took N² steps).
+/// With unique layer ids each layer has one link, the links form chains and disjoint loops, and
+/// the layers on a loop are found once ([`loop_of`]). Repeated ids (not made by EffectCraft)
+/// keep the walk ([`parents_to_cut_by_walk`]).
+fn parents_to_cut(links: &[(LayerId, Option<LayerId>)], exported: &HashSet<LayerId>) -> Vec<bool> {
+    if exported.len() != links.len() {
+        return parents_to_cut_by_walk(links, exported);
+    }
+    let on_loop = loop_of(&links.iter().filter_map(|(l, p)| p.map(|p| (*l, p))).collect());
+    let mut opened: HashSet<usize> = HashSet::new();
+    links
+        .iter()
+        .map(|(l, p)| match p {
+            None => false,
+            Some(p) if !exported.contains(p) => true,
+            Some(_) => on_loop.get(l).is_some_and(|lp| opened.insert(*lp)),
+        })
+        .collect()
+}
+
+/// The loop each layer is on (a number per loop), for the links `layer -> parent`. Each layer is
+/// visited once.
+fn loop_of(links: &HashMap<LayerId, LayerId>) -> HashMap<LayerId, usize> {
+    // Absent: not seen; `false`: on the chain being walked; `true`: finished.
+    let mut done: HashMap<LayerId, bool> = HashMap::with_capacity(links.len());
+    let mut on_loop: HashMap<LayerId, usize> = HashMap::new();
+    let mut loops = 0usize;
+    for &start in links.keys() {
+        let mut chain = Vec::new();
+        let mut at = start;
+        loop {
+            match done.get(&at) {
+                Some(false) => {
+                    // Back on the chain: the part from `at` on is a loop.
+                    if let Some(i) = chain.iter().position(|l| *l == at) {
+                        for l in chain.get(i..).unwrap_or_default() {
+                            on_loop.insert(*l, loops);
+                        }
+                        loops = loops.saturating_add(1);
+                    }
+                    break;
+                }
+                Some(true) => break,
+                None => {}
+            }
+            done.insert(at, false);
+            chain.push(at);
+            match links.get(&at) {
+                Some(next) => at = *next,
+                None => break,
+            }
+        }
+        for l in chain {
+            done.insert(l, true);
+        }
+    }
+    on_loop
+}
+
+/// [`parents_to_cut`] by following each chain from its layer (for repeated layer ids): a chain
+/// longer than the number of links is a loop.
+fn parents_to_cut_by_walk(layers: &[(LayerId, Option<LayerId>)], exported: &HashSet<LayerId>) -> Vec<bool> {
+    let mut links: HashMap<LayerId, LayerId> = layers.iter().filter_map(|(l, p)| p.map(|p| (*l, p))).collect();
+    let mut out = Vec::with_capacity(layers.len());
+    for (l, p) in layers {
+        let Some(p) = *p else {
+            out.push(false);
+            continue;
+        };
         let mut cut = !exported.contains(&p);
         if !cut {
-            // Follow the chain; a chain longer than the number of links is a loop.
             let mut at = p;
             for _ in 0..=links.len() {
-                if at == l.ec_id {
+                if at == *l {
                     cut = true;
                     break;
                 }
@@ -687,16 +785,16 @@ fn resolve_parents(cp: &mut CompPlan, comp_name: &str, col: &mut Collector) {
                     None => break,
                 }
             }
-            if !cut && at == l.ec_id {
+            if !cut && at == *l {
                 cut = true;
             }
         }
         if cut {
-            col.lose(LossCategory::ParentLinks, format!("{comp_name}: '{}' has a parent that was not exported or forms a loop", l.name));
-            links.remove(&l.ec_id);
-            l.parent = None;
+            links.remove(l);
         }
+        out.push(cut);
     }
+    out
 }
 
 /// The source of a layer and its size; `None` (with a loss) for a layer that is not written.
@@ -761,7 +859,7 @@ fn plan_source(
             }
         },
         LayerSource::Comp { item } => match cx.project.item(*item).filter(|_| cx.ok.contains(item)).map(|i| &i.kind) {
-            Some(ItemKind::Comp(c)) if !precomp_loop(cx.project, comp_id, *item) => {
+            Some(ItemKind::Comp(c)) if !precomp_loop(cx.component, comp_id, *item) => {
                 (LayerSrc::Comp(*item), (c.width.clamp(1, MAX_SIDE), c.height.clamp(1, MAX_SIDE)))
             }
             Some(ItemKind::Comp(_)) => {
@@ -1115,27 +1213,28 @@ fn has_bezier_keys(g: &effectcraft_project::PropGroup, depth: usize) -> bool {
     })
 }
 
-/// Whether showing the composition `to` inside `from` closes a loop (`to` is `from`, or uses it
-/// through its own precomposition layers). The walk is iterative and visits each item once.
-fn precomp_loop(project: &Project, from: ItemId, to: ItemId) -> bool {
-    let mut seen: HashSet<ItemId> = HashSet::new();
-    let mut stack = vec![to];
-    while let Some(at) = stack.pop() {
-        if at == from {
-            return true;
-        }
-        if !seen.insert(at) {
-            continue;
-        }
-        if let Some(ItemKind::Comp(c)) = project.item(at).map(|i| &i.kind) {
-            for l in &c.layers {
+/// Every precomposition link of the project once: composition -> the items its layers show.
+fn precomp_links(project: &Project) -> HashMap<ItemId, HashSet<ItemId>> {
+    let mut links: HashMap<ItemId, HashSet<ItemId>> = HashMap::new();
+    for (id, item) in &project.items {
+        if let ItemKind::Comp(c) = &item.kind {
+            for l in c.layers.iter() {
                 if let LayerSource::Comp { item } = &l.source {
-                    stack.push(*item);
+                    links.entry(*id).or_default().insert(*item);
                 }
             }
         }
     }
-    false
+    links
+}
+
+/// Whether showing the composition `to` in `from` closes a loop: `to` is `from` or uses it
+/// through its own precomposition layers. The layer itself links `from` to `to`, so `to` uses
+/// `from` exactly when both are in one component of the project's precomposition links
+/// (`component`, found once per export). Before, every precomposition layer walked the layers of
+/// every composition below its source (N layers of a precomposition with N layers took N² steps).
+fn precomp_loop(component: &HashMap<ItemId, usize>, from: ItemId, to: ItemId) -> bool {
+    closes_loop(from, to, |to| matches!((component.get(&from), component.get(&to)), (Some(a), Some(b)) if a == b))
 }
 
 /// The names of a layer's Material Options that differ from a new layer's (value, keys or an
@@ -1341,3 +1440,212 @@ fn plan_remap(p: &Property, comp: &Comp, cp: &CompPlan, layer: &str, comp_name:
     }
     plan
 }
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    /// The comparator as it was written before the keys were cached (the reference).
+    fn old_cmp(a: &str, b: &str) -> std::cmp::Ordering {
+        let (ka, kb) = (natural_key(a), natural_key(b));
+        let cmp = |x: &(bool, String, u128), y: &(bool, String, u128)| match (x.0, y.0) {
+            (true, true) => x.2.cmp(&y.2).then_with(|| x.1.cmp(&y.1)),
+            (false, false) => x.1.cmp(&y.1),
+            (true, false) => std::cmp::Ordering::Less,
+            (false, true) => std::cmp::Ordering::Greater,
+        };
+        for (x, y) in ka.iter().zip(kb.iter()) {
+            let c = cmp(x, y);
+            if c != std::cmp::Ordering::Equal {
+                return c;
+            }
+        }
+        ka.len().cmp(&kb.len())
+    }
+
+    /// A pseudo-random generator for the differential tests.
+    fn lcg(seed: u64) -> impl FnMut(u64) -> u64 {
+        let mut state = seed;
+        move |n| {
+            state = state.wrapping_mul(6_364_136_223_846_793_005).wrapping_add(1_442_695_040_888_963_407);
+            (state >> 33) % n.max(1)
+        }
+    }
+
+    #[test]
+    fn parent_links_are_cut_as_the_walk_cut_them() {
+        for seed in 0..500 {
+            let mut next = lcg(seed);
+            let n = 1 + next(12);
+            // Unique ids, or (one seed in five) some repeated; parents among the layers, missing
+            // ones (not exported) and none.
+            let ids: Vec<LayerId> = (0..n).map(|i| LayerId(if seed % 5 == 0 { next(n) } else { i })).collect();
+            let links: Vec<(LayerId, Option<LayerId>)> = ids
+                .iter()
+                .map(|l| {
+                    let p = match next(4) {
+                        0 => None,
+                        1 => Some(LayerId(100 + next(3))),
+                        _ => Some(LayerId(next(n))),
+                    };
+                    (*l, p)
+                })
+                .collect();
+            let exported: HashSet<LayerId> = ids.iter().copied().collect();
+            assert_eq!(parents_to_cut(&links, &exported), parents_to_cut_by_walk(&links, &exported), "{links:?}");
+        }
+    }
+
+    #[test]
+    fn a_long_parent_chain_is_resolved_in_linear_time() {
+        // 200 000 layers each parented to the next and the last to the first: one link is cut.
+        // Walking the chain from every layer (as before) is 4e10 steps.
+        let n = 200_000u64;
+        let links: Vec<(LayerId, Option<LayerId>)> = (0..n).map(|i| (LayerId(i), Some(LayerId((i + 1) % n)))).collect();
+        let exported: HashSet<LayerId> = (0..n).map(LayerId).collect();
+        let cut = parents_to_cut(&links, &exported);
+        assert_eq!(cut.iter().filter(|c| **c).count(), 1);
+        assert!(cut[0]);
+    }
+
+    /// The loop check as it was (the reference): a walk from `to` over the layers of every
+    /// composition below it.
+    fn old_precomp_loop(project: &Project, from: ItemId, to: ItemId) -> bool {
+        let mut seen: HashSet<ItemId> = HashSet::new();
+        let mut stack = vec![to];
+        while let Some(at) = stack.pop() {
+            if at == from {
+                return true;
+            }
+            if !seen.insert(at) {
+                continue;
+            }
+            if let Some(ItemKind::Comp(c)) = project.item(at).map(|i| &i.kind) {
+                for l in c.layers.iter() {
+                    if let LayerSource::Comp { item } = &l.source {
+                        stack.push(*item);
+                    }
+                }
+            }
+        }
+        false
+    }
+
+    /// A project with `comps` compositions; composition `i` shows the items `shows(i)` (repeats
+    /// and non-compositions allowed), as layers.
+    fn project_of(comps: usize, shows: &mut dyn FnMut(usize) -> Vec<usize>) -> (Project, Vec<ItemId>) {
+        use effectcraft_project::build;
+        let mut p = Project::default();
+        let solid = p.add_item(
+            "S",
+            effectcraft_color::Label::None,
+            None,
+            ItemKind::Solid(effectcraft_project::Solid { color: [0.0; 3], width: 4, height: 4, pixel_aspect: 1.0 }),
+        );
+        let ids: Vec<ItemId> = (0..comps)
+            .map(|i| {
+                let c = Comp::new(4, 4, effectcraft_time::FrameRate::new(25, 1), Tick(effectcraft_time::TICKS_PER_SECOND));
+                p.add_item(&format!("C{i}"), effectcraft_color::Label::None, None, ItemKind::Comp(std::sync::Arc::new(c)))
+            })
+            .collect();
+        for (i, id) in ids.iter().enumerate() {
+            let Some(mut c) = p.comp(*id).cloned() else { continue };
+            for s in shows(i) {
+                let source = match ids.get(s) {
+                    Some(item) => LayerSource::Comp { item: *item },
+                    None => LayerSource::Solid { item: solid },
+                };
+                let l = build::layer(&mut p, &c, "L", source, (4, 4), None);
+                c.layers.push(l);
+            }
+            if let Some(item) = p.item_mut(*id) {
+                item.kind = ItemKind::Comp(std::sync::Arc::new(c));
+            }
+        }
+        (p, ids)
+    }
+
+    #[test]
+    fn precomp_loops_are_found_as_the_walk_found_them() {
+        for seed in 0..300 {
+            let mut next = lcg(seed);
+            let comps = 1 + usize::try_from(next(10)).unwrap_or(0);
+            let (p, ids) = project_of(comps, &mut |_| (0..next(6)).map(|_| usize::try_from(next(comps as u64 + 2)).unwrap_or(0)).collect());
+            let component = components(&precomp_links(&p));
+            for from in &ids {
+                let Some(c) = p.comp(*from) else { continue };
+                for l in c.layers.iter() {
+                    if let LayerSource::Comp { item } = &l.source {
+                        assert_eq!(precomp_loop(&component, *from, *item), old_precomp_loop(&p, *from, *item), "{from:?} -> {item:?}");
+                    }
+                }
+            }
+        }
+    }
+
+    #[test]
+    fn layered_precomps_are_checked_in_linear_time() {
+        // K top compositions each show K middle ones, each of which shows K leaves: the old walk
+        // from every layer took K^3 steps; the components are found once.
+        let k = 60;
+        let (p, ids) = project_of(3 * k, &mut |i| if i < 2 * k { (0..k).map(|j| if i < k { k + j } else { 2 * k + j }).collect() } else { Vec::new() });
+        let component = components(&precomp_links(&p));
+        let mut checked = 0;
+        for from in &ids {
+            let Some(c) = p.comp(*from) else { continue };
+            for l in c.layers.iter() {
+                if let LayerSource::Comp { item } = &l.source {
+                    assert!(!precomp_loop(&component, *from, *item));
+                    checked += 1;
+                }
+            }
+        }
+        assert_eq!(checked, 2 * k * k);
+        // One more layer, a leaf showing a top composition, closes a loop through all three.
+        let (p, ids) = project_of(3 * k, &mut |i| match i {
+            _ if i < k => (k..2 * k).collect(),
+            _ if i < 2 * k => (2 * k..3 * k).collect(),
+            _ if i == 2 * k => vec![0],
+            _ => Vec::new(),
+        });
+        let component = components(&precomp_links(&p));
+        assert!(precomp_loop(&component, ids[2 * k], ids[0]));
+        assert!(precomp_loop(&component, ids[0], ids[k]));
+        assert!(!precomp_loop(&component, ids[k], ids[2 * k + 1]));
+    }
+
+    #[test]
+    fn the_cached_natural_key_orders_as_the_comparator_did() {
+        let names = [
+            "",
+            "a",
+            "A",
+            "a1",
+            "a01",
+            "a001",
+            "a2",
+            "a10",
+            "1",
+            "01",
+            "001",
+            "10",
+            "1a",
+            "a b",
+            "a-b",
+            "Comp 2",
+            "comp 10",
+            "Comp 1 copy",
+            "ß",
+            "Ä 3",
+            "x99999999999999999999999999999999999999999999",
+            "x100000000000000000000000000000000000000000000",
+            "Solids",
+            "solids 0",
+        ];
+        for a in names {
+            for b in names {
+                assert_eq!(Natural(natural_key(a)).cmp(&Natural(natural_key(b))), old_cmp(a, b), "{a:?} {b:?}");
+            }
+        }
+    }
+}
diff --git a/crates/aep/src/import.rs b/crates/aep/src/import.rs
index fae3b3256..f9f14511e 100644
--- a/crates/aep/src/import.rs
+++ b/crates/aep/src/import.rs
@@ -24,7 +24,7 @@
 //! for wasm32; it reads no files itself: the caller passes the bytes, a way to ask whether a
 //! footage path exists and one to ask whether a font is installed.
 
-mod build;
+pub(crate) mod build;
 mod camera;
 mod effects;
 mod lumetri;
diff --git a/crates/aep/src/import/build.rs b/crates/aep/src/import/build.rs
index 5a55c557a..8d1f640c0 100644
--- a/crates/aep/src/import/build.rs
+++ b/crates/aep/src/import/build.rs
@@ -56,7 +56,7 @@ struct PendingComp<'f, 'a> {
 struct Ctx<'o> {
     sources: HashMap<u32, Source>,
     /// Which comps use which comps as precomps (to refuse loops).
-    uses: HashMap<ItemId, Vec<ItemId>>,
+    precomps: Precomps,
     created: Vec<ItemId>,
     col: Collector,
     options: &'o ImportOptions<'o>,
@@ -69,7 +69,7 @@ struct Ctx<'o> {
 pub(crate) fn run(project: &mut Project, view: &AepProject<'_, '_>, options: &ImportOptions<'_>) -> (ItemId, Vec<ItemId>, Vec<ItemId>, ImportReport) {
     let mut cx = Ctx {
         sources: HashMap::new(),
-        uses: HashMap::new(),
+        precomps: Precomps::default(),
         created: Vec::new(),
         col: Collector::default(),
         options,
@@ -101,9 +101,9 @@ pub(crate) fn run(project: &mut Project, view: &AepProject<'_, '_>, options: &Im
                 // After Effects writes an `Sfdr` even for an empty folder (and other chunks next to the
                 // items in it); without one the contents are lost.
                 if !item.has_folder_contents() {
-                    cx.col.lose(LossCategory::DamagedData, format!("folder '{name}': its contents list is missing, imported empty"));
+                    cx.col.lose_with(LossCategory::DamagedData, || format!("folder '{name}': its contents list is missing, imported empty"));
                 } else if item.folder_contents_unreadable() {
-                    cx.col.lose(LossCategory::DamagedData, format!("folder '{name}': its contents list is damaged, imported empty"));
+                    cx.col.lose_with(LossCategory::DamagedData, || format!("folder '{name}': its contents list is damaged, imported empty"));
                 }
                 let mut kids: Vec<_> = item.children().map(|k| (k, id)).collect();
                 kids.reverse();
@@ -112,16 +112,16 @@ pub(crate) fn run(project: &mut Project, view: &AepProject<'_, '_>, options: &Im
             Some(AepKind::Composition) => {
                 let name = if name.is_empty() { "Composition".to_string() } else { name };
                 let Some(comp_view) = item.comp() else {
-                    cx.col.lose(LossCategory::DamagedData, format!("composition '{name}': composition data missing, not imported"));
+                    cx.col.lose_with(LossCategory::DamagedData, || format!("composition '{name}': composition data missing, not imported"));
                     continue;
                 };
                 let Some(header) = comp_view.header() else {
-                    cx.col.lose(LossCategory::DamagedData, format!("composition '{name}': header unreadable, not imported"));
+                    cx.col.lose_with(LossCategory::DamagedData, || format!("composition '{name}': header unreadable, not imported"));
                     continue;
                 };
                 let tb = header.time_base;
                 let Some(rate) = frame_rate(tb.timescale, tb.frame_duration) else {
-                    cx.col.lose(LossCategory::DamagedData, format!("composition '{name}': time base unreadable, not imported"));
+                    cx.col.lose_with(LossCategory::DamagedData, || format!("composition '{name}': time base unreadable, not imported"));
                     continue;
                 };
                 let map = TimeMap { timescale: tb.timescale, frame_duration: tb.frame_duration, rate };
@@ -137,12 +137,13 @@ pub(crate) fn run(project: &mut Project, view: &AepProject<'_, '_>, options: &Im
                 pending.push(PendingComp { id, item, map });
             }
             Some(AepKind::Footage) => import_footage(project, &mut cx, &item, name, label, parent, &null_only),
-            Some(AepKind::Other(code)) => cx.col.lose(LossCategory::UnsupportedItems, format!("'{name}': item type {code}")),
+            Some(AepKind::Other(code)) => cx.col.lose_with(LossCategory::UnsupportedItems, || format!("'{name}': item type {code}")),
             None => cx.col.lose(LossCategory::DamagedData, "a project item without a readable type".to_string()),
         }
     }
 
     // Pass 2: the layers. The effect definitions are indexed once for every layer of every comp.
+    cx.precomps = Precomps::new(&precomp_candidates(&cx.sources, &pending));
     let defs = view.effect_definition_index();
     for p in &pending {
         build_layers(project, &mut cx, &defs, p);
@@ -185,12 +186,12 @@ fn new_comp(h: &CompHeader, renderer: Option<AepRenderer>, map: &TimeMap, name:
     comp.work_area = if start >= Tick::ZERO && end > start {
         (start, end)
     } else {
-        col.lose(LossCategory::DamagedData, format!("composition '{name}': the work area is empty or negative, the whole composition is used"));
+        col.lose_with(LossCategory::DamagedData, || format!("composition '{name}': the work area is empty or negative, the whole composition is used"));
         (Tick::ZERO, duration)
     };
     comp.background = h.background.map(|c| f32::from(c) / 255.0);
     comp.pixel_aspect = h.pixel_aspect.to_f64().filter(|v| v.is_finite() && *v > 0.0).unwrap_or_else(|| {
-        col.lose(LossCategory::DamagedData, format!("composition '{name}': the pixel aspect ratio is not valid, 1 is used"));
+        col.lose_with(LossCategory::DamagedData, || format!("composition '{name}': the pixel aspect ratio is not valid, 1 is used"));
         1.0
     });
     comp.shutter_angle = f64::from(h.shutter_angle);
@@ -210,7 +211,7 @@ fn new_comp(h: &CompHeader, renderer: Option<AepRenderer>, map: &TimeMap, name:
 /// Unreadable footage is recorded as a loss, solids and null placeholders are handled separately, and file and sequence footage is linked to its files.
 fn import_footage(project: &mut Project, cx: &mut Ctx<'_>, item: &AepItem<'_, '_>, name: String, label: Label, parent: ItemId, null_only: &HashSet<u32>) {
     let Some(f) = item.footage() else {
-        cx.col.lose(LossCategory::DamagedData, format!("footage '{name}': data unreadable, not imported"));
+        cx.col.lose_with(LossCategory::DamagedData, || format!("footage '{name}': data unreadable, not imported"));
         return;
     };
     let aep_id = item.id();
@@ -229,7 +230,7 @@ fn import_footage(project: &mut Project, cx: &mut Ctx<'_>, item: &AepItem<'_, '_
         let mut rgb = f.solid_rgb().unwrap_or([0.0; 3]);
         if rgb.iter().any(|c| !c.is_finite()) {
             rgb = rgb.map(|c| if c.is_finite() { c } else { 0.0 });
-            cx.col.lose(LossCategory::DamagedData, format!("solid '{name}': a color channel is not a number, replaced by 0"));
+            cx.col.lose_with(LossCategory::DamagedData, || format!("solid '{name}': a color channel is not a number, replaced by 0"));
         }
         let solid = Solid { color: rgb, width: f.width, height: f.height, pixel_aspect: 1.0 };
         let id = project.add_item(&name, label, Some(parent), ItemKind::Solid(solid));
@@ -262,10 +263,9 @@ fn import_footage(project: &mut Project, cx: &mut Ctx<'_>, item: &AepItem<'_, '_
         let bytes = len(folder.len().saturating_add(1)).saturating_mul(u64::from(frames)).saturating_add(file_bytes);
         if frames > MAX_SEQUENCE_FRAMES || frames > cx.sequence_budget || bytes > cx.sequence_bytes {
             // Not expanded: the item keeps its first file (a still standing for the sequence).
-            cx.col.lose(
-                LossCategory::DamagedData,
-                format!("footage '{name}': a sequence of {frames} frames is longer than the import expands; only its first file is linked"),
-            );
+            cx.col.lose_with(LossCategory::DamagedData, || {
+                format!("footage '{name}': a sequence of {frames} frames is longer than the import expands; only its first file is linked")
+            });
             path = format!("{folder}{sep}{}", seq.nth_file_name(0).unwrap_or_default());
         } else {
             cx.sequence_budget -= frames;
@@ -277,7 +277,7 @@ fn import_footage(project: &mut Project, cx: &mut Ctx<'_>, item: &AepItem<'_, '_
         }
     } else if f.is_sequence && !path.is_empty() {
         // The alias is a folder, but the file names could not be read: the item links the folder.
-        cx.col.lose(LossCategory::DamagedData, format!("footage '{name}': image sequence naming not read, linked to its folder"));
+        cx.col.lose_with(LossCategory::DamagedData, || format!("footage '{name}': image sequence naming not read, linked to its folder"));
     }
     let present = !path.is_empty() && (cx.options.exists)(&path);
     if !present {
@@ -478,10 +478,13 @@ fn build_layers(project: &mut Project, cx: &mut Ctx<'_>, defs: &EffectDefinition
     let mut layer_refs: Vec<PendingLayerRef> = Vec::new();
     // The id of the layer above in the file (the matte of the older "layer above" form).
     let mut above: Option<u32> = None;
+    // The comps that use this one, directly or through others: a precomp layer of one of them
+    // would close a loop. Found once, at the first precomp layer (see `Precomps`).
+    let mut users: Option<HashSet<ItemId>> = None;
 
     for layer in comp_view.layers() {
         let Some(h) = layer.header() else {
-            cx.col.lose(LossCategory::DamagedData, format!("{comp_name}: a layer header is unreadable, layer not imported"));
+            cx.col.lose_with(LossCategory::DamagedData, || format!("{comp_name}: a layer header is unreadable, layer not imported"));
             above = None;
             continue;
         };
@@ -545,11 +548,10 @@ fn build_layers(project: &mut Project, cx: &mut Ctx<'_>, defs: &EffectDefinition
                 SourceKind::Solid => (LayerSource::Solid { item: s.item }, (s.width.max(1), s.height.max(1))),
                 SourceKind::Footage => (LayerSource::Footage { item: s.item }, (s.width.max(1), s.height.max(1))),
                 SourceKind::Comp => {
-                    if would_loop(&cx.uses, p.id, s.item) {
+                    if !cx.precomps.accept(p.id, s.item, &mut users) {
                         skip(cx, &mut skipped, LossCategory::UnsupportedLayers, "precomposition loop, layer");
                         continue;
                     }
-                    cx.uses.entry(p.id).or_default().push(s.item);
                     (LayerSource::Comp { item: s.item }, (s.width.max(1), s.height.max(1)))
                 }
             },
@@ -571,7 +573,7 @@ fn build_layers(project: &mut Project, cx: &mut Ctx<'_>, defs: &EffectDefinition
             Some(b) => l.blend_mode = b,
             // Cameras and lights have no blend mode (their byte is 0, 251).
             None if is_camera || light.is_some() => {}
-            None => cx.col.lose(LossCategory::BlendModes, format!("{comp_name}: '{name}' uses blend mode code {}", h.blend_mode.code())),
+            None => cx.col.lose_with(LossCategory::BlendModes, || format!("{comp_name}: '{name}' uses blend mode code {}", h.blend_mode.code())),
         }
         let what = format!("{comp_name}: '{name}'");
         l.markers = import_markers(layer.markers(), layer.chunk(), &what, &tm, &mut cx.col);
@@ -640,9 +642,13 @@ fn build_layers(project: &mut Project, cx: &mut Ctx<'_>, defs: &EffectDefinition
         comp.layers.push(l);
     }
 
-    resolve_parents(&mut comp, &parents, &ids, &skipped, &comp_name, &mut cx.col);
-    resolve_mattes(&mut comp, &mattes, &ids, &skipped, &comp_name, &mut cx.col);
-    resolve_layer_refs(&mut comp, &layer_refs, &ids, &mut cx.col);
+    // Project layer id -> position in `comp.layers` (the first, as `Comp::layer_mut` finds it):
+    // one lookup per link instead of a scan of the layers, which made a composition of many
+    // parented, matted or referenced layers quadratic.
+    let at = layer_positions(&comp);
+    resolve_parents(&mut comp, &at, &parents, &ids, &skipped, &comp_name, &mut cx.col);
+    resolve_mattes(&mut comp, &at, &mattes, &ids, &skipped, &comp_name, &mut cx.col);
+    resolve_layer_refs(&mut comp, &at, &layer_refs, &ids, &mut cx.col);
     // Global Light is one setting per composition here: the layers' stored values are adopted.
     effectcraft_project::styles::sync_comp(&mut comp);
 
@@ -662,10 +668,10 @@ fn import_source_text(l: &mut Layer, layer: &AepLayer<'_, '_>, what: &str, cx: &
             let value = text_doc(&doc, what, cx.options.has_font, &mut cx.col);
             match l.props.prop_mut("text/sourceText") {
                 Some(p) => p.value = Value::Text(Box::new(value)),
-                None => cx.col.lose(LossCategory::DamagedData, format!("{what}: the text layer has no Source Text property, the text is not imported")),
+                None => cx.col.lose_with(LossCategory::DamagedData, || format!("{what}: the text layer has no Source Text property, the text is not imported")),
             }
         }
-        None => cx.col.lose(LossCategory::DamagedData, format!("{what}: the text document is unreadable, the layer is imported with empty text")),
+        None => cx.col.lose_with(LossCategory::DamagedData, || format!("{what}: the text document is unreadable, the layer is imported with empty text")),
     }
     report_text_extras(layer, what, &mut cx.col);
 }
@@ -679,33 +685,176 @@ fn import_text_animators(l: &mut Layer, layer: &AepLayer<'_, '_>, what: &str, tm
     }
     match l.props.group_mut("text/animators") {
         Some(target) => import_animators(&animators, what, tm, ids, target, col),
-        None => col.lose(LossCategory::TextLayers, format!("{what}: the text layer has no animator group, its text animators are not imported")),
+        None => col.lose_with(LossCategory::TextLayers, || format!("{what}: the text layer has no animator group, its text animators are not imported")),
     }
 }
 
-/// Whether adding `to` as a precomp of `from` would close a loop.
-fn would_loop(uses: &HashMap<ItemId, Vec<ItemId>>, from: ItemId, to: ItemId) -> bool {
-    if from == to {
-        return true;
+/// Whether a precomp layer of `to` in `from` closes a loop: `to` is `from`, or `to` already uses
+/// `from` (`uses_from`, directly or through others). Shared by the import and the export.
+pub(crate) fn closes_loop(from: ItemId, to: ItemId, uses_from: impl FnOnce(ItemId) -> bool) -> bool {
+    to == from || uses_from(to)
+}
+
+/// The walk's own stack in [`components`]: a node, the nodes it links to and how many are done.
+type Walk = Vec<(ItemId, Vec<ItemId>, usize)>;
+
+/// The strongly connected components of the graph `edges` (node -> the nodes it links to): each
+/// node's component number (every node of a loop has the same one). Iterative (Tarjan), linear in
+/// nodes and links.
+pub(crate) fn components(edges: &HashMap<ItemId, HashSet<ItemId>>) -> HashMap<ItemId, usize> {
+    struct Tarjan<'e> {
+        edges: &'e HashMap<ItemId, HashSet<ItemId>>,
+        index: HashMap<ItemId, usize>,
+        low: HashMap<ItemId, usize>,
+        on_stack: HashSet<ItemId>,
+        stack: Vec<ItemId>,
+        counter: usize,
     }
-    let mut seen = HashSet::new();
-    let mut stack = vec![to];
-    while let Some(c) = stack.pop() {
-        if c == from {
-            return true;
-        }
-        if seen.insert(c) {
-            stack.extend(uses.get(&c).into_iter().flatten().copied());
+    impl Tarjan<'_> {
+        fn enter(&mut self, n: ItemId, walk: &mut Walk) {
+            self.index.insert(n, self.counter);
+            self.low.insert(n, self.counter);
+            self.counter = self.counter.saturating_add(1);
+            self.stack.push(n);
+            self.on_stack.insert(n);
+            walk.push((n, self.edges.get(&n).map(|s| s.iter().copied().collect()).unwrap_or_default(), 0));
         }
     }
-    false
+    let mut t = Tarjan { edges, index: HashMap::new(), low: HashMap::new(), on_stack: HashSet::new(), stack: Vec::new(), counter: 0 };
+    let mut component: HashMap<ItemId, usize> = HashMap::new();
+    let mut found = 0usize;
+    for &root in edges.keys() {
+        if t.index.contains_key(&root) {
+            continue;
+        }
+        let mut walk: Walk = Vec::new();
+        t.enter(root, &mut walk);
+        while let Some((v, next, done)) = walk.last_mut() {
+            let v = *v;
+            if let Some(w) = next.get(*done).copied() {
+                *done += 1;
+                if !t.index.contains_key(&w) {
+                    t.enter(w, &mut walk);
+                } else if t.on_stack.contains(&w) {
+                    let iw = t.index.get(&w).copied().unwrap_or(usize::MAX);
+                    if let Some(lv) = t.low.get_mut(&v) {
+                        *lv = (*lv).min(iw);
+                    }
+                }
+                continue;
+            }
+            walk.pop();
+            let lv = t.low.get(&v).copied().unwrap_or(usize::MAX);
+            if let Some((u, _, _)) = walk.last()
+                && let Some(lu) = t.low.get_mut(u)
+            {
+                *lu = (*lu).min(lv);
+            }
+            if Some(lv) == t.index.get(&v).copied() {
+                while let Some(x) = t.stack.pop() {
+                    t.on_stack.remove(&x);
+                    component.insert(x, found);
+                    if x == v {
+                        break;
+                    }
+                }
+                found = found.saturating_add(1);
+            }
+        }
+    }
+    component
+}
+
+/// The precomp links of the import: the links every precomp layer of the file could make (the
+/// candidates, known before any layer is built), and the ones accepted so far, stored as precomp
+/// -> the comps that use it.
+///
+/// A precomp layer of `to` in `from` closes a loop when `to` already uses `from` over accepted
+/// links ([`closes_loop`]). That path and the layer's own link form a loop of candidate links, so
+/// `to` and `from` share a component of the candidate graph: between components the answer is no
+/// without a search (a file without a precomp loop never searches). Within a component, the comps
+/// that use `from` are found once per composition, among that component's comps only: while
+/// `from`'s layers are built the only links added start at `from`, and a path that reaches `from`
+/// never needs one of them. (Before, every precomp layer walked the whole graph, which held one
+/// link per layer.)
+#[derive(Default)]
+struct Precomps {
+    used_by: HashMap<ItemId, HashSet<ItemId>>,
+    component: HashMap<ItemId, usize>,
+}
+
+impl Precomps {
+    /// `candidates`: comp -> the comps its layers could show.
+    fn new(candidates: &HashMap<ItemId, HashSet<ItemId>>) -> Self {
+        Precomps { used_by: HashMap::new(), component: components(candidates) }
+    }
+
+    /// Decides a precomp layer of `to` in `from`: recorded and `true`, or `false` when it closes a
+    /// loop. `users` holds the comps that use `from` once they are needed (one per composition).
+    fn accept(&mut self, from: ItemId, to: ItemId, users: &mut Option<HashSet<ItemId>>) -> bool {
+        let looped = closes_loop(from, to, |to| self.same_component(from, to) && users.get_or_insert_with(|| self.users_of(from)).contains(&to));
+        if !looped {
+            self.used_by.entry(to).or_default().insert(from);
+        }
+        !looped
+    }
+
+    /// Whether `a` and `b` are in one component of the candidate graph.
+    fn same_component(&self, a: ItemId, b: ItemId) -> bool {
+        matches!((self.component.get(&a), self.component.get(&b)), (Some(x), Some(y)) if x == y)
+    }
+
+    /// The comps of `comp`'s component that use it over accepted links, directly or through
+    /// others (each visited once).
+    fn users_of(&self, comp: ItemId) -> HashSet<ItemId> {
+        let mut found = HashSet::new();
+        let mut stack = vec![comp];
+        while let Some(c) = stack.pop() {
+            for u in self.used_by.get(&c).into_iter().flatten() {
+                if self.same_component(*u, comp) && found.insert(*u) {
+                    stack.push(*u);
+                }
+            }
+        }
+        found
+    }
+}
+
+/// Every link a precomp layer of the file could make: comp -> the comps its layers name as their
+/// source (resolved as `build_layers` resolves them).
+fn precomp_candidates(sources: &HashMap<u32, Source>, pending: &[PendingComp<'_, '_>]) -> HashMap<ItemId, HashSet<ItemId>> {
+    let mut links: HashMap<ItemId, HashSet<ItemId>> = HashMap::new();
+    for p in pending {
+        let Some(comp) = p.item.comp() else { continue };
+        for layer in comp.layers() {
+            let Some(s) = layer.header().and_then(|h| h.source_id).and_then(|s| sources.get(&s)) else { continue };
+            if s.kind == SourceKind::Comp {
+                links.entry(p.id).or_default().insert(s.item);
+            }
+        }
+    }
+    links
+}
+
+/// Each layer's position in `comp.layers`, the first one for an id that repeats.
+fn layer_positions(comp: &Comp) -> HashMap<LayerId, usize> {
+    let mut at = HashMap::with_capacity(comp.layers.len());
+    for (i, l) in comp.layers.iter().enumerate() {
+        at.entry(l.id).or_insert(i);
+    }
+    at
+}
+
+/// The layer with project id `id`, through [`layer_positions`].
+pub(crate) fn layer_at<'c>(comp: &'c mut Comp, at: &HashMap<LayerId, usize>, id: LayerId) -> Option<&'c mut Layer> {
+    comp.layers.get_mut(*at.get(&id)?)
 }
 
 fn apply_timing(l: &mut Layer, h: &LayerHeader, tm: &TimeMap, name: &str, col: &mut Collector) {
     // The exact ratio `stretch / stretch_den` (50 % is 1/2, -100 % is -1/1); a zero or unreadable
     // one is 100 %.
     let stretch = h.stretch_ratio().filter(|r| r.num != 0).unwrap_or_else(|| {
-        col.lose(LossCategory::DamagedData, format!("layer '{name}': the time stretch is zero or unreadable, 100 % is used"));
+        col.lose_with(LossCategory::DamagedData, || format!("layer '{name}': the time stretch is zero or unreadable, 100 % is used"));
         Rational { num: 1, den: 1 }
     });
     let stored = stretch.to_f64().map_or(100.0, |r| r * 100.0);
@@ -714,7 +863,9 @@ fn apply_timing(l: &mut Layer, h: &LayerHeader, tm: &TimeMap, name: &str, col: &
     // out points keep the comp times the file stores.
     l.stretch = effectcraft_project::limits::stretch(stored);
     if l.stretch.to_bits() != stored.to_bits() {
-        col.lose(LossCategory::DamagedData, format!("layer '{name}': the time stretch of {stored:e} % is outside ±1 % to ±9900 %, {} % is used", l.stretch));
+        col.lose_with(LossCategory::DamagedData, || {
+            format!("layer '{name}': the time stretch of {stored:e} % is outside ±1 % to ±9900 %, {} % is used", l.stretch)
+        });
     }
     // A stored time with a zero denominator (or a sum that overflows) has no value; it is read as 0
     // and reported, so the layer's timing never changes silently.
@@ -726,9 +877,11 @@ fn apply_timing(l: &mut Layer, h: &LayerHeader, tm: &TimeMap, name: &str, col: &
     l.start_time = tm.ticks(h.start.num, h.start.den);
     let points = [(h.in_relative, h.in_point()), (h.out_relative, h.out_point())].map(|(offset, reduced)| absolute(h.start, offset, stretch, reduced));
     if !unreadable.is_empty() {
-        col.lose(LossCategory::DamagedData, format!("layer '{name}': the stored {} time is unreadable (zero denominator), 0 is used", unreadable.join(", ")));
+        col.lose_with(LossCategory::DamagedData, || {
+            format!("layer '{name}': the stored {} time is unreadable (zero denominator), 0 is used", unreadable.join(", "))
+        });
     } else if points.iter().any(Option::is_none) {
-        col.lose(LossCategory::DamagedData, format!("layer '{name}': the in or out point is out of range, 0 is used"));
+        col.lose_with(LossCategory::DamagedData, || format!("layer '{name}': the in or out point is out of range, 0 is used"));
     }
     let [a, b] = points.map(|p| p.map_or(Tick::ZERO, |(n, d)| tm.ticks(n, d)));
     // A negative stretch reverses the layer (981-983): the stored in point is then the later
@@ -799,7 +952,15 @@ struct PendingMatte {
 /// above: that layer is used. The matte layer's video switch is imported as stored (After Effects
 /// switches it off when the matte is set, 403; EffectCraft, like After Effects, still uses a
 /// hidden layer as a matte).
-fn resolve_mattes(comp: &mut Comp, mattes: &[PendingMatte], ids: &HashMap<u32, LayerId>, skipped: &HashMap<u32, String>, comp_name: &str, col: &mut Collector) {
+fn resolve_mattes(
+    comp: &mut Comp,
+    at: &HashMap<LayerId, usize>,
+    mattes: &[PendingMatte],
+    ids: &HashMap<u32, LayerId>,
+    skipped: &HashMap<u32, String>,
+    comp_name: &str,
+    col: &mut Collector,
+) {
     for m in mattes {
         let kind = match m.matte.mode {
             MatteMode::Alpha => MatteKind::Alpha,
@@ -807,24 +968,24 @@ fn resolve_mattes(comp: &mut Comp, mattes: &[PendingMatte], ids: &HashMap<u32, L
             MatteMode::Luma => MatteKind::Luma,
             MatteMode::LumaInverted => MatteKind::LumaInverted,
             MatteMode::Other(code) => {
-                col.lose(LossCategory::TrackMattes, format!("{comp_name}: '{}' has a track matte of unknown mode {code}", m.name));
+                col.lose_with(LossCategory::TrackMattes, || format!("{comp_name}: '{}' has a track matte of unknown mode {code}", m.name));
                 continue;
             }
         };
         let Some(source) = m.matte.layer.or(m.above) else {
-            col.lose(LossCategory::TrackMattes, format!("{comp_name}: '{}' has a track matte but no layer above it", m.name));
+            col.lose_with(LossCategory::TrackMattes, || format!("{comp_name}: '{}' has a track matte but no layer above it", m.name));
             continue;
         };
         let Some(target) = ids.get(&source).copied() else {
             let why = skipped.get(&source).map_or("a layer that does not exist", |s| s.as_str());
-            col.lose(LossCategory::TrackMattes, format!("{comp_name}: '{}' has {why} as its track matte", m.name));
+            col.lose_with(LossCategory::TrackMattes, || format!("{comp_name}: '{}' has {why} as its track matte", m.name));
             continue;
         };
         if target == m.layer {
-            col.lose(LossCategory::TrackMattes, format!("{comp_name}: '{}' is its own track matte", m.name));
+            col.lose_with(LossCategory::TrackMattes, || format!("{comp_name}: '{}' is its own track matte", m.name));
             continue;
         }
-        if let Some(l) = comp.layer_mut(m.layer) {
+        if let Some(l) = layer_at(comp, at, m.layer) {
             l.track_matte = Some(TrackMatte { layer: target, kind });
             col.imported.track_mattes += 1;
         }
@@ -869,6 +1030,7 @@ fn parent_cycles(links: &HashMap<LayerId, LayerId>) -> HashSet<LayerId> {
 /// Sets the parent links that point at an imported layer, without loops.
 fn resolve_parents(
     comp: &mut Comp,
+    at: &HashMap<LayerId, usize>,
     parents: &[(u32, LayerId, String, u32)],
     ids: &HashMap<u32, LayerId>,
     skipped: &HashMap<u32, String>,
@@ -883,7 +1045,7 @@ fn resolve_parents(
             }
             None => {
                 let why = skipped.get(parent).map_or("a layer that does not exist", |s| s.as_str());
-                col.lose(LossCategory::ParentLinks, format!("{comp_name}: '{name}' has {why} as its parent"));
+                col.lose_with(LossCategory::ParentLinks, || format!("{comp_name}: '{name}' has {why} as its parent"));
             }
         }
     }
@@ -892,11 +1054,11 @@ fn resolve_parents(
     let looped: Vec<LayerId> = links.keys().copied().filter(|l| on_loop.contains(l)).collect();
     for l in &looped {
         links.remove(l);
-        let name = comp.layer(*l).map(|x| x.name.clone()).unwrap_or_default();
-        col.lose(LossCategory::ParentLinks, format!("{comp_name}: '{name}' has a parent loop"));
+        let name = at.get(l).and_then(|i| comp.layers.get(*i)).map(|x| x.name.clone()).unwrap_or_default();
+        col.lose_with(LossCategory::ParentLinks, || format!("{comp_name}: '{name}' has a parent loop"));
     }
     for (layer, parent) in links {
-        if let Some(l) = comp.layer_mut(layer) {
+        if let Some(l) = layer_at(comp, at, layer) {
             l.parent = Some(parent);
         }
     }
@@ -928,6 +1090,137 @@ mod tests {
         assert_eq!(found, [1, 2, 3, 5]);
     }
 
+    /// The loop check as it was (a walk over every link per precomp layer), the reference.
+    fn old_would_loop(uses: &HashMap<ItemId, Vec<ItemId>>, from: ItemId, to: ItemId) -> bool {
+        if from == to {
+            return true;
+        }
+        let mut seen = HashSet::new();
+        let mut stack = vec![to];
+        while let Some(c) = stack.pop() {
+            if c == from {
+                return true;
+            }
+            if seen.insert(c) {
+                stack.extend(uses.get(&c).into_iter().flatten().copied());
+            }
+        }
+        false
+    }
+
+    /// Builds the compositions `0..comps` in order, each with `layers` precomp layers of
+    /// pseudo-random compositions, deciding every layer with the old and the new check.
+    fn decide_both(comps: u64, layers: u64, seed: u64) -> usize {
+        let mut state = seed;
+        let mut next = || {
+            state = state.wrapping_mul(6_364_136_223_846_793_005).wrapping_add(1_442_695_040_888_963_407);
+            state >> 33
+        };
+        let plan: Vec<(ItemId, Vec<ItemId>)> = (0..comps).map(|c| (ItemId(c), (0..layers).map(|_| ItemId(next() % comps)).collect())).collect();
+        let mut candidates: HashMap<ItemId, HashSet<ItemId>> = HashMap::new();
+        for (from, tos) in &plan {
+            candidates.entry(*from).or_default().extend(tos.iter().copied());
+        }
+        let (mut uses, mut new) = (HashMap::<ItemId, Vec<ItemId>>::new(), Precomps::new(&candidates));
+        let mut refused = 0;
+        for (from, tos) in &plan {
+            let mut users: Option<HashSet<ItemId>> = None;
+            for to in tos {
+                let accepted = new.accept(*from, *to, &mut users);
+                assert_eq!(!accepted, old_would_loop(&uses, *from, *to), "{from:?} -> {to:?}");
+                if accepted {
+                    uses.entry(*from).or_default().push(*to);
+                } else {
+                    refused += 1;
+                }
+            }
+        }
+        refused
+    }
+
+    #[test]
+    fn the_precomp_loop_check_decides_as_the_full_walk_did() {
+        let mut refused = 0;
+        for seed in 0..200 {
+            refused += decide_both(1 + seed % 12, 1 + seed % 5, seed);
+        }
+        // Both kinds of answer occur.
+        assert!(refused > 0);
+    }
+
+    #[test]
+    fn many_layers_of_one_precomp_are_checked_in_linear_time() {
+        // C holds 200 000 layers of B, B 200 000 of A, built B first: before, every layer of C
+        // walked B's 200 000 links (4e10 steps); now no layer searches (no loop in the file).
+        let (a, b, c) = (ItemId(1), ItemId(2), ItemId(3));
+        let candidates = HashMap::from([(b, HashSet::from([a])), (c, HashSet::from([b]))]);
+        let mut p = Precomps::new(&candidates);
+        for (from, to) in [(b, a), (c, b)] {
+            let mut users = None;
+            for _ in 0..200_000 {
+                assert!(p.accept(from, to, &mut users));
+            }
+            assert!(users.is_none(), "no search");
+        }
+    }
+
+    #[test]
+    fn layered_precomps_are_checked_without_a_search() {
+        // K top comps each show K middle comps, each of which shows K leaf comps, built leaves
+        // last (the order that made each leaf's users the whole graph): K^3 steps before the
+        // components, now none. K = 300: 180 000 links.
+        let k = 300u64;
+        let (top, mid, leaf) = (|i: u64| ItemId(i), |i: u64| ItemId(1000 + i), |i: u64| ItemId(2000 + i));
+        let mut candidates: HashMap<ItemId, HashSet<ItemId>> = HashMap::new();
+        for i in 0..k {
+            candidates.insert(top(i), (0..k).map(mid).collect());
+            candidates.insert(mid(i), (0..k).map(leaf).collect());
+        }
+        let mut p = Precomps::new(&candidates);
+        for from in (0..k).map(top).chain((0..k).map(mid)) {
+            let mut users = None;
+            for to in candidates.get(&from).into_iter().flatten() {
+                assert!(p.accept(from, *to, &mut users));
+            }
+            assert!(users.is_none(), "no search");
+        }
+    }
+
+    #[test]
+    fn components_are_the_loops() {
+        let n = |i: u64| ItemId(i);
+        // 1 -> 2 -> 3 -> 1 is a loop, 4 leads into it, 5 -> 5 links to itself, 6 -> 7 ends.
+        let edges: HashMap<ItemId, HashSet<ItemId>> = [(1, 2), (2, 3), (3, 1), (4, 1), (5, 5), (6, 7)].into_iter().fold(HashMap::new(), |mut m, (a, b)| {
+            m.entry(n(a)).or_default().insert(n(b));
+            m
+        });
+        let c = components(&edges);
+        assert!(c[&n(1)] == c[&n(2)] && c[&n(2)] == c[&n(3)]);
+        let others = [4, 5, 6, 7].map(|i| c[&n(i)]);
+        assert!(others.iter().all(|x| *x != c[&n(1)]));
+        assert_eq!(others.iter().collect::<HashSet<_>>().len(), 4);
+        // A chain of 200 000 links closed into one loop, walked without recursion.
+        let big: HashMap<ItemId, HashSet<ItemId>> = (0..200_000u64).map(|i| (n(i), HashSet::from([n((i + 1) % 200_000)]))).collect();
+        let c = components(&big);
+        assert_eq!(c.values().collect::<HashSet<_>>().len(), 1);
+    }
+
+    #[test]
+    fn layer_positions_find_the_first_layer_of_an_id() {
+        let mut project = Project::default();
+        let mut comp = Comp::new(10, 10, effectcraft_time::FrameRate::new(25, 1), Tick::ZERO);
+        for (id, name) in [(5, "a"), (6, "b"), (5, "c")] {
+            let mut l = build::layer(&mut project, &comp, name, LayerSource::Null, (10, 10), None);
+            l.id = LayerId(id);
+            l.name = name.into();
+            comp.layers.push(l);
+        }
+        let at = layer_positions(&comp);
+        assert_eq!(layer_at(&mut comp, &at, LayerId(5)).map(|l| l.name.clone()).as_deref(), Some("a"));
+        assert_eq!(layer_at(&mut comp, &at, LayerId(6)).map(|l| l.name.clone()).as_deref(), Some("b"));
+        assert!(layer_at(&mut comp, &at, LayerId(7)).is_none());
+    }
+
     #[test]
     fn a_long_parent_chain_is_checked_in_linear_time() {
         // 200 000 layers each parented to the next, the last to the first: walking the chain from
diff --git a/crates/aep/src/import/effects.rs b/crates/aep/src/import/effects.rs
index e53d6a9aa..992c78cdf 100644
--- a/crates/aep/src/import/effects.rs
+++ b/crates/aep/src/import/effects.rs
@@ -34,7 +34,7 @@
 //! import. Hue/Saturation's master values and Levels' values are arbitrary data, decoded by the
 //! reader (444-446, 512-516).
 
-use crate::effect_map::{CRYPTOMATTE_OUTPUT, Conv, EFFECTS, EffectMap, Extra, HUE_SATURATION_MASTER, LEVELS_RGB, ParamMap, popup_key};
+use crate::effect_map::{CRYPTOMATTE_OUTPUT, Conv, EFFECTS, EffectMap, Extra, HUE_SATURATION_MASTER, LEVELS_RGB, ParamMap, popup_key, popup_stem};
 use crate::{
     CryptomatteData, CurvesData, DefinitionSource, Effect as AepEffect, EffectDefinitions, EffectParam, ExtractorChannels, HueSaturationData,
     Layer as AepLayer, LayerRef, LevelsData, MeshData, ParamKind, ParamValue,
@@ -83,25 +83,26 @@ pub(crate) fn import_effects<'f, 'a>(
         }
         let shown = fx.display_name().unwrap_or_else(|| fx.match_name().to_string());
         let Some(map) = EFFECTS.iter().find(|m| m.match_name == fx.match_name()) else {
-            col.lose(LossCategory::Effects, format!("{}: '{}' has the effect '{shown}' ({})", cx.comp, cx.layer, fx.match_name()));
+            col.lose_with(LossCategory::Effects, || format!("{}: '{}' has the effect '{shown}' ({})", cx.comp, cx.layer, fx.match_name()));
             continue;
         };
         let Some(spec) = effectcraft_effects::find(map.effect) else {
-            col.lose(LossCategory::Effects, format!("{}: '{}' has the effect '{shown}' ({})", cx.comp, cx.layer, fx.match_name()));
+            col.lose_with(LossCategory::Effects, || format!("{}: '{}' has the effect '{shown}' ({})", cx.comp, cx.layer, fx.match_name()));
             continue;
         };
         if defs.source(&fx) == DefinitionSource::Missing {
-            col.lose(
-                LossCategory::Effects,
-                format!("{}: '{}' has the effect '{shown}' ({}) without readable parameter definitions, not imported", cx.comp, cx.layer, fx.match_name()),
-            );
+            col.lose_with(LossCategory::Effects, || {
+                format!("{}: '{}' has the effect '{shown}' ({}) without readable parameter definitions, not imported", cx.comp, cx.layer, fx.match_name())
+            });
             continue;
         }
         let size = [f64::from(cx.size.0), f64::from(cx.size.1)];
         let mut group = effectcraft_effects::instantiate(spec, ids, &shown, size);
         match fx.enabled() {
             Some(on) => group.enabled = on,
-            None => col.lose(LossCategory::DamagedData, format!("{}: '{}': the fx switch of '{shown}' is unreadable, imported switched on", cx.comp, cx.layer)),
+            None => col.lose_with(LossCategory::DamagedData, || {
+                format!("{}: '{}': the fx switch of '{shown}' is unreadable, imported switched on", cx.comp, cx.layer)
+            }),
         }
         let params = defs.params(&fx);
         // Borrowed definitions (another instance's or the project copy) may not name every value
@@ -109,15 +110,14 @@ pub(crate) fn import_effects<'f, 'a>(
         if params.first().is_some_and(|p| p.borrowed_definition) {
             let defined: std::collections::HashSet<&str> = params.iter().map(|p| p.match_name.as_str()).collect();
             for name in fx.value_record_names().iter().filter(|n| !defined.contains(n.as_str())) {
-                col.lose(
-                    LossCategory::Effects,
+                col.lose_with(LossCategory::Effects, || {
                     format!(
                         "{}: '{}' effect '{shown}' ({}): the value record {name} has no parameter definition, not imported",
                         cx.comp,
                         cx.layer,
                         fx.match_name()
-                    ),
-                );
+                    )
+                });
             }
         }
         if map.extra == Extra::Lumetri {
@@ -182,7 +182,7 @@ fn import_param(fx: &AepEffect<'_, '_>, map: &EffectMap, p: &EffectParam<'_, '_>
         // Not in the table: lost only when the file stores something for it. A layer parameter
         // set to no layer (its record always exists, Timewarp's Matte Layer 529) holds nothing.
         if p.stored().is_some() && !matches!(p.stored_value(), Some(ParamValue::Layer(0))) {
-            col.lose(LossCategory::Effects, format!("{here}: parameter {label} not imported"));
+            col.lose_with(LossCategory::Effects, || format!("{here}: parameter {label} not imported"));
         }
         return;
     };
@@ -195,7 +195,7 @@ pub(crate) fn import_mapped(p: &EffectParam<'_, '_>, m: &ParamMap, cx: &LayerCtx
     let (here, label) = names;
     let ParamOut { group, refs, col } = out;
     if p.kind != m.kind {
-        col.lose(LossCategory::Effects, format!("{here}: parameter {label} has type {:?}, expected {:?}; not imported", p.kind, m.kind));
+        col.lose_with(LossCategory::Effects, || format!("{here}: parameter {label} has type {:?}, expected {:?}; not imported", p.kind, m.kind));
         return;
     }
     match m.conv {
@@ -215,7 +215,7 @@ pub(crate) fn import_mapped(p: &EffectParam<'_, '_>, m: &ParamMap, cx: &LayerCtx
         // After Effects 2026 writes 0.990005 (the 16.16 rounding differs); the scale is the same.
         let ok = found.is_some_and(|v| (v - valid_max).abs() <= valid_max.abs() * 1e-4);
         if !ok {
-            col.lose(LossCategory::Effects, format!("{here}: parameter {label} has the valid maximum {found:?}, expected {valid_max}; not imported"));
+            col.lose_with(LossCategory::Effects, || format!("{here}: parameter {label} has the valid maximum {found:?}, expected {valid_max}; not imported"));
         }
         ok
     };
@@ -224,10 +224,9 @@ pub(crate) fn import_mapped(p: &EffectParam<'_, '_>, m: &ParamMap, cx: &LayerCtx
         (Conv::Popup { .. }, Some(items)) => items.clone(),
         (Conv::Popup { items, .. }, None) => {
             if p.popup_item_count().map(usize::from) != Some(items.len()) {
-                col.lose(
-                    LossCategory::Effects,
-                    format!("{here}: parameter {label}: the file names no popup items and has {:?} of them, not imported", p.popup_item_count()),
-                );
+                col.lose_with(LossCategory::Effects, || {
+                    format!("{here}: parameter {label}: the file names no popup items and has {:?} of them, not imported", p.popup_item_count())
+                });
                 return;
             }
             items.iter().map(|s| s.to_string()).collect()
@@ -263,7 +262,7 @@ pub(crate) fn import_mapped(p: &EffectParam<'_, '_>, m: &ParamMap, cx: &LayerCtx
     };
     // Grouped parameters are addressed by path (`master/exposure`).
     let Some(prop) = group.prop_mut(m.target) else {
-        col.lose(LossCategory::Effects, format!("{here}: parameter {label} has no counterpart '{}'", m.target));
+        col.lose_with(LossCategory::Effects, || format!("{here}: parameter {label} has no counterpart '{}'", m.target));
         return;
     };
     // For a popup: file item (0-based over all items) -> EffectCraft item, by name.
@@ -271,7 +270,7 @@ pub(crate) fn import_mapped(p: &EffectParam<'_, '_>, m: &ParamMap, cx: &LayerCtx
         Conv::Popup { .. } => match popup_mapping(&items, &prop.ui) {
             Some(map) => Some(map),
             None => {
-                col.lose(LossCategory::Effects, format!("{here}: parameter {label}: the popup items do not match EffectCraft's, not imported"));
+                col.lose_with(LossCategory::Effects, || format!("{here}: parameter {label}: the popup items do not match EffectCraft's, not imported"));
                 return;
             }
         },
@@ -288,7 +287,7 @@ pub(crate) fn import_mapped(p: &EffectParam<'_, '_>, m: &ParamMap, cx: &LayerCtx
             _ => false,
         };
         if converted && stored.expression().is_some() {
-            col.lose(LossCategory::Effects, format!("{here}: the expression on parameter {label} is not imported (the value is converted here)"));
+            col.lose_with(LossCategory::Effects, || format!("{here}: the expression on parameter {label} is not imported (the value is converted here)"));
         } else {
             import_expression(&stored, prop, col);
         }
@@ -296,14 +295,14 @@ pub(crate) fn import_mapped(p: &EffectParam<'_, '_>, m: &ParamMap, cx: &LayerCtx
     if p.is_animated() {
         if kind == Kind::EffectBool {
             // Keys on a checkbox are not sampled by the corpus.
-            col.lose(LossCategory::Effects, format!("{here}: the keyframes of parameter {label} are not imported (not decoded), default used"));
+            col.lose_with(LossCategory::Effects, || format!("{here}: the keyframes of parameter {label} are not imported (not decoded), default used"));
             return;
         }
         if let Some(stored) = p.stored() {
             let before = prop.keys.len();
             import_keys(&stored, kind, cx.layer, &p.match_name, cx.tm, prop, col);
             if prop.keys.len() == before {
-                col.lose(LossCategory::DamagedData, format!("{here}: parameter {label} has no readable keyframe, default used"));
+                col.lose_with(LossCategory::DamagedData, || format!("{here}: parameter {label} has no readable keyframe, default used"));
             }
             if let Some(map) = &popup_map {
                 remap_popup_keys(prop, map, here, label, col);
@@ -317,7 +316,7 @@ pub(crate) fn import_mapped(p: &EffectParam<'_, '_>, m: &ParamMap, cx: &LayerCtx
     let value = match (p.stored(), p.recorded_value()) {
         (Some(_), Some(v)) => Some(v),
         (Some(_), None) => {
-            col.lose(LossCategory::DamagedData, format!("{here}: parameter {label} holds an unreadable value, default used"));
+            col.lose_with(LossCategory::DamagedData, || format!("{here}: parameter {label} holds an unreadable value, default used"));
             return;
         }
         // Absent = default. A borrowed popup's default slot is not reliable (a selection writes
@@ -335,7 +334,7 @@ pub(crate) fn import_mapped(p: &EffectParam<'_, '_>, m: &ParamMap, cx: &LayerCtx
             Some(Some(ec)) => Some(Value::Enum(ec)),
             Some(None) => {
                 let item = usize::try_from(i).ok().and_then(|i| i.checked_sub(1)).and_then(|i| items.get(i)).cloned().unwrap_or_default();
-                col.lose(LossCategory::Effects, format!("{here}: parameter {label}: item '{item}' has no counterpart, default used"));
+                col.lose_with(LossCategory::Effects, || format!("{here}: parameter {label}: item '{item}' has no counterpart, default used"));
                 return;
             }
             None => None,
@@ -347,7 +346,7 @@ pub(crate) fn import_mapped(p: &EffectParam<'_, '_>, m: &ParamMap, cx: &LayerCtx
             report_beyond_limit(m.limit, std::iter::once(&v), here, label, col);
             prop.value = v;
         }
-        None => col.lose(LossCategory::DamagedData, format!("{here}: parameter {label} holds a value that is not valid ({value:?}), default used")),
+        None => col.lose_with(LossCategory::DamagedData, || format!("{here}: parameter {label} holds a value that is not valid ({value:?}), default used")),
     }
 }
 
@@ -357,7 +356,9 @@ fn report_beyond_limit<'v>(limit: Option<(f64, f64)>, values: impl Iterator<Item
     let Some((lo, hi)) = limit else { return };
     let beyond: Vec<f64> = values.filter_map(|v| if let Value::Scalar(x) = v { Some(*x) } else { None }).filter(|x| *x < lo || *x > hi).collect();
     if let Some(x) = beyond.first() {
-        col.lose(LossCategory::Effects, format!("{here}: parameter {label} is {x}, EffectCraft's effect uses {lo} to {hi} (rendered as the nearest of them)"));
+        col.lose_with(LossCategory::Effects, || {
+            format!("{here}: parameter {label} is {x}, EffectCraft's effect uses {lo} to {hi} (rendered as the nearest of them)")
+        });
     }
 }
 
@@ -375,11 +376,11 @@ fn import_layer_ref(p: &EffectParam<'_, '_>, target: &str, own: bool, cx: &Layer
         src.value = Value::Enum(0);
     }
     let Some(prop) = group.prop_mut(target) else {
-        col.lose(LossCategory::Effects, format!("{here}: parameter {label} has no counterpart '{target}'"));
+        col.lose_with(LossCategory::Effects, || format!("{here}: parameter {label} has no counterpart '{target}'"));
         return;
     };
     if p.is_animated() || p.stored().is_some_and(|s| s.expression().is_some()) {
-        col.lose(LossCategory::Effects, format!("{here}: keyframes or an expression on the layer parameter {label} are not imported"));
+        col.lose_with(LossCategory::Effects, || format!("{here}: keyframes or an expression on the layer parameter {label} are not imported"));
     }
     // No record: the default, the owning layer (320).
     match p.layer_ref(cx.aep_id).unwrap_or(LayerRef::This) {
@@ -395,19 +396,21 @@ fn import_layer_ref(p: &EffectParam<'_, '_>, target: &str, own: bool, cx: &Layer
 }
 
 /// Sets the layer parameters that name another layer of the composition (`ids`: file id ->
-/// project layer); one whose layer was not imported stays unset and is reported.
+/// project layer; `at`: project layer -> position in the composition); one whose layer was not
+/// imported stays unset and is reported.
 pub(crate) fn resolve_layer_refs(
     comp: &mut effectcraft_project::Comp,
+    at: &std::collections::HashMap<effectcraft_project::LayerId, usize>,
     refs: &[PendingLayerRef],
     ids: &std::collections::HashMap<u32, effectcraft_project::LayerId>,
     col: &mut Collector,
 ) {
     for r in refs {
         let Some(target) = ids.get(&r.target) else {
-            col.lose(LossCategory::Effects, format!("{} names a layer that is not imported (id {}), left unset", r.what, r.target));
+            col.lose_with(LossCategory::Effects, || format!("{} names a layer that is not imported (id {}), left unset", r.what, r.target));
             continue;
         };
-        if let Some(prop) = comp.layers.iter_mut().find(|l| l.id == r.layer).and_then(|l| l.props.find_mut(r.prop)) {
+        if let Some(prop) = crate::import::build::layer_at(comp, at, r.layer).and_then(|l| l.props.find_mut(r.prop)) {
             prop.value = Value::Layer(Some(target.0));
         }
     }
@@ -415,9 +418,12 @@ pub(crate) fn resolve_layer_refs(
 
 /// The EffectCraft item of each file item (by name, ignoring case and separators); `None` when
 /// the parameter here is not a popup.
+///
+/// The file's item count is not bounded (its `pdnm`), EffectCraft's options are: each side's key
+/// is taken once and compared without a copy, so the cost is linear in the file's items.
 fn popup_mapping(file_items: &[String], ui: &ParamUi) -> Option<Vec<Option<u32>>> {
     let ParamUi::Popup { options } = ui else { return None };
-    let norm = popup_key;
+    let options: Vec<&str> = options.iter().map(|o| popup_stem(o)).collect();
     Some(
         file_items
             .iter()
@@ -425,7 +431,8 @@ fn popup_mapping(file_items: &[String], ui: &ParamUi) -> Option<Vec<Option<u32>>
                 if item.trim() == "(-" {
                     return None;
                 }
-                options.iter().position(|o| norm(o) == norm(item)).and_then(|i| u32::try_from(i).ok())
+                let item = popup_stem(item);
+                options.iter().position(|o| o.eq_ignore_ascii_case(item)).and_then(|i| u32::try_from(i).ok())
             })
             .collect(),
     )
@@ -445,7 +452,7 @@ fn remap_popup_keys(prop: &mut effectcraft_project::Property, map: &[Option<u32>
         _ => true,
     });
     if prop.keys.len() != before {
-        col.lose(LossCategory::Effects, format!("{here}: a keyframe of parameter {label} has an item without a counterpart, dropped"));
+        col.lose_with(LossCategory::Effects, || format!("{here}: a keyframe of parameter {label} has an item without a counterpart, dropped"));
     }
     if let Some(first) = prop.keys.first() {
         prop.value = first.value.clone();
@@ -455,17 +462,16 @@ fn remap_popup_keys(prop: &mut effectcraft_project::Property, map: &[Option<u32>
 /// Hue/Saturation's master values, Levels' RGB values: from the arbitrary data of `p`.
 fn import_extra(fx: &AepEffect<'_, '_>, extra: Extra, p: &EffectParam<'_, '_>, here: &str, size: (u32, u32), group: &mut PropGroup, col: &mut Collector) {
     if p.is_animated() || p.stored().is_some_and(|s| s.expression().is_some()) {
-        col.lose(LossCategory::Effects, format!("{here}: keyframes or an expression on {} are not imported", p.name));
+        col.lose_with(LossCategory::Effects, || format!("{here}: keyframes or an expression on {} are not imported", p.name));
     }
     let Some(data) = fx.arbitrary_data(&p.match_name) else {
         // No record: every value is at its default. A Channel Info value record without its
         // aRbs/aRbp payload (every sampled record has it) is damaged: the payload may have chosen
         // other channels (`Z`), so the defaults are not what After Effects renders.
         if p.stored().is_some() && matches!(extra, Extra::Extractor | Extra::Identifier) {
-            col.lose(
-                LossCategory::DamagedData,
-                format!("{here}: the Channel Info data is missing (a value record without its data), the default channels used"),
-            );
+            col.lose_with(LossCategory::DamagedData, || {
+                format!("{here}: the Channel Info data is missing (a value record without its data), the default channels used")
+            });
         }
         return;
     };
@@ -483,10 +489,10 @@ fn import_extra(fx: &AepEffect<'_, '_>, extra: Extra, p: &EffectParam<'_, '_>, h
                     set(id, f64::from(v));
                 }
                 if !d.ranges_are_default() {
-                    col.lose(LossCategory::Effects, format!("{here}: the colour ranges (Reds ... Magentas) are not imported (not sampled)"));
+                    col.lose_with(LossCategory::Effects, || format!("{here}: the colour ranges (Reds ... Magentas) are not imported (not sampled)"));
                 }
             }
-            None => col.lose(LossCategory::DamagedData, format!("{here}: the Hue/Saturation data is unreadable, defaults used")),
+            None => col.lose_with(LossCategory::DamagedData, || format!("{here}: the Hue/Saturation data is unreadable, defaults used")),
         },
         Extra::Levels => match LevelsData::parse(data) {
             Some(d) => {
@@ -494,10 +500,10 @@ fn import_extra(fx: &AepEffect<'_, '_>, extra: Extra, p: &EffectParam<'_, '_>, h
                     set(id, f64::from(v));
                 }
                 if d.channels[1..].iter().any(|c| *c != LevelsData::DEFAULT_CHANNEL) {
-                    col.lose(LossCategory::Effects, format!("{here}: the per-channel values (Red, Green, Blue, Alpha) are not imported (not sampled)"));
+                    col.lose_with(LossCategory::Effects, || format!("{here}: the per-channel values (Red, Green, Blue, Alpha) are not imported (not sampled)"));
                 }
             }
-            None => col.lose(LossCategory::DamagedData, format!("{here}: the Levels data is unreadable, defaults used")),
+            None => col.lose_with(LossCategory::DamagedData, || format!("{here}: the Levels data is unreadable, defaults used")),
         },
         Extra::Curves => match CurvesData::parse(data) {
             Some(d) => {
@@ -511,11 +517,11 @@ fn import_extra(fx: &AepEffect<'_, '_>, extra: Extra, p: &EffectParam<'_, '_>, h
                     }
                 }
             }
-            None => col.lose(LossCategory::DamagedData, format!("{here}: the Curves data is unreadable, defaults used")),
+            None => col.lose_with(LossCategory::DamagedData, || format!("{here}: the Curves data is unreadable, defaults used")),
         },
         Extra::MeshWarp => match MeshData::parse(data) {
             Some(m) => import_mesh(&m, here, size, group, col),
-            None => col.lose(LossCategory::DamagedData, format!("{here}: the Distortion Mesh is unreadable, defaults used")),
+            None => col.lose_with(LossCategory::DamagedData, || format!("{here}: the Distortion Mesh is unreadable, defaults used")),
         },
         Extra::Extractor => match ExtractorChannels::parse(data).map(|c| (c.sources(), c)) {
             // Each output channel reads the footage's channel of the stored name, which
@@ -531,16 +537,16 @@ fn import_extra(fx: &AepEffect<'_, '_>, extra: Extra, p: &EffectParam<'_, '_>, h
             }
             Some((Err(k), c)) => {
                 let names: Vec<&str> = c.channels.iter().map(|(_, n)| n.as_str()).collect();
-                col.lose(
+                col.lose_with(
                     LossCategory::Effects,
-                    format!(
+                    || format!(
                         "{here}: the channels {} are not imported (record {} is of an unknown kind or names no channel), R, G, B, A used",
                         names.join(", "),
                         k.saturating_add(1)
                     ),
                 );
             }
-            None => col.lose(LossCategory::Effects, format!("{here}: the Channel Info data is not in the sampled layout, R, G, B, A used")),
+            None => col.lose_with(LossCategory::Effects, || format!("{here}: the Channel Info data is not in the sampled layout, R, G, B, A used")),
         },
         Extra::Identifier => match crate::identifier_channel_type(data) {
             // No channel chosen (the type's label): After Effects lists only the footage's integer
@@ -550,9 +556,9 @@ fn import_extra(fx: &AepEffect<'_, '_>, extra: Extra, p: &EffectParam<'_, '_>, h
                 if let Some(prop) = group.prop_mut("channelType") {
                     prop.value = Value::Enum(0);
                 }
-                col.lose(
+                col.lose_with(
                     LossCategory::Effects,
-                    format!("{here}: no ID channel is chosen (Channel Info), so After Effects leaves the layer unchanged; EffectCraft draws the footage's object ID channel"),
+                    || format!("{here}: no ID channel is chosen (Channel Info), so After Effects leaves the layer unchanged; EffectCraft draws the footage's object ID channel"),
                 );
             }
             // A chosen channel, by name. EffectCraft's IDentifier has no channel of its own: it
@@ -564,12 +570,12 @@ fn import_extra(fx: &AepEffect<'_, '_>, extra: Extra, p: &EffectParam<'_, '_>, h
                         prop.value = Value::Enum(u32::try_from(kind).unwrap_or(0));
                     }
                 }
-                None => col.lose(
+                None => col.lose_with(
                     LossCategory::Effects,
-                    format!("{here}: the ID channel '{name}' (Channel Info) is not imported; EffectCraft reads the footage's object ID channel (ObjectID, object_id, objectId, id)"),
+                    || format!("{here}: the ID channel '{name}' (Channel Info) is not imported; EffectCraft reads the footage's object ID channel (ObjectID, object_id, objectId, id)"),
                 ),
             },
-            None => col.lose(LossCategory::Effects, format!("{here}: the Channel Info data is not in the sampled layout, the object ID channel used")),
+            None => col.lose_with(LossCategory::Effects, || format!("{here}: the Channel Info data is not in the sampled layout, the object ID channel used")),
         },
         Extra::None | Extra::Lumetri | Extra::Cryptomatte => {}
     }
@@ -599,13 +605,13 @@ fn import_cryptomatte(fx: &AepEffect<'_, '_>, params: &[EffectParam<'_, '_>], cx
         match (p.index, p.kind) {
             (1, ParamKind::ArbitraryData) => {
                 if moving {
-                    col.lose(LossCategory::Effects, format!("{here}: keyframes or an expression on {label} are not imported"));
+                    col.lose_with(LossCategory::Effects, || format!("{here}: keyframes or an expression on {label} are not imported"));
                 }
                 // No record: the definition's default, no layer and no selection. A record
                 // without its data (every sampled record has it) is damaged.
                 let Some(data) = fx.arbitrary_data(&p.match_name) else {
                     if p.stored().is_some() {
-                        col.lose(LossCategory::DamagedData, format!("{here}: the Cryptomatte settings (layer, selection) have no data, none used"));
+                        col.lose_with(LossCategory::DamagedData, || format!("{here}: the Cryptomatte settings (layer, selection) have no data, none used"));
                     }
                     continue;
                 };
@@ -614,12 +620,14 @@ fn import_cryptomatte(fx: &AepEffect<'_, '_>, params: &[EffectParam<'_, '_>], cx
                         set(group, "layerName", Value::Str(d.layer));
                         set(group, "selection", Value::Str(d.selection));
                     }
-                    None => col.lose(LossCategory::DamagedData, format!("{here}: the Cryptomatte settings (layer, selection) are unreadable, none used")),
+                    None => {
+                        col.lose_with(LossCategory::DamagedData, || format!("{here}: the Cryptomatte settings (layer, selection) are unreadable, none used"))
+                    }
                 }
             }
             (2, ParamKind::Popup) => {
                 if moving {
-                    col.lose(LossCategory::Effects, format!("{here}: keyframes or an expression on {label} are not imported, Colors used"));
+                    col.lose_with(LossCategory::Effects, || format!("{here}: keyframes or an expression on {label} are not imported, Colors used"));
                     continue;
                 }
                 let (display, matte_only) = crypto_output(p, &here, &label, col);
@@ -628,19 +636,19 @@ fn import_cryptomatte(fx: &AepEffect<'_, '_>, params: &[EffectParam<'_, '_>], cx
             }
             (3, ParamKind::Checkbox) => {
                 if moving {
-                    col.lose(LossCategory::Effects, format!("{here}: keyframes or an expression on {label} are not imported"));
+                    col.lose_with(LossCategory::Effects, || format!("{here}: keyframes or an expression on {label} are not imported"));
                 } else {
                     match selection_mode_on(p) {
                         // A picking switch of the plug-in; EffectCraft picks with its own tool.
-                        Some(true) => col.lose(LossCategory::Effects, format!("{here}: parameter {label} is on and has no counterpart")),
+                        Some(true) => col.lose_with(LossCategory::Effects, || format!("{here}: parameter {label} is on and has no counterpart")),
                         Some(false) => {}
-                        None => col.lose(LossCategory::DamagedData, format!("{here}: parameter {label} holds an unreadable value, off used")),
+                        None => col.lose_with(LossCategory::DamagedData, || format!("{here}: parameter {label} holds an unreadable value, off used")),
                     }
                 }
             }
             _ => {
                 if p.stored().is_some() && !matches!(p.stored_value(), Some(ParamValue::Layer(0))) {
-                    col.lose(LossCategory::Effects, format!("{here}: parameter {label} ({:?}) not imported", p.kind));
+                    col.lose_with(LossCategory::Effects, || format!("{here}: parameter {label} ({:?}) not imported", p.kind));
                 }
             }
         }
@@ -671,17 +679,16 @@ fn crypto_output(p: &EffectParam<'_, '_>, here: &str, label: &str, col: &mut Col
         Some(items) => items.clone(),
         None if p.popup_item_count().map(usize::from) == Some(CRYPTOMATTE_OUTPUT.len()) => CRYPTOMATTE_OUTPUT.iter().map(|s| s.to_string()).collect(),
         None => {
-            col.lose(
-                LossCategory::Effects,
-                format!("{here}: parameter {label}: the file names no popup items and has {:?} of them, not imported, Colors used", p.popup_item_count()),
-            );
+            col.lose_with(LossCategory::Effects, || {
+                format!("{here}: parameter {label}: the file names no popup items and has {:?} of them, not imported, Colors used", p.popup_item_count())
+            });
             return CRYPTO_COLORS;
         }
     };
     let index = match (p.stored(), p.stored_value()) {
         (Some(_), Some(ParamValue::Index(i))) => i,
         (Some(_), _) => {
-            col.lose(LossCategory::DamagedData, format!("{here}: parameter {label} holds an unreadable value, Colors used"));
+            col.lose_with(LossCategory::DamagedData, || format!("{here}: parameter {label} holds an unreadable value, Colors used"));
             return CRYPTO_COLORS;
         }
         // No record: the default. The plug-in's is Colors (1): the `pard` default of the
@@ -699,14 +706,14 @@ fn crypto_output(p: &EffectParam<'_, '_>, here: &str, label: &str, col: &mut Col
         "matted rgba" => (1, false),
         "matte only" => (1, true),
         "matted colors" => {
-            col.lose(
+            col.lose_with(
                 LossCategory::Effects,
-                format!("{here}: parameter {label}: item '{item}' ({index}) has no counterpart, imported as Matte (the layer's colours keyed by the selection, not the ID colours)"),
+                || format!("{here}: parameter {label}: item '{item}' ({index}) has no counterpart, imported as Matte (the layer's colours keyed by the selection, not the ID colours)"),
             );
             (1, false)
         }
         _ => {
-            col.lose(LossCategory::Effects, format!("{here}: parameter {label}: item '{item}' ({index}) has no counterpart, Colors used"));
+            col.lose_with(LossCategory::Effects, || format!("{here}: parameter {label}: item '{item}' ({index}) has no counterpart, Colors used"));
             CRYPTO_COLORS
         }
     }
@@ -734,7 +741,9 @@ fn import_mesh(m: &MeshData, here: &str, size: (u32, u32), group: &mut PropGroup
     let rows_stored = group.prop("rows").map(|p| p.value.as_f64().round());
     let cols_stored = group.prop("columns").map(|p| p.value.as_f64().round());
     if rows_stored != Some(f64::from(m.rows)) || cols_stored != Some(f64::from(m.columns)) {
-        col.lose(LossCategory::Effects, format!("{here}: the Distortion Mesh is {} x {} cells, Rows / Columns say otherwise; not imported", m.columns, m.rows));
+        col.lose_with(LossCategory::Effects, || {
+            format!("{here}: the Distortion Mesh is {} x {} cells, Rows / Columns say otherwise; not imported", m.columns, m.rows)
+        });
         return;
     }
     let mut offs = Vec::with_capacity(m.vertices.len());
@@ -760,7 +769,7 @@ fn import_mesh(m: &MeshData, here: &str, size: (u32, u32), group: &mut PropGroup
             }
         }
         if !(dx.is_finite() && dy.is_finite() && own.iter().all(|x| x.is_finite())) {
-            col.lose(LossCategory::DamagedData, format!("{here}: the Distortion Mesh holds a number that is not valid, not imported"));
+            col.lose_with(LossCategory::DamagedData, || format!("{here}: the Distortion Mesh holds a number that is not valid, not imported"));
             return;
         }
         // EffectCraft's mesh reads the first two numbers of a vertex; moved handles follow as
@@ -775,10 +784,9 @@ fn import_mesh(m: &MeshData, here: &str, size: (u32, u32), group: &mut PropGroup
         offs.push(token);
     }
     if handles_moved {
-        col.lose(
-            LossCategory::Effects,
-            format!("{here}: Distortion Mesh Bezier handles moved on their own are not drawn (EffectCraft's mesh is bilinear; they are kept for the export)"),
-        );
+        col.lose_with(LossCategory::Effects, || {
+            format!("{here}: Distortion Mesh Bezier handles moved on their own are not drawn (EffectCraft's mesh is bilinear; they are kept for the export)")
+        });
     }
     if let Some(p) = group.prop_mut("rows") {
         p.value = Value::Scalar(f64::from(m.rows));
@@ -811,3 +819,34 @@ fn convert(value: ParamValue, kind: Kind) -> Option<Value> {
     };
     kind.value(&raw)
 }
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    fn ui(options: &[&str]) -> ParamUi {
+        ParamUi::Popup { options: options.iter().map(|s| s.to_string()).collect() }
+    }
+
+    #[test]
+    fn popup_items_map_by_name_ignoring_case_separators_and_channel() {
+        let file: Vec<String> = ["Red Channel", "(-", " GREEN ", "Alpha channel", "Other", "red"].iter().map(|s| s.to_string()).collect();
+        let map = popup_mapping(&file, &ui(&["Red", "Green", "Blue", "Alpha", "red"])).expect("a popup");
+        // The first option of a name wins, as `position` finds it.
+        assert_eq!(map, [Some(0), None, Some(1), Some(3), None, Some(0)]);
+        assert_eq!(popup_mapping(&file, &ParamUi::Checkbox), None);
+    }
+
+    #[test]
+    fn a_popup_with_a_huge_item_list_maps_in_linear_time() {
+        // A `pdnm` of 200 000 items (a hostile file: the count is not bounded there) against an
+        // effect's options. Each comparison used to build two keys (two allocations), 4e7 of
+        // them here at 100 options; now each key is borrowed once and compared in place.
+        let options: Vec<String> = (0..100).map(|i| format!("Option {i}")).collect();
+        let file: Vec<String> = (0..200_000).map(|i| format!("Item {}", i % 1000)).collect();
+        let ui = ParamUi::Popup { options };
+        let map = popup_mapping(&file, &ui).expect("a popup");
+        assert_eq!(map.len(), file.len());
+        assert!(map.iter().all(Option::is_none));
+    }
+}
diff --git a/crates/aep/src/import/masks.rs b/crates/aep/src/import/masks.rs
index 184250c4c..da7dd660e 100644
--- a/crates/aep/src/import/masks.rs
+++ b/crates/aep/src/import/masks.rs
@@ -11,11 +11,11 @@
 //! progress per second and reported.
 
 use crate::{Layer as AepLayer, MaskAtom, MaskMode as AepMode, PropNode, ShapePath as AepPath, ValueSource};
-use effectcraft_keyframe::{Ease, Interp, Keyframe, ShapePath, Value};
+use effectcraft_keyframe::{Interp, Keyframe, ShapePath, Value};
 use effectcraft_project::build::{self, Ids};
 use effectcraft_project::{GroupKind, MaskMode, Node, PropGroup as EcGroup};
 
-use crate::import::props::{Kind, LIMIT, import_expression, import_keys, interp};
+use crate::import::props::{Kind, LIMIT, ease, import_expression, import_keys, interp, sort_unique};
 use crate::import::report::{Collector, LossCategory};
 use crate::import::time::TimeMap;
 
@@ -129,7 +129,7 @@ fn import_mask(atom: &MaskAtom<'_, '_>, index: usize, name: &str, what: &str, ml
     let first = match first {
         Ok(p) => p,
         Err(why) => {
-            col.lose(LossCategory::Masks, format!("{what}: not imported, {why}"));
+            col.lose_with(LossCategory::Masks, || format!("{what}: not imported, {why}"));
             return None;
         }
     };
@@ -139,11 +139,11 @@ fn import_mask(atom: &MaskAtom<'_, '_>, index: usize, name: &str, what: &str, ml
                 AepMode::Other(c) => c,
                 _ => 0,
             };
-            col.lose(LossCategory::Masks, format!("{what}: mode code {shown} is not known, imported as Add"));
+            col.lose_with(LossCategory::Masks, || format!("{what}: mode code {shown} is not known, imported as Add"));
             MaskMode::Add
         }),
         None => {
-            col.lose(LossCategory::DamagedData, format!("{what}: mode and invert switch unreadable, Add used"));
+            col.lose_with(LossCategory::DamagedData, || format!("{what}: mode and invert switch unreadable, Add used"));
             MaskMode::Add
         }
     };
@@ -185,14 +185,14 @@ fn import_mask(atom: &MaskAtom<'_, '_>, index: usize, name: &str, what: &str, ml
 fn set_static(g: &mut EcGroup, id: &str, value: Value, source: ValueSource, valid: impl Fn(&Value) -> bool, what: &str, col: &mut Collector) {
     match source {
         ValueSource::Default | ValueSource::Keyframed => {}
-        ValueSource::Unreadable => col.lose(LossCategory::DamagedData, format!("{what}: {id} unreadable, default used")),
+        ValueSource::Unreadable => col.lose_with(LossCategory::DamagedData, || format!("{what}: {id} unreadable, default used")),
         ValueSource::Stored => {
             if crate::import::props::sane(&value) && valid(&value) {
                 if let Some(p) = g.get_mut(id) {
                     p.value = value;
                 }
             } else {
-                col.lose(LossCategory::DamagedData, format!("{what}: {id} holds a number that is not valid, default used"));
+                col.lose_with(LossCategory::DamagedData, || format!("{what}: {id} holds a number that is not valid, default used"));
             }
         }
     }
@@ -210,25 +210,25 @@ pub(crate) fn import_path_keys(
     col: &mut Collector,
 ) {
     let Some(list) = path.keys() else {
-        col.lose(LossCategory::DamagedData, format!("{what}: path keyframes unreadable, the first shape is static"));
+        col.lose_with(LossCategory::DamagedData, || format!("{what}: path keyframes unreadable, the first shape is static"));
         return;
     };
     let records: Vec<_> = list.keyframes().collect();
     if records.len() != shapes.len() {
-        col.lose(LossCategory::DamagedData, format!("{what}: {} path keyframes but {} shapes, the first shape is static", records.len(), shapes.len()));
+        col.lose_with(LossCategory::DamagedData, || format!("{what}: {} path keyframes but {} shapes, the first shape is static", records.len(), shapes.len()));
         return;
     }
     let scale = path.time_scale().filter(|s| *s != 0).unwrap_or(tm.timescale);
     let mut keys: Vec<Keyframe> = Vec::new();
     for (rec, shape) in records.iter().zip(shapes) {
         let Some(units) = rec.time_units() else {
-            col.lose(LossCategory::DamagedData, format!("{what}: unreadable path keyframe"));
+            col.lose_with(LossCategory::DamagedData, || format!("{what}: unreadable path keyframe"));
             continue;
         };
         let path = match shape.as_ref().ok_or("its shape is unreadable").and_then(|s| to_path(s, size)) {
             Ok(p) => p,
             Err(why) => {
-                col.lose(LossCategory::DamagedData, format!("{what}: a path keyframe was dropped, {why}"));
+                col.lose_with(LossCategory::DamagedData, || format!("{what}: a path keyframe was dropped, {why}"));
                 continue;
             }
         };
@@ -238,20 +238,25 @@ pub(crate) fn import_path_keys(
         if key.in_interp == Interp::Bezier || key.out_interp == Interp::Bezier {
             // The ease at byte 24 (599, 700): influences as fractions; a speed of 0 is exact, the
             // unit of another speed is not verified (taken as progress per second).
-            match rec.ease().filter(|e| [e.in_speed, e.in_influence, e.out_speed, e.out_influence].iter().all(|v| v.is_finite())) {
-                Some(e) => {
+            // The same rule as every other key's ease (`props::ease`): a speed beyond its limit is
+            // unreadable, not imported as it is.
+            match rec.ease().and_then(path_eases) {
+                Some((in_e, out_e)) => {
+                    let unverified = (key.in_interp == Interp::Bezier && in_e.speed != 0.0) || (key.out_interp == Interp::Bezier && out_e.speed != 0.0);
                     if key.in_interp == Interp::Bezier {
-                        key.in_ease = vec![Ease { speed: e.in_speed, influence: e.in_influence.clamp(0.001, 1.0) }];
+                        key.in_ease = vec![in_e];
                     }
                     if key.out_interp == Interp::Bezier {
-                        key.out_ease = vec![Ease { speed: e.out_speed, influence: e.out_influence.clamp(0.001, 1.0) }];
+                        key.out_ease = vec![out_e];
                     }
-                    if (key.in_interp == Interp::Bezier && e.in_speed != 0.0) || (key.out_interp == Interp::Bezier && e.out_speed != 0.0) {
-                        col.lose(LossCategory::ApproximatedKeyframes, format!("{what}: path key ease speed imported unverified (only speed 0 is sampled)"));
+                    if unverified {
+                        col.lose_with(LossCategory::ApproximatedKeyframes, || {
+                            format!("{what}: path key ease speed imported unverified (only speed 0 is sampled)")
+                        });
                     }
                 }
                 None => {
-                    col.lose(LossCategory::ApproximatedKeyframes, format!("{what}: bezier path key read as linear (its ease is unreadable)"));
+                    col.lose_with(LossCategory::ApproximatedKeyframes, || format!("{what}: bezier path key read as linear (its ease is unreadable)"));
                     key.in_interp = if key.in_interp == Interp::Bezier { Interp::Linear } else { key.in_interp };
                     key.out_interp = if key.out_interp == Interp::Bezier { Interp::Linear } else { key.out_interp };
                 }
@@ -264,12 +269,7 @@ pub(crate) fn import_path_keys(
     if keys.is_empty() {
         return;
     }
-    keys.sort_by_key(|k| k.time);
-    let before = keys.len();
-    keys.dedup_by_key(|k| k.time);
-    if keys.len() != before {
-        col.lose(LossCategory::DamagedData, format!("{what}: path keyframes at the same time"));
-    }
+    sort_unique(&mut keys, what, "path keyframes", col);
     // The first key's incoming and the last key's outgoing ease mean nothing.
     if let Some(first) = keys.first_mut() {
         first.in_ease.clear();
@@ -283,3 +283,26 @@ pub(crate) fn import_path_keys(
     }
     prop.keys = keys;
 }
+
+/// The in and out ease of a mask path key, under the rule of every other key's ease
+/// (`props::ease`); `None` when either side cannot be used.
+fn path_eases(e: crate::KeyEase) -> Option<(effectcraft_keyframe::Ease, effectcraft_keyframe::Ease)> {
+    Some((ease(e.in_speed, e.in_influence, 1.0)?, ease(e.out_speed, e.out_influence, 1.0)?))
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn a_path_ease_speed_beyond_the_property_limit_is_unreadable() {
+        let e = |speed: f64| crate::KeyEase { in_speed: speed, in_influence: 0.5, out_speed: 0.0, out_influence: 2.0 };
+        let (i, o) = path_eases(e(3.0)).expect("usable");
+        assert_eq!((i.speed, i.influence, o.speed, o.influence), (3.0, 0.5, 0.0, 1.0));
+        // Finite but far beyond what a property key accepts (before, only finiteness was checked).
+        assert!(path_eases(e(1e12)).is_none());
+        assert!(path_eases(e(-1e12)).is_none());
+        assert!(path_eases(e(f64::NAN)).is_none());
+        assert!(path_eases(crate::KeyEase { out_speed: 1e12, ..e(0.0) }).is_none());
+    }
+}
diff --git a/crates/aep/src/import/props.rs b/crates/aep/src/import/props.rs
index 838a2ee44..eb9653612 100644
--- a/crates/aep/src/import/props.rs
+++ b/crates/aep/src/import/props.rs
@@ -188,12 +188,12 @@ pub(crate) fn import_transform(
         }
         if source_of == ValueSource::Unreadable {
             // Present in the file but not decodable: the reader gave the default in its place.
-            col.lose(LossCategory::DamagedData, format!("{layer_name}: {match_name} unreadable, default used"));
+            col.lose_with(LossCategory::DamagedData, || format!("{layer_name}: {match_name} unreadable, default used"));
         }
         if sane(&base) {
             prop.value = base;
         } else {
-            col.lose(LossCategory::DamagedData, format!("{layer_name}: {match_name} holds a number that is not valid, default used"));
+            col.lose_with(LossCategory::DamagedData, || format!("{layer_name}: {match_name} holds a number that is not valid, default used"));
         }
         let Some(PropNode::Property(node)) = group.get(match_name) else { continue };
         if source_of == ValueSource::Keyframed {
@@ -204,7 +204,7 @@ pub(crate) fn import_transform(
     for (match_name, id) in ROTATIONS {
         let Some(PropNode::Property(node)) = group.get(match_name) else { continue };
         let Some(prop) = target.get_mut(id) else {
-            col.lose(LossCategory::TransformProperties, format!("{layer_name}: {match_name}"));
+            col.lose_with(LossCategory::TransformProperties, || format!("{layer_name}: {match_name}"));
             continue;
         };
         if node.is_animated() {
@@ -214,7 +214,7 @@ pub(crate) fn import_transform(
             if sane(&value) {
                 prop.value = value;
             } else {
-                col.lose(LossCategory::DamagedData, format!("{layer_name}: {match_name} holds a number that is not valid, default used"));
+                col.lose_with(LossCategory::DamagedData, || format!("{layer_name}: {match_name} holds a number that is not valid, default used"));
             }
         }
         import_expression(&node, prop, col);
@@ -226,9 +226,9 @@ pub(crate) fn import_transform(
             (Some(o), None) if !o.animated && !o.has_expression && o.degrees == [0.0; 3] => {}
             (Some(o), Some(prop)) if o.animated && !o.has_expression => import_orientation_keys(layer, layer_name, tm, prop, col),
             (Some(o), Some(_)) if o.has_expression => {
-                col.lose(LossCategory::TransformProperties, format!("{layer_name}: ADBE Orientation expression (not decoded)"));
+                col.lose_with(LossCategory::TransformProperties, || format!("{layer_name}: ADBE Orientation expression (not decoded)"));
             }
-            _ => col.lose(LossCategory::TransformProperties, format!("{layer_name}: ADBE Orientation")),
+            _ => col.lose_with(LossCategory::TransformProperties, || format!("{layer_name}: ADBE Orientation")),
         }
     }
     report_other_properties(&group, layer_name, col);
@@ -241,7 +241,7 @@ fn import_orientation_keys(layer: &AepLayer<'_, '_>, layer_name: &str, tm: &Time
     let what = format!("{layer_name}: ADBE Orientation");
     let stored = layer.orientation_keys();
     if stored.is_empty() {
-        col.lose(LossCategory::TransformProperties, format!("{what} keys unreadable, the static value is used"));
+        col.lose_with(LossCategory::TransformProperties, || format!("{what} keys unreadable, the static value is used"));
         return;
     }
     // Key times count in the property's time scale (a stretched layer's is scaled), as in
@@ -252,7 +252,7 @@ fn import_orientation_keys(layer: &AepLayer<'_, '_>, layer_name: &str, tm: &Time
     for k in &stored {
         let value = Value::Vec3(k.degrees);
         if !sane(&value) {
-            col.lose(LossCategory::DamagedData, format!("{what}: keyframe value is not a number"));
+            col.lose_with(LossCategory::DamagedData, || format!("{what}: keyframe value is not a number"));
             continue;
         }
         let mut key = Keyframe::new(tm.units(i64::from(k.time_units), scale), value);
@@ -268,10 +268,10 @@ fn import_orientation_keys(layer: &AepLayer<'_, '_>, layer_name: &str, tm: &Time
         keys.push(key);
     }
     if approximated {
-        col.lose(LossCategory::ApproximatedKeyframes, format!("{what}: bezier key read as linear (the Orientation ease is not sampled)"));
+        col.lose_with(LossCategory::ApproximatedKeyframes, || format!("{what}: bezier key read as linear (the Orientation ease is not sampled)"));
     }
-    keys.sort_by_key(|k| k.time);
-    keys.dedup_by_key(|k| k.time);
+    // Reported as on every other property (`import_keys`, mask paths).
+    sort_unique(&mut keys, &what, "keyframes", col);
     col.imported.keyframes = col.imported.keyframes.saturating_add(keys.len());
     if let Some(first) = keys.first() {
         prop.value = first.value.clone();
@@ -290,7 +290,7 @@ fn report_other_properties(group: &PropGroup<'_, '_>, layer_name: &str, col: &mu
         // A property in its default state (`tdsb` 3) holds nothing to lose.
         let stored = p.is_animated() || p.flags() == Some(1) || p.expression().is_some();
         if stored && !(IGNORED.contains(&name) && p.flags() != Some(1) && !p.is_animated()) {
-            col.lose(LossCategory::TransformProperties, format!("{layer_name}: {name}"));
+            col.lose_with(LossCategory::TransformProperties, || format!("{layer_name}: {name}"));
         }
     }
 }
@@ -309,14 +309,26 @@ pub(crate) fn interp(i: Option<Interpolation>, col: &mut Collector, what: &str)
         Some(Interpolation::Bezier) => Interp::Bezier,
         Some(Interpolation::Hold) => Interp::Hold,
         Some(Interpolation::Other(code)) => {
-            col.lose(LossCategory::ApproximatedKeyframes, format!("{what}: unknown interpolation {code} read as linear"));
+            col.lose_with(LossCategory::ApproximatedKeyframes, || format!("{what}: unknown interpolation {code} read as linear"));
             Interp::Linear
         }
     }
 }
 
-/// An ease that can be evaluated: finite speed, influence within 0.1 % and 100 %.
-fn ease(speed: f64, influence: f64, factor: f64) -> Option<Ease> {
+/// Puts `keys` in time order and keeps the first of keys at the same time, reporting that some
+/// were dropped (`noun` names them: "keyframes", "path keyframes").
+pub(crate) fn sort_unique(keys: &mut Vec<Keyframe>, what: &str, noun: &str, col: &mut Collector) {
+    keys.sort_by_key(|k| k.time);
+    let before = keys.len();
+    keys.dedup_by_key(|k| k.time);
+    if keys.len() != before {
+        col.lose_with(LossCategory::DamagedData, || format!("{what}: {noun} at the same time"));
+    }
+}
+
+/// An ease that can be evaluated: finite speed within `LIMIT * 100`, influence within 0.1 % and
+/// 100 % (also the rule for mask path keys, `import/masks.rs`).
+pub(crate) fn ease(speed: f64, influence: f64, factor: f64) -> Option<Ease> {
     let speed = speed * factor;
     (speed.is_finite() && speed.abs() <= LIMIT * 100.0 && influence.is_finite()).then(|| Ease { speed, influence: influence.clamp(0.001, 1.0) })
 }
@@ -358,11 +370,11 @@ pub(crate) fn import_keys(node: &AepProp<'_, '_>, kind: Kind, layer_name: &str,
     let mut keys: Vec<Keyframe> = Vec::new();
     for rec in list.keyframes() {
         let (Some(units), Some(raw)) = (rec.time_units(), rec.value()) else {
-            col.lose(LossCategory::DamagedData, format!("{what}: unreadable keyframe"));
+            col.lose_with(LossCategory::DamagedData, || format!("{what}: unreadable keyframe"));
             continue;
         };
         let Some(value) = kind.value(&raw) else {
-            col.lose(LossCategory::DamagedData, format!("{what}: keyframe value is missing or not a number"));
+            col.lose_with(LossCategory::DamagedData, || format!("{what}: keyframe value is missing or not a number"));
             continue;
         };
         let mut key = Keyframe::new(tm.units(i64::from(units), scale), value);
@@ -404,7 +416,7 @@ pub(crate) fn import_keys(node: &AepProp<'_, '_>, kind: Kind, layer_name: &str,
                 None => {
                     // The ease cannot be used, so the bezier sides become linear.
                     let why = if undecoded { "the ease of this effect parameter is not decoded" } else { "ease data not decodable" };
-                    col.lose(LossCategory::ApproximatedKeyframes, format!("{what}: bezier key read as linear ({why})"));
+                    col.lose_with(LossCategory::ApproximatedKeyframes, || format!("{what}: bezier key read as linear ({why})"));
                     if key.in_interp == Interp::Bezier {
                         key.in_interp = Interp::Linear;
                     }
@@ -419,12 +431,7 @@ pub(crate) fn import_keys(node: &AepProp<'_, '_>, kind: Kind, layer_name: &str,
     if keys.is_empty() {
         return;
     }
-    keys.sort_by_key(|k| k.time);
-    let before = keys.len();
-    keys.dedup_by_key(|k| k.time);
-    if keys.len() != before {
-        col.lose(LossCategory::DamagedData, format!("{what}: keyframes at the same time"));
-    }
+    sort_unique(&mut keys, &what, "keyframes", col);
     // The first key's incoming and the last key's outgoing ease mean nothing.
     if let Some(first) = keys.first_mut() {
         first.in_ease.clear();
@@ -438,3 +445,25 @@ pub(crate) fn import_keys(node: &AepProp<'_, '_>, kind: Kind, layer_name: &str,
     }
     prop.keys = keys;
 }
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use effectcraft_time::Tick;
+
+    #[test]
+    fn keys_at_the_same_time_are_merged_and_reported() {
+        let key = |t: i64, v: f64| Keyframe::new(Tick(t), Value::Scalar(v));
+        let mut keys = vec![key(5, 1.0), key(0, 2.0), key(5, 3.0)];
+        let mut col = Collector::default();
+        sort_unique(&mut keys, "L: ADBE Orientation", "keyframes", &mut col);
+        assert_eq!(keys.iter().map(|k| (k.time.0, k.value.clone())).collect::<Vec<_>>(), [(0, Value::Scalar(2.0)), (5, Value::Scalar(1.0))]);
+        let report = col.finish();
+        assert_eq!(report.count(LossCategory::DamagedData), 1);
+        assert_eq!(report.losses[0].details, ["L: ADBE Orientation: keyframes at the same time"]);
+        // Distinct times: nothing reported.
+        let mut col = Collector::default();
+        sort_unique(&mut vec![key(1, 0.0), key(0, 0.0)], "L", "keyframes", &mut col);
+        assert!(col.finish().losses.is_empty());
+    }
+}
diff --git a/crates/aep/src/import/styles.rs b/crates/aep/src/import/styles.rs
index 51585a0e7..709de2177 100644
--- a/crates/aep/src/import/styles.rs
+++ b/crates/aep/src/import/styles.rs
@@ -54,7 +54,7 @@ fn key_kind(conv: StyleConv) -> Option<Kind> {
 fn import_param(spec: &StyleParam, full: &str, node: Option<PropNode<'_, '_>>, prop: &mut EcProp, tm: &TimeMap, what: &str, col: &mut Collector) {
     if spec.conv == StyleConv::Gradient {
         if node.is_some() {
-            col.lose(LossCategory::LayerStyles, format!("{what}: {full} (gradient colours are not decoded, EffectCraft's default gradient kept)"));
+            col.lose_with(LossCategory::LayerStyles, || format!("{what}: {full} (gradient colours are not decoded, EffectCraft's default gradient kept)"));
         }
         return;
     }
@@ -63,7 +63,7 @@ fn import_param(spec: &StyleParam, full: &str, node: Option<PropNode<'_, '_>>, p
     }
     let Some(node) = node else { return };
     let PropNode::Property(p) = node else {
-        col.lose(LossCategory::LayerStyles, format!("{what}: {full} is not a property, default used"));
+        col.lose_with(LossCategory::LayerStyles, || format!("{what}: {full} is not a property, default used"));
         return;
     };
     import_record(spec.conv, &p, full, prop, tm, what, col);
@@ -73,12 +73,12 @@ fn import_record(conv: StyleConv, p: &AepProp<'_, '_>, full: &str, prop: &mut Ec
     if p.is_animated() {
         match key_kind(conv) {
             Some(kind) => import_keys(p, kind, what, full, tm, prop, col),
-            None => col.lose(LossCategory::LayerStyles, format!("{what}: keys on {full} are not imported (not sampled), default used")),
+            None => col.lose_with(LossCategory::LayerStyles, || format!("{what}: keys on {full} are not imported (not sampled), default used")),
         }
     } else if let Some(stored) = p.static_value() {
         match value(conv, &stored) {
             Some(v) => prop.value = v,
-            None => col.lose(LossCategory::LayerStyles, format!("{what}: {full} holds a value that is not valid ({stored:?}), default used")),
+            None => col.lose_with(LossCategory::LayerStyles, || format!("{what}: {full} holds a value that is not valid ({stored:?}), default used")),
         }
     }
     import_expression(p, prop, col);
@@ -102,33 +102,37 @@ pub(crate) fn import_layer_styles(layer: &AepLayer<'_, '_>, l: &mut Layer, gl: &
             Some(sm::FLAGS_ON) => true,
             Some(sm::FLAGS_OFF) => false,
             other => {
-                col.lose(LossCategory::LayerStyles, format!("{what}: style {prefix} in state {} (not sampled), not imported", other.unwrap_or(0)));
+                col.lose_with(LossCategory::LayerStyles, || format!("{what}: style {prefix} in state {} (not sampled), not imported", other.unwrap_or(0)));
                 continue;
             }
         };
         match sm::by_ae(prefix) {
             Some(spec) => applied.push((spec, g, on)),
-            None if prefix == sm::PATTERN_OVERLAY => col.lose(LossCategory::LayerStyles, format!("{what}: Pattern Overlay (no counterpart)")),
-            None => col.lose(LossCategory::LayerStyles, format!("{what}: unknown layer style {prefix}")),
+            None if prefix == sm::PATTERN_OVERLAY => col.lose_with(LossCategory::LayerStyles, || format!("{what}: Pattern Overlay (no counterpart)")),
+            None => col.lose_with(LossCategory::LayerStyles, || format!("{what}: unknown layer style {prefix}")),
         }
     }
     if applied.is_empty() {
         // Without a style the Blending Options group holds only an empty Advanced Blending group
         // (every case); stored values there have nowhere to go.
-        if let Some(PropNode::Group(bo)) = ls.get(sm::BLEND_OPTIONS)
-            && holds_values(&bo, 0)
-        {
-            col.lose(LossCategory::LayerStyles, format!("{what}: Blending Options set without a layer style, not imported"));
+        if let Some(PropNode::Group(bo)) = ls.get(sm::BLEND_OPTIONS) {
+            match holds_values(&bo, 0) {
+                Held::Values => col.lose_with(LossCategory::LayerStyles, || format!("{what}: Blending Options set without a layer style, not imported")),
+                Held::TooDeep => col.lose_with(LossCategory::LayerStyles, || {
+                    format!("{what}: Blending Options nest groups deeper than {MAX_HELD_DEPTH} levels, not read (they may hold values)")
+                }),
+                Held::Nothing => {}
+            }
         }
         return;
     }
     if !l.can_have_styles() {
-        col.lose(LossCategory::LayerStyles, format!("{what}: this kind of layer takes no layer styles here ({} not imported)", applied.len()));
+        col.lose_with(LossCategory::LayerStyles, || format!("{what}: this kind of layer takes no layer styles here ({} not imported)", applied.len()));
         return;
     }
     for (spec, g, on) in &applied {
         let Some(uid) = st::add_style(l, ids, spec.ec, gl, *on) else {
-            col.lose(LossCategory::LayerStyles, format!("{what}: style {} could not be added", spec.ae));
+            col.lose_with(LossCategory::LayerStyles, || format!("{what}: style {} could not be added", spec.ae));
             continue;
         };
         let Some(group) = l.props.find_group_mut(uid) else { continue };
@@ -138,12 +142,12 @@ pub(crate) fn import_layer_styles(layer: &AepLayer<'_, '_>, l: &mut Layer, gl: &
             let node = records.iter().find(|r| r.match_name == full).map(|r| r.node);
             match group.get_mut(prm.ec) {
                 Some(prop) => import_param(prm, &full, node, prop, tm, what, col),
-                None => col.lose(LossCategory::LayerStyles, format!("{what}: {full} has no counterpart '{}'", prm.ec)),
+                None => col.lose_with(LossCategory::LayerStyles, || format!("{what}: {full} has no counterpart '{}'", prm.ec)),
             }
         }
         for r in &records {
             if r.match_name != "ADBE Group End" && !spec.params.iter().any(|prm| spec.param_name(prm) == r.match_name) {
-                col.lose(LossCategory::LayerStyles, format!("{what}: {} is not imported (unknown parameter)", r.match_name));
+                col.lose_with(LossCategory::LayerStyles, || format!("{what}: {} is not imported (unknown parameter)", r.match_name));
             }
         }
         col.imported.layer_styles += 1;
@@ -151,14 +155,40 @@ pub(crate) fn import_layer_styles(layer: &AepLayer<'_, '_>, l: &mut Layer, gl: &
     import_blending(&ls, l, tm, what, col);
 }
 
-/// True when `g` or a group below it (to a bounded depth) stores a property.
-fn holds_values(g: &AepGroup<'_, '_>, depth: usize) -> bool {
-    depth < 8
-        && g.entries().iter().any(|e| match e.node {
-            PropNode::Property(_) => true,
-            PropNode::Group(sub) => holds_values(&sub, depth.saturating_add(1)),
-            PropNode::Other(_) => false,
-        })
+/// The deepest group below Blending Options that is looked into for stored values.
+const MAX_HELD_DEPTH: usize = 8;
+
+/// What a group stores, looked at to [`MAX_HELD_DEPTH`].
+#[derive(Clone, Copy, Debug, PartialEq, Eq)]
+enum Held {
+    Nothing,
+    /// A property, in the group or a group below it.
+    Values,
+    /// No property within the depth, but a group at the depth limit that is not empty (it may
+    /// hold values; deeper is not read).
+    TooDeep,
+}
+
+/// Whether `g` or a group below it (to a bounded depth) stores a property. A non-empty group at
+/// the depth limit is not looked into: it counts as [`Held::TooDeep`] (reported), not as empty;
+/// After Effects nests Blending Options two levels deep.
+fn holds_values(g: &AepGroup<'_, '_>, depth: usize) -> Held {
+    if depth >= MAX_HELD_DEPTH {
+        return if g.entries().is_empty() { Held::Nothing } else { Held::TooDeep };
+    }
+    let mut held = Held::Nothing;
+    for e in g.entries() {
+        match e.node {
+            PropNode::Property(_) => return Held::Values,
+            PropNode::Group(sub) => match holds_values(&sub, depth.saturating_add(1)) {
+                Held::Values => return Held::Values,
+                Held::TooDeep => held = Held::TooDeep,
+                Held::Nothing => {}
+            },
+            PropNode::Other(_) => {}
+        }
+    }
+    held
 }
 
 /// Blending Options: Global Light (adopted by the composition later) and Advanced Blending.
diff --git a/crates/aep/tests/it/export.rs b/crates/aep/tests/it/export.rs
index 13d438b48..18eee2869 100644
--- a/crates/aep/tests/it/export.rs
+++ b/crates/aep/tests/it/export.rs
@@ -3,6 +3,7 @@
 #[macro_use]
 mod helpers;
 
+mod bounds;
 mod built;
 mod ease;
 mod effects;
diff --git a/crates/aep/tests/it/export/bounds.rs b/crates/aep/tests/it/export/bounds.rs
new file mode 100644
index 000000000..4958304f5
--- /dev/null
+++ b/crates/aep/tests/it/export/bounds.rs
@@ -0,0 +1,72 @@
+//! Projects that used to cost quadratic time to export (#3299): many layers of one
+//! precomposition in a composition that is itself shown many times, and a long parent chain. The
+//! sizes are moderate, so the tests check what is written; the bounds are pinned by the unit tests
+//! in `export::plan`.
+
+use std::sync::Arc;
+
+use crate::export::helpers::*;
+use effectcraft_aep::export::LossCategory;
+use effectcraft_project::{ItemId, ItemKind, LayerSource, Project, build};
+use effectcraft_time::FrameRate;
+
+/// Puts `n` layers of `source` into `comp` at once; `edit` changes layer `i`.
+fn fill(p: &mut Project, comp: ItemId, n: usize, source: LayerSource, edit: &dyn Fn(usize, &mut effectcraft_project::Layer)) {
+    let mut c = p.comp(comp).cloned().expect("comp");
+    for i in 0..n {
+        let mut l = build::layer(p, &c, &format!("L{i}"), source.clone(), (100, 100), None);
+        l.name = format!("L{i}");
+        edit(i, &mut l);
+        c.layers.push(l);
+    }
+    if let Some(item) = p.item_mut(comp) {
+        item.kind = ItemKind::Comp(Arc::new(c));
+    }
+}
+
+#[test]
+fn many_layers_of_one_precomp_in_a_shown_composition_are_written() {
+    let n = 1500;
+    let mut p = Project::default();
+    let a = add_comp(&mut p, "A", 100, 100, FrameRate::new(25, 1), 1.0, None);
+    let s = add_solid(&mut p, "S", 100, 100, [1.0, 0.0, 0.0], None);
+    add_layer(&mut p, a, "S", LayerSource::Solid { item: s }, (100, 100));
+    let b = add_comp(&mut p, "B", 100, 100, FrameRate::new(25, 1), 1.0, None);
+    fill(&mut p, b, n, LayerSource::Comp { item: a }, &|_, _| {});
+    let c = add_comp(&mut p, "C", 100, 100, FrameRate::new(25, 1), 1.0, None);
+    fill(&mut p, c, n, LayerSource::Comp { item: b }, &|_, _| {});
+    let r = export_all(&p);
+    assert_eq!(r.report.exported.precomp_layers, 2 * n);
+    assert_eq!(r.report.count(LossCategory::UnsupportedLayers), 0, "{:?}", r.report.losses);
+}
+
+#[test]
+fn a_long_parent_chain_is_written_and_its_loop_cut_once() {
+    let n = 1500;
+    let mut p = Project::default();
+    let s = add_solid(&mut p, "S", 100, 100, [1.0, 0.0, 0.0], None);
+    let c = add_comp(&mut p, "C", 100, 100, FrameRate::new(25, 1), 1.0, None);
+    fill(&mut p, c, n, LayerSource::Solid { item: s }, &|_, _| {});
+    // Each layer parented to the next; with `closed`, the last to the first (a loop).
+    for closed in [false, true] {
+        let mut q = p.clone();
+        with_comp(&mut q, c, |cc| {
+            let ids: Vec<_> = cc.layers.iter().map(|l| l.id).collect();
+            for i in 0..n {
+                let next = if i + 1 < n {
+                    Some(ids[i + 1])
+                } else if closed {
+                    Some(ids[0])
+                } else {
+                    None
+                };
+                if let Some(l) = cc.layers.get_mut(i) {
+                    l.parent = next;
+                }
+            }
+        });
+        let r = export_all(&q);
+        assert_eq!(r.report.exported.layers, n);
+        assert_eq!(r.report.count(LossCategory::ParentLinks), usize::from(closed), "{:?}", r.report.losses);
+    }
+}
diff --git a/crates/aep/tests/it/import.rs b/crates/aep/tests/it/import.rs
index eb6963d6f..2d1878a37 100644
--- a/crates/aep/tests/it/import.rs
+++ b/crates/aep/tests/it/import.rs
@@ -5,6 +5,7 @@ mod helpers;
 
 mod aepx;
 mod blend_modes;
+mod bounds;
 mod cameras;
 mod cases;
 mod combined;
diff --git a/crates/aep/tests/it/import/bounds.rs b/crates/aep/tests/it/import/bounds.rs
new file mode 100644
index 000000000..2fa0c3003
--- /dev/null
+++ b/crates/aep/tests/it/import/bounds.rs
@@ -0,0 +1,316 @@
+//! Hostile inputs that used to cost quadratic time, and losses that used to be silent (#3299).
+//!
+//! The quadratic cases are built from the committed `tests/fixtures/synthetic.aep` (composition
+//! `C`, id 2, with a sequence layer, id 17, and a solid layer, id 16): its composition item and
+//! its solid layer are copied with new ids. The sizes here are moderate, so the tests check what
+//! arrives; the bounds themselves are pinned by the unit tests next to the code
+//! (`import::build`, `import::effects`).
+
+use effectcraft_aep::import::{ImportOptions, ImportResult, LossCategory, import};
+use effectcraft_aep::{AepFile, Body, Chunk, parse, write};
+use effectcraft_project::{ItemKind, LayerId, LayerSource, Project};
+
+const SYNTHETIC: &[u8] = include_bytes!("../../fixtures/synthetic.aep");
+/// The item id of composition `C` and the layer id of its solid layer.
+const COMP_C: u32 = 2;
+const SOLID_LAYER: u32 = 16;
+
+fn run(bytes: &[u8]) -> (Project, ImportResult) {
+    let mut project = Project::default();
+    let none = |_: &str| false;
+    let r = import(&mut project, bytes, &ImportOptions { allow_losses: true, ..ImportOptions::new(&none) }).expect("imports");
+    (project, r)
+}
+
+fn losses(r: &ImportResult, category: LossCategory) -> Vec<String> {
+    r.report.losses.iter().filter(|l| l.category == category).flat_map(|l| l.details.clone()).collect()
+}
+
+fn set_be_u32(c: &mut Chunk<'_>, at: usize, v: u32) {
+    if let Body::Data(d) = &mut c.body {
+        d.to_mut()[at..at + 4].copy_from_slice(&v.to_be_bytes());
+    }
+}
+
+fn be_u32(c: &Chunk<'_>, at: usize) -> u32 {
+    u32::from_be_bytes(c.bytes().expect("data")[at..at + 4].try_into().unwrap())
+}
+
+fn children<'c, 'a>(c: &'c mut Chunk<'a>) -> &'c mut Vec<Chunk<'a>> {
+    match &mut c.body {
+        Body::List { children, .. } | Body::Chunks(children) => children,
+        _ => panic!("not a list"),
+    }
+}
+
+/// The project's folder list (`LIST Fold`, top level).
+fn fold<'f, 'a>(file: &'f mut AepFile<'a>) -> &'f mut Vec<Chunk<'a>> {
+    children(file.chunks.iter_mut().find(|c| c.is_list(b"Fold")).expect("Fold"))
+}
+
+/// The `Item` list of composition `C`.
+fn comp_c<'a>(file: &AepFile<'a>) -> Chunk<'a> {
+    let fold = file.list(b"Fold").expect("Fold");
+    fold.children().iter().find(|c| c.is_list(b"Item") && c.child(b"idta").is_some_and(|i| be_u32(i, 16) == COMP_C)).expect("composition C").clone()
+}
+
+/// The solid layer of `C` (`LIST Layr` with id 16).
+fn solid_layer<'a>(comp: &Chunk<'a>) -> Chunk<'a> {
+    comp.children().iter().find(|c| c.is_list(b"Layr") && c.child(b"ldta").is_some_and(|l| be_u32(l, 0) == SOLID_LAYER)).expect("the solid layer").clone()
+}
+
+/// A copy of `layer` with layer id `id`; `edit` changes its `ldta`.
+fn layer_copy<'a>(layer: &Chunk<'a>, id: u32, edit: &dyn Fn(&mut Chunk<'a>)) -> Chunk<'a> {
+    let mut l = layer.clone();
+    let ldta = children(&mut l).iter_mut().find(|c| c.is(b"ldta")).expect("ldta");
+    set_be_u32(ldta, 0, id);
+    edit(ldta);
+    l
+}
+
+/// A composition like `C` with item id `id`, name `name` and only the layers `layers`.
+fn comp_with<'a>(c: &Chunk<'a>, id: u32, name: &str, layers: Vec<Chunk<'a>>) -> Chunk<'a> {
+    let mut item = c.clone();
+    let kids = children(&mut item);
+    kids.retain(|k| !k.is_list(b"Layr"));
+    for k in kids.iter_mut() {
+        if k.is(b"idta") {
+            set_be_u32(k, 16, id);
+        }
+        if k.is(b"Utf8") {
+            *k = Chunk::data(*b"Utf8", name.as_bytes().to_vec());
+        }
+    }
+    let at = kids.iter().position(|k| k.is_list(b"Ewst")).unwrap_or(kids.len());
+    kids.splice(at..at, layers);
+    item
+}
+
+/// Composition `B` (id 900) with `n` layers of `C`, and `D` (id 901) with `n` layers of `B`,
+/// after `C` in the file. With `c_uses_d`, `C` also gets a layer of `D`, which closes a loop.
+fn precomp_chain(n: u32, c_uses_d: bool) -> Vec<u8> {
+    let mut file = parse(SYNTHETIC).unwrap();
+    let c = comp_c(&file);
+    let solid = solid_layer(&c);
+    let layers = |first: u32, source: u32| -> Vec<Chunk<'_>> { (0..n).map(|i| layer_copy(&solid, first + i, &|l| set_be_u32(l, 40, source))).collect() };
+    let b = comp_with(&c, 900, "B", layers(100_000, COMP_C));
+    let d = comp_with(&c, 901, "D", layers(200_000, 900));
+    let fold = fold(&mut file);
+    let at = fold.iter().position(|k| k.is_list(b"Item") && k.child(b"idta").is_some_and(|i| be_u32(i, 16) == COMP_C)).expect("C") + 1;
+    fold.splice(at..at, [b, d]);
+    if c_uses_d {
+        let c = fold.iter_mut().find(|k| k.is_list(b"Item") && k.child(b"idta").is_some_and(|i| be_u32(i, 16) == COMP_C)).expect("C");
+        let kids = children(c);
+        let at = kids.iter().position(|k| k.is_list(b"Layr")).expect("a layer");
+        kids.insert(at, layer_copy(&solid, 300_000, &|l| set_be_u32(l, 40, 901)));
+    }
+    write(&file).unwrap()
+}
+
+fn comp_named<'p>(p: &'p Project, name: &str) -> &'p effectcraft_project::Comp {
+    p.items.values().find_map(|i| if let ItemKind::Comp(c) = &i.kind { (i.name == name).then_some(&**c) } else { None }).unwrap_or_else(|| panic!("no {name}"))
+}
+
+#[test]
+fn many_layers_of_one_precomp_in_a_used_composition_import() {
+    let n = 1500;
+    let (p, r) = run(&precomp_chain(n, false));
+    let (b, d) = (comp_named(&p, "B"), comp_named(&p, "D"));
+    let item = |name: &str| p.items.values().find(|i| i.name == name).map(|i| i.id).expect("item");
+    assert_eq!(b.layers.len(), n as usize);
+    assert!(b.layers.iter().all(|l| l.source == LayerSource::Comp { item: item("C") }));
+    assert!(d.layers.iter().all(|l| l.source == LayerSource::Comp { item: item("B") }));
+    assert_eq!(d.layers.len(), n as usize);
+    assert_eq!(r.report.imported.precomp_layers, 2 * n as usize);
+    let found = losses(&r, LossCategory::UnsupportedLayers);
+    assert!(!found.iter().any(|d| d.contains("loop")), "{found:?}");
+}
+
+#[test]
+fn every_precomp_layer_that_closes_a_loop_is_refused() {
+    // C (built first) uses D; B uses C; so D's layers of B would close C -> D -> B -> C.
+    let n = 300;
+    let (_, base) = run(SYNTHETIC);
+    let (p, r) = run(&precomp_chain(n, true));
+    assert_eq!(comp_named(&p, "B").layers.len(), n as usize);
+    assert!(comp_named(&p, "D").layers.is_empty());
+    let refused = r.report.count(LossCategory::UnsupportedLayers) - base.report.count(LossCategory::UnsupportedLayers);
+    assert_eq!(refused, n as usize, "{:?}", r.report.losses);
+    assert!(losses(&r, LossCategory::UnsupportedLayers).iter().any(|d| d.contains("precomposition loop")));
+}
+
+#[test]
+fn many_parented_and_matted_layers_resolve() {
+    // `n` copies of the solid layer in C, each parented to it and using it as an alpha matte.
+    let n = 1500;
+    let mut file = parse(SYNTHETIC).unwrap();
+    let c = comp_c(&file);
+    let solid = solid_layer(&c);
+    let fold = fold(&mut file);
+    let item = fold.iter_mut().find(|k| k.is_list(b"Item") && k.child(b"idta").is_some_and(|i| be_u32(i, 16) == COMP_C)).expect("C");
+    let kids = children(item);
+    let at = kids.iter().position(|k| k.is_list(b"Layr")).expect("a layer");
+    let copies: Vec<Chunk<'_>> = (0..n)
+        .map(|i| {
+            layer_copy(&solid, 100_000 + i, &|l| {
+                set_be_u32(l, 132, SOLID_LAYER);
+                if let Body::Data(d) = &mut l.body {
+                    d.to_mut()[107] = 1;
+                }
+                set_be_u32(l, 160, SOLID_LAYER);
+            })
+        })
+        .collect();
+    kids.splice(at..at, copies);
+    let (p, r) = run(&write(&file).unwrap());
+    let c = comp_named(&p, "C");
+    // The original solid layer: the last layer whose source is the solid and that has no parent.
+    let target: LayerId = c.layers.iter().rev().find(|l| l.parent.is_none() && matches!(l.source, LayerSource::Solid { .. })).map(|l| l.id).expect("the solid");
+    let linked: Vec<_> = c.layers.iter().filter(|l| l.parent.is_some()).collect();
+    assert_eq!(linked.len(), n as usize);
+    assert!(linked.iter().all(|l| l.parent == Some(target) && l.track_matte.map(|m| m.layer) == Some(target)));
+    assert_eq!(r.report.imported.track_mattes, n as usize);
+    assert_eq!(r.report.count(LossCategory::ParentLinks), 0, "{:?}", r.report.losses);
+}
+
+/// `count` nested groups (`tdmn` + `LIST tdgp`), the innermost empty.
+fn nested(count: usize) -> Vec<Chunk<'static>> {
+    let end = || {
+        let mut name = b"ADBE Group End".to_vec();
+        name.resize(40, 0);
+        Chunk::data(*b"tdmn", name)
+    };
+    let mut inner = vec![end()];
+    for _ in 0..count {
+        let mut name = b"ADBE Deep Group".to_vec();
+        name.resize(40, 0);
+        inner = vec![Chunk::data(*b"tdmn", name), Chunk::list(*b"tdgp", inner), end()];
+    }
+    inner
+}
+
+#[test]
+fn blending_options_nested_past_the_read_depth_are_reported() {
+    let mut file = parse(SYNTHETIC).unwrap();
+    let mut patched = 0;
+    // Every layer's Advanced Blending group gets groups nested twelve deep (no property in them).
+    fn visit(chunks: &mut [Chunk<'_>], patched: &mut usize) {
+        let mut next_is_adv = false;
+        for c in chunks.iter_mut() {
+            if next_is_adv && c.is_list(b"tdgp") {
+                *children(c) = nested(12);
+                *patched += 1;
+            }
+            next_is_adv = c.is(b"tdmn") && c.bytes().is_some_and(|b| b.starts_with(b"ADBE Adv Blend Group\0"));
+            visit(c.children_mut(), patched);
+        }
+    }
+    visit(&mut file.chunks, &mut patched);
+    assert!(patched >= 2, "{patched}");
+    let (_, r) = run(&write(&file).unwrap());
+    let found = losses(&r, LossCategory::LayerStyles);
+    assert!(found.iter().any(|d| d.contains("deeper than 8 levels")), "{found:?}");
+    // Nested within the depth, an empty group still holds nothing.
+    let mut file = parse(SYNTHETIC).unwrap();
+    fn shallow(chunks: &mut [Chunk<'_>]) {
+        let mut next_is_adv = false;
+        for c in chunks.iter_mut() {
+            if next_is_adv && c.is_list(b"tdgp") {
+                *children(c) = nested(3);
+            }
+            next_is_adv = c.is(b"tdmn") && c.bytes().is_some_and(|b| b.starts_with(b"ADBE Adv Blend Group\0"));
+            shallow(c.children_mut());
+        }
+    }
+    shallow(&mut file.chunks);
+    let (_, r) = run(&write(&file).unwrap());
+    assert_eq!(losses(&r, LossCategory::LayerStyles), Vec::<String>::new());
+}
+
+/// Every key record of the property `match_name` (the `LIST list` of its `LIST tdbs`; a mask
+/// shape's vertex lists are not touched) gets `patch`.
+fn patch_keys(file: &mut AepFile<'_>, match_name: &[u8], patch: &dyn Fn(usize, &mut [u8])) -> usize {
+    fn lists(c: &mut Chunk<'_>, patch: &dyn Fn(usize, &mut [u8]), n: &mut usize) {
+        if c.is_list(b"tdbs") {
+            for k in c.children_mut() {
+                keys(k, patch, n);
+            }
+            return;
+        }
+        for k in c.children_mut() {
+            lists(k, patch, n);
+        }
+    }
+    fn keys(c: &mut Chunk<'_>, patch: &dyn Fn(usize, &mut [u8]), n: &mut usize) {
+        if c.is_list(b"list") {
+            let size = c.child(b"lhd3").and_then(|h| h.bytes()).map(|h| u32::from_be_bytes(h[16..20].try_into().unwrap()) as usize).unwrap_or(0);
+            if let Some(Body::Data(d)) = children(c).iter_mut().find(|k| k.is(b"ldat")).map(|k| &mut k.body)
+                && size > 0
+            {
+                for (i, rec) in d.to_mut().chunks_exact_mut(size).enumerate() {
+                    patch(i, rec);
+                    *n += 1;
+                }
+            }
+        }
+    }
+    fn visit(chunks: &mut [Chunk<'_>], name: &[u8], patch: &dyn Fn(usize, &mut [u8]), n: &mut usize) {
+        let mut next = false;
+        for c in chunks.iter_mut() {
+            if next {
+                lists(c, patch, n);
+            }
+            next = c.is(b"tdmn") && c.bytes().is_some_and(|b| b.strip_prefix(name).is_some_and(|r| r.first() == Some(&0)));
+            visit(c.children_mut(), name, patch, n);
+        }
+    }
+    let mut n = 0;
+    visit(&mut file.chunks, match_name, patch, &mut n);
+    n
+}
+
+#[test]
+fn orientation_keys_at_the_same_time_are_reported() {
+    let Some(bytes) = crate::common::try_fixture("703-key-orientation-0-to-10-20-30-linear.aep") else { return };
+    let mut file = parse(&bytes).unwrap();
+    // The second key at the first key's time (the record starts with its time).
+    let first = std::cell::Cell::new([0u8; 4]);
+    let n = patch_keys(&mut file, b"ADBE Orientation", &|i, rec| {
+        if i == 0 {
+            first.set(rec[0..4].try_into().unwrap());
+        } else {
+            rec[0..4].copy_from_slice(&first.get());
+        }
+    });
+    assert!(n >= 2, "{n}");
+    let (p, r) = run(&write(&file).unwrap());
+    let found = losses(&r, LossCategory::DamagedData);
+    assert!(found.iter().any(|d| d.contains("ADBE Orientation: keyframes at the same time")), "{found:?}");
+    let l = comp_named(&p, "C").layers.iter().find(|l| l.name == "L").expect("L");
+    assert_eq!(l.props.prop("transform/orientation").expect("orientation").keys.len(), 1);
+}
+
+#[test]
+fn a_mask_path_ease_speed_beyond_the_limit_is_not_imported() {
+    let Some(bytes) = crate::common::try_fixture("700-key-mask-path-ease-out20-in50.aep") else { return };
+    let mut file = parse(&bytes).unwrap();
+    // Both speeds (bytes 24 and 40 of a mask path record) far past what a property key accepts.
+    let n = patch_keys(&mut file, b"ADBE Mask Shape", &|_, rec| {
+        rec[24..32].copy_from_slice(&1e12f64.to_be_bytes());
+        rec[40..48].copy_from_slice(&1e12f64.to_be_bytes());
+    });
+    assert!(n >= 2, "{n}");
+    let (p, r) = run(&write(&file).unwrap());
+    let found = losses(&r, LossCategory::ApproximatedKeyframes);
+    assert!(found.iter().any(|d| d.contains("its ease is unreadable")), "{found:?}");
+    let speeds: Vec<f64> = p
+        .items
+        .values()
+        .filter_map(|i| if let ItemKind::Comp(c) = &i.kind { Some(c.layers.iter().cloned().collect::<Vec<_>>()) } else { None })
+        .flatten()
+        .flat_map(|l| l.props.sub("masks").map(|m| m.groups().filter_map(|g| g.prop("path").cloned()).collect::<Vec<_>>()).unwrap_or_default())
+        .flat_map(|p| p.keys)
+        .flat_map(|k| k.in_ease.into_iter().chain(k.out_ease).map(|e| e.speed))
+        .collect();
+    assert!(speeds.iter().all(|s| s.abs() <= 1e11), "{speeds:?}");
+}

From 2e24ae47a1a72fa925fe6339d4317f7821f3650e Mon Sep 17 00:00:00 2001
From: vangel76 <vangel1976@googlemail.com>
Date: Sun, 8 Nov 2026 16:21:57 +0100
Subject: [PATCH 24/30] aep export: the time remap and Transform keys use the
 shared key-list and match-name helpers; doc comments for the audit's
 functions (#3300)

---
 crates/aep/src/container/aepx.rs              |  5 ++
 crates/aep/src/container/effects.rs           |  1 +
 crates/aep/src/container/index.rs             | 23 ++++++
 crates/aep/src/container/read.rs              |  4 +
 crates/aep/src/container/settings.rs          |  1 +
 crates/aep/src/container/textdoc.rs           | 35 ++++++++
 crates/aep/src/container/typed.rs             |  2 +
 crates/aep/src/container/write.rs             |  3 +
 crates/aep/src/export/base.rs                 |  2 +
 crates/aep/src/export/emit.rs                 | 82 +++++++------------
 crates/aep/src/export/fxsynth.rs              |  1 +
 crates/aep/src/export/keys.rs                 |  3 +
 crates/aep/src/export/masks.rs                |  3 +
 crates/aep/src/export/report.rs               |  3 +
 crates/aep/src/export/synth.rs                |  4 +
 crates/aep/src/export/tree.rs                 |  4 +
 crates/aep/src/import.rs                      |  2 +
 crates/aep/src/import/report.rs               |  3 +
 .../aep/tests/it/container/batch3_objects.rs  |  1 +
 .../aep/tests/it/container/layer_switches.rs  |  1 +
 crates/aep/tests/it/container/tree_index.rs   |  5 ++
 crates/aep/tests/it/export/built.rs           |  1 +
 22 files changed, 136 insertions(+), 53 deletions(-)

diff --git a/crates/aep/src/container/aepx.rs b/crates/aep/src/container/aepx.rs
index e79b904d1..6ca729807 100644
--- a/crates/aep/src/container/aepx.rs
+++ b/crates/aep/src/container/aepx.rs
@@ -658,6 +658,7 @@ mod tests {
         assert!(matches!(read_aepx(b"<AfterEffectsProject>\xff</AfterEffectsProject>"), Err(AepError::Xml { .. })));
     }
 
+    /// Attribute values decode entities only where they have them.
     #[test]
     fn attribute_values_decode_entities_only_where_they_have_them() {
         // An entity inside `bdata` still decodes before the hex does.
@@ -672,6 +673,7 @@ mod tests {
         assert_eq!(f.chunks[0].bytes(), Some(&[0x0a, 0xff][..]));
     }
 
+    /// A large bdata with a bad digit is refused before it is sized.
     #[test]
     fn a_large_bdata_with_a_bad_digit_is_refused_before_it_is_sized() {
         // 10 MB of hex that is bad from the first pair (and once more at the very end).
@@ -685,6 +687,7 @@ mod tests {
         assert!(matches!(read_aepx(x.as_bytes()), Err(AepError::Xml { .. })));
     }
 
+    /// Bdata decodes up to the size limit and not past it.
     #[test]
     fn bdata_decodes_up_to_the_size_limit_and_not_past_it() {
         assert_eq!(decode_hex_at_most(b"00ff10", 0, 3), Ok(vec![0x00, 0xff, 0x10]));
@@ -697,8 +700,10 @@ mod tests {
         assert_eq!(MAX_BDATA as u64, u64::from(u32::MAX));
     }
 
+    /// Decode hex matches the collecting version.
     #[test]
     fn decode_hex_matches_the_collecting_version() {
+        /// The collecting decoder this one replaced, as the reference.
         fn old(text: &[u8], offset: usize) -> Result<Vec<u8>, AepError> {
             if text.len() % 2 == 1 {
                 return Err(xml(offset, "bdata has an odd number of hex digits"));
diff --git a/crates/aep/src/container/effects.rs b/crates/aep/src/container/effects.rs
index 09a5b1ed6..6ccfa3af6 100644
--- a/crates/aep/src/container/effects.rs
+++ b/crates/aep/src/container/effects.rs
@@ -293,6 +293,7 @@ impl<'f, 'a> Effect<'f, 'a> {
     }
 }
 
+/// True when a `LIST parT` holds parameter definitions (a `pard`).
 fn has_pard(part: Node<'_, '_>) -> bool {
     part.children().any(|c| c.is(b"pard"))
 }
diff --git a/crates/aep/src/container/index.rs b/crates/aep/src/container/index.rs
index cb9621e94..30d7fcb9d 100644
--- a/crates/aep/src/container/index.rs
+++ b/crates/aep/src/container/index.rs
@@ -57,6 +57,7 @@ struct Entry<'a> {
 }
 
 impl<'a> Entry<'a> {
+    /// An entry for a chunk whose body is not read yet.
     fn placeholder(id: [u8; 4]) -> Self {
         Self { data: &[], id, list_type: [0; 4], end: 0, kind: Kind::Data, pad: None }
     }
@@ -70,6 +71,7 @@ pub struct TreeIndex<'a> {
 }
 
 impl fmt::Debug for TreeIndex<'_> {
+    /// The sizes only: the chunk count and the trailer length.
     fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
         f.debug_struct("TreeIndex").field("chunks", &self.nodes.len()).field("trailer", &self.trailer.len()).finish()
     }
@@ -196,6 +198,7 @@ impl<'a> TreeIndex<'a> {
         AepFile { chunks: self.build(0, u32::try_from(self.nodes.len()).unwrap_or(u32::MAX)), trailer: Cow::Borrowed(self.trailer) }
     }
 
+    /// The entry at `at`, `None` past the end.
     fn entry(&self, at: u32) -> Option<&Entry<'a>> {
         self.nodes.get(usize::try_from(at).ok()?)
     }
@@ -332,10 +335,12 @@ impl<'a> Builder<'a> {
         }
     }
 
+    /// The input bytes `start..end` (empty when out of range).
     fn slice(&self, start: usize, end: usize) -> &'a [u8] {
         self.data.get(start..end).unwrap_or(&[])
     }
 
+    /// Fills in the body of the entry at `at` once the parser knows what it is.
     fn set(&mut self, at: usize, kind: Kind, data: &'a [u8], list_type: [u8; 4]) {
         if let Some(e) = self.nodes.get_mut(at) {
             e.kind = kind;
@@ -382,6 +387,7 @@ enum NodeRepr<'f, 'a> {
 }
 
 impl<'f, 'a> From<&'f Chunk<'a>> for Node<'f, 'a> {
+    /// The handle for this value.
     fn from(chunk: &'f Chunk<'a>) -> Self {
         Node(NodeRepr::Chunk(chunk))
     }
@@ -390,6 +396,7 @@ impl<'f, 'a> From<&'f Chunk<'a>> for Node<'f, 'a> {
 /// Prints the chunk as [`Chunk`]'s `Debug` does, whichever tree it is in, without copying the
 /// subtree.
 impl fmt::Debug for Node<'_, '_> {
+    /// The chunk as `Chunk`'s `Debug` prints it.
     fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
         match self.0 {
             NodeRepr::Chunk(c) => fmt::Debug::fmt(c, f),
@@ -405,6 +412,7 @@ struct BodyDebug<'f, 'a>(Node<'f, 'a>);
 struct ChildrenDebug<'f, 'a>(Node<'f, 'a>);
 
 impl fmt::Debug for BodyDebug<'_, '_> {
+    /// The body as `Body`'s `Debug` prints it.
     fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
         let Some(e) = self.0.entry() else { return f.write_str("?") };
         match e.kind {
@@ -417,12 +425,14 @@ impl fmt::Debug for BodyDebug<'_, '_> {
 }
 
 impl fmt::Debug for ChildrenDebug<'_, '_> {
+    /// The children as a list.
     fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
         f.debug_list().entries(self.0.children()).finish()
     }
 }
 
 impl<'f, 'a> Node<'f, 'a> {
+    /// The entry at `at`, `None` past the end.
     fn entry(self) -> Option<&'f Entry<'a>> {
         match self.0 {
             NodeRepr::Index(tree, at) => tree.entry(at),
@@ -570,6 +580,7 @@ enum NodesRepr<'f, 'a> {
 impl<'f, 'a> Iterator for Nodes<'f, 'a> {
     type Item = Node<'f, 'a>;
 
+    /// The next item, `None` at the end of the range.
     fn next(&mut self) -> Option<Self::Item> {
         match &mut self.0 {
             NodesRepr::Slice(it) => it.next().map(Node::from),
@@ -605,6 +616,7 @@ enum WalkRepr<'f, 'a> {
 impl<'f, 'a> Iterator for NodeWalk<'f, 'a> {
     type Item = (usize, Node<'f, 'a>);
 
+    /// The next item, `None` at the end of the range.
     fn next(&mut self) -> Option<Self::Item> {
         match &mut self.0 {
             WalkRepr::Chunk(w) => w.next().map(|(d, c)| (d, Node::from(c))),
@@ -637,12 +649,14 @@ pub(crate) enum Root<'f, 'a> {
 }
 
 impl<'f, 'a> From<&'f AepFile<'a>> for Root<'f, 'a> {
+    /// The handle for this value.
     fn from(file: &'f AepFile<'a>) -> Self {
         Root::File(file)
     }
 }
 
 impl<'f, 'a> From<&'f TreeIndex<'a>> for Root<'f, 'a> {
+    /// The handle for this value.
     fn from(index: &'f TreeIndex<'a>) -> Self {
         Root::Index(index)
     }
@@ -677,6 +691,7 @@ mod tests {
     struct Rng(u64);
 
     impl Rng {
+        /// The next pseudo-random number (xorshift64*).
         fn next(&mut self) -> u64 {
             let mut x = self.0;
             x ^= x >> 12;
@@ -686,6 +701,7 @@ mod tests {
             x.wrapping_mul(0x2545_f491_4f6c_dd1d)
         }
 
+        /// A number below `n` (0 for `n == 0`).
         fn below(&mut self, n: u64) -> u64 {
             if n == 0 { 0 } else { self.next() % n }
         }
@@ -745,6 +761,7 @@ mod tests {
         }
     }
 
+    /// The default limits and four tight ones (depth 1 and 3, 7 and 40 chunks).
     fn limits() -> [Limits; 5] {
         [
             Limits::default(),
@@ -755,6 +772,7 @@ mod tests {
         ]
     }
 
+    /// The index matches the chunk parser on generated and damaged trees.
     #[test]
     fn the_index_matches_the_chunk_parser_on_generated_and_damaged_trees() {
         let mut rng = Rng(0x9e37_79b9_7f4a_7c15);
@@ -785,6 +803,7 @@ mod tests {
         }
     }
 
+    /// Header errors are the same.
     #[test]
     fn header_errors_are_the_same() {
         for bytes in [&b""[..], b"RIFX", b"RIFX\0\0\0\x04Egg", b"RIFX\0\0\0\x04Fnord", b"RIFX\0\0\0\x08Egg!", b"RIFX\0\0\0\x03Egg!", b"RIFF\0\0\0\x04Egg!"] {
@@ -824,6 +843,7 @@ mod tests {
         }
     }
 
+    /// The index never reserves more than the input or the limit allows.
     #[test]
     fn the_index_never_reserves_more_than_the_input_or_the_limit_allows() {
         // 1000 empty headers: the most chunks the bytes can hold.
@@ -875,6 +895,7 @@ mod tests {
         data
     }
 
+    /// The index grows with the chunk count not the byte size.
     #[test]
     fn the_index_grows_with_the_chunk_count_not_the_byte_size() {
         // 4 MB in 4 chunks: a few slots, not one per 32 bytes (that would be 131 072 slots, 4 MB).
@@ -903,6 +924,7 @@ mod tests {
         out
     }
 
+    /// Failed attempts count once and leave nothing behind.
     #[test]
     fn failed_attempts_count_once_and_leave_nothing_behind() {
         let mut wide = b"Fold".to_vec();
@@ -928,6 +950,7 @@ mod tests {
         same(&data, Limits::default());
     }
 
+    /// Depth beyond the limit stays opaque without recursion past it.
     #[test]
     fn depth_beyond_the_limit_stays_opaque_without_recursion_past_it() {
         // 5000 nested lists: far deeper than the limit; everything below depth 64 stays bytes.
diff --git a/crates/aep/src/container/read.rs b/crates/aep/src/container/read.rs
index a47d06684..200b3d84a 100644
--- a/crates/aep/src/container/read.rs
+++ b/crates/aep/src/container/read.rs
@@ -63,6 +63,7 @@ pub(super) fn container_end(data: &[u8]) -> Result<usize, AepError> {
     usize::try_from(declared).map_err(|_| AepError::TooLarge)?.checked_add(8).ok_or(AepError::TooLarge)
 }
 
+/// The 4-byte id at `at`, `None` when the input is too short.
 pub(super) fn id4(data: &[u8], at: usize) -> Option<[u8; 4]> {
     array::<4>(data, at)
 }
@@ -183,6 +184,7 @@ mod tests {
         }
     }
 
+    /// Every sibling list is allocated once at its exact length.
     #[test]
     fn every_sibling_list_is_allocated_once_at_its_exact_length() {
         let inner: Vec<Chunk<'static>> = (0..37u8).map(|i| Chunk::data(*b"cdat", vec![i; usize::from(i % 5)])).collect();
@@ -201,6 +203,7 @@ mod tests {
         }
     }
 
+    /// The preallocation is bounded by the input and the chunk limit.
     #[test]
     fn the_preallocation_is_bounded_by_the_input_and_the_chunk_limit() {
         // 1000 empty headers: the most chunks the bytes can hold.
@@ -245,6 +248,7 @@ mod tests {
         out
     }
 
+    /// Nested lists with broken tails parse each header once.
     #[test]
     fn nested_lists_with_broken_tails_parse_each_header_once() {
         // A wide, well-formed list at the bottom, then 50 levels that each fail and fall back to
diff --git a/crates/aep/src/container/settings.rs b/crates/aep/src/container/settings.rs
index 3079d5c7d..a443df874 100644
--- a/crates/aep/src/container/settings.rs
+++ b/crates/aep/src/container/settings.rs
@@ -64,6 +64,7 @@ impl ProjectSettings {
         Self::of(Root::from(index))
     }
 
+    /// Reads the settings from the top-level chunks of either tree.
     pub(crate) fn of(file: Root<'_, '_>) -> ProjectSettings {
         let nhed = file.chunk(b"nhed").and_then(Node::bytes);
         let byte = |i: usize| nhed.and_then(|b| b.get(i).copied());
diff --git a/crates/aep/src/container/textdoc.rs b/crates/aep/src/container/textdoc.rs
index 2de5d8eb2..e673e63cf 100644
--- a/crates/aep/src/container/textdoc.rs
+++ b/crates/aep/src/container/textdoc.rs
@@ -184,29 +184,35 @@ struct Parser<'b> {
     items: Vec<V<'b>>,
 }
 
+/// Whitespace between tokens.
 fn is_ws(c: u8) -> bool {
     matches!(c, b' ' | b'\t' | b'\r' | b'\n')
 }
 
+/// A byte that ends a bare word.
 fn is_delimiter(c: u8) -> bool {
     is_ws(c) || matches!(c, b'/' | b'[' | b']' | b'<' | b'>' | b'(' | b')')
 }
 
 impl<'b> Parser<'b> {
+    /// The next byte, `None` at the end.
     fn peek(&self) -> Option<u8> {
         self.b.get(self.i).copied()
     }
 
+    /// Moves past whitespace.
     fn skip_ws(&mut self) {
         while self.peek().is_some_and(is_ws) {
             self.i = self.i.saturating_add(1);
         }
     }
 
+    /// True when the unread bytes start with `s`.
     fn starts_with(&self, s: &[u8]) -> bool {
         self.b.get(self.i..).is_some_and(|rest| rest.starts_with(s))
     }
 
+    /// The bare word at the position (up to the next delimiter), borrowed from the body.
     fn word(&mut self) -> &'b [u8] {
         let start = self.i;
         while self.peek().is_some_and(|c| !is_delimiter(c)) {
@@ -242,6 +248,7 @@ impl<'b> Parser<'b> {
         }
     }
 
+    /// The value at the position, `None` when it is malformed or nested deeper than the limit.
     fn parse(&mut self, depth: usize) -> Option<V<'b>> {
         self.skip_ws();
         if depth > MAX_DEPTH {
@@ -322,6 +329,7 @@ impl<'b> Parser<'b> {
     }
 }
 
+/// A big-endian UTF-16 string as text (unpaired surrogates become U+FFFD).
 fn decode_utf16be(bytes: &[u8]) -> String {
     let (pairs, rest) = bytes.as_chunks::<2>();
     let units = pairs.iter().map(|p| u16::from_be_bytes(*p));
@@ -369,10 +377,12 @@ fn val(v: f64) -> V<'static> {
     V::Float(v)
 }
 
+/// A dictionary value with these keys, for the built-in defaults.
 fn dict(pairs: Vec<(&'static str, V<'static>)>) -> V<'static> {
     V::Dict(pairs.into_iter().map(|(k, v)| (Cow::Borrowed(k), v)).collect())
 }
 
+/// An array of numbers, for the built-in defaults.
 fn numbers(v: &[f64]) -> V<'static> {
     V::Array(v.iter().map(|x| val(*x)).collect())
 }
@@ -774,11 +784,13 @@ pub struct TextBox {
     pub height: f64,
 }
 
+/// The RGBA colour in a style slot (`slot/0/1`), `None` when it is not four numbers.
 fn colour_of(style: &V<'_>, slot: &str) -> Option<[f64; 4]> {
     let c = style.get(slot)?.get("0")?.get("1")?;
     Some([c.at(0)?.as_f64()?, c.at(1)?.as_f64()?, c.at(2)?.as_f64()?, c.at(3)?.as_f64()?])
 }
 
+/// A non-negative integer value as `usize`.
 fn usize_of(v: &V<'_>) -> Option<usize> {
     usize::try_from(v.as_i64()?).ok()
 }
@@ -1203,6 +1215,7 @@ mod oracle {
     }
 
     impl TextValue {
+        /// The canonical text of a key, as the owning parser built it.
         fn key_text(&self) -> String {
             match self {
                 Self::Name(s) | Self::Str(s) | Self::Token(s) => s.clone(),
@@ -1220,29 +1233,35 @@ mod oracle {
         i: usize,
     }
 
+    /// Whitespace between tokens.
     fn is_ws(c: u8) -> bool {
         matches!(c, b' ' | b'\t' | b'\r' | b'\n')
     }
 
+    /// A byte that ends a bare word.
     fn is_delimiter(c: u8) -> bool {
         is_ws(c) || matches!(c, b'/' | b'[' | b']' | b'<' | b'>' | b'(' | b')')
     }
 
     impl Parser<'_> {
+        /// The next byte, `None` at the end.
         fn peek(&self) -> Option<u8> {
             self.b.get(self.i).copied()
         }
 
+        /// Moves past whitespace.
         fn skip_ws(&mut self) {
             while self.peek().is_some_and(is_ws) {
                 self.i = self.i.saturating_add(1);
             }
         }
 
+        /// True when the unread bytes start with `s`.
         fn starts_with(&self, s: &[u8]) -> bool {
             self.b.get(self.i..).is_some_and(|rest| rest.starts_with(s))
         }
 
+        /// The bare word at the position (up to the next delimiter), borrowed from the body.
         fn word(&mut self) -> &[u8] {
             let start = self.i;
             while self.peek().is_some_and(|c| !is_delimiter(c)) {
@@ -1251,6 +1270,7 @@ mod oracle {
             self.b.get(start..self.i).unwrap_or(&[])
         }
 
+        /// The value at the position, `None` when it is malformed or nested deeper than the limit.
         fn parse(&mut self, depth: usize) -> Option<TextValue> {
             self.skip_ws();
             if depth > MAX_DEPTH {
@@ -1332,6 +1352,7 @@ mod oracle {
         }
     }
 
+    /// A big-endian UTF-16 string as text (unpaired surrogates become U+FFFD).
     fn decode_utf16be(bytes: &[u8]) -> String {
         let (pairs, rest) = bytes.as_chunks::<2>();
         let units = pairs.iter().map(|p| u16::from_be_bytes(*p));
@@ -1364,10 +1385,12 @@ mod oracle {
         TextValue::Float(v)
     }
 
+    /// A dictionary value with these keys, for the built-in defaults.
     fn dict(pairs: Vec<(&str, TextValue)>) -> TextValue {
         TextValue::Dict(pairs.into_iter().map(|(k, v)| (k.to_string(), v)).collect())
     }
 
+    /// An array of numbers, for the built-in defaults.
     fn numbers(v: &[f64]) -> TextValue {
         TextValue::Array(v.iter().map(|x| val(*x)).collect())
     }
@@ -1434,6 +1457,7 @@ mod tests {
     use super::*;
     use crate::container::Chunk;
 
+    /// A `LIST` of this type holding `kids`.
     fn list(t: &[u8; 4], kids: Vec<Chunk<'static>>) -> Chunk<'static> {
         Chunk::list(*t, kids)
     }
@@ -1451,6 +1475,7 @@ mod tests {
     struct Rng(u64);
 
     impl Rng {
+        /// The next pseudo-random number (xorshift).
         fn next(&mut self) -> u64 {
             self.0 ^= self.0 << 13;
             self.0 ^= self.0 >> 7;
@@ -1458,11 +1483,13 @@ mod tests {
             self.0
         }
 
+        /// A number below `n` (0 for `n == 0`).
         fn below(&mut self, n: usize) -> usize {
             usize::try_from(self.next() % (n as u64)).unwrap_or(0)
         }
     }
 
+    /// The borrowing parser reads what the owning one read.
     #[test]
     fn the_borrowing_parser_reads_what_the_owning_one_read() {
         // Every key form the owned keys canonicalise (`06`, `+6`, `-0`, `1.0`, `1e2`, strings,
@@ -1515,6 +1542,7 @@ mod tests {
             b")",
         ];
         // A value: mostly well formed, with a random part in its place now and then.
+        /// Appends one generated value to `out`: mostly well formed, now and then a random part.
         fn value(rng: &mut Rng, parts: &[&[u8]], depth: usize, out: &mut Vec<u8>) {
             let pick = |rng: &mut Rng| parts.get(rng.below(parts.len())).copied().unwrap_or_default();
             match rng.below(if depth > 6 { 5 } else { 10 }) {
@@ -1597,6 +1625,7 @@ mod tests {
         }
     }
 
+    /// A realistic document is read in full.
     #[test]
     fn a_realistic_document_is_read_in_full() {
         let doc = TextDocument::parse(DOC).expect("a document");
@@ -1612,6 +1641,7 @@ mod tests {
         assert_eq!(doc.line_orientation, Some(2));
     }
 
+    /// The defaults are the sampled ones and built once.
     #[test]
     fn the_defaults_are_the_sampled_ones_and_built_once() {
         assert_eq!(STYLE_DEFAULTS.clone().into_owned(), oracle::style_defaults());
@@ -1619,6 +1649,7 @@ mod tests {
         assert!(std::ptr::eq(&*STYLE_DEFAULTS, &*STYLE_DEFAULTS));
     }
 
+    /// Names keys and strings are borrowed from the body.
     #[test]
     fn names_keys_and_strings_are_borrowed_from_the_body() {
         let V::Dict(pairs) = parse_dict(b"/a /b /c (\xfe\xff\0x) /d (plain) /e word /f 1.5 /g (\\(esc) 07 1") else { panic!("a dict") };
@@ -1637,6 +1668,7 @@ mod tests {
         assert!(matches!(outer.get(1).map(|p| &p.1), Some(V::Array(a)) if a.len() == 9 && a.capacity() >= a.len()));
     }
 
+    /// Slot checks agree with the owned ones.
     #[test]
     fn slot_checks_agree_with_the_owned_ones() {
         // Slots: defaults, decoded, neutral-listed and unknown ones. Values: each default as
@@ -1710,6 +1742,7 @@ mod tests {
         assert!(listed > 10_000, "{listed} slots listed");
     }
 
+    /// Values compare by their text.
     #[test]
     fn values_compare_by_their_text() {
         // Two names that are not UTF-8 read as the same text with replacement characters, as the
@@ -1721,6 +1754,7 @@ mod tests {
         assert!(is_neutral(&V::Name(b"nil")) && !is_neutral(&V::Token(b"nil")) && is_neutral(&V::Float(0.0)) && !is_neutral(&V::Str(Cow::Borrowed(b""))));
     }
 
+    /// A layers marker list is the one in its root group.
     #[test]
     fn a_layers_marker_list_is_the_one_in_its_root_group() {
         let marked = |tag: u8| list(b"mrst", vec![Chunk::data(*b"test", vec![tag])]);
@@ -1737,6 +1771,7 @@ mod tests {
         assert_eq!(Node::from(&secl).marker_list().and_then(|m| m.child(b"test")).and_then(Node::bytes), Some(&[3u8][..]));
     }
 
+    /// The source text record is found in the text group.
     #[test]
     fn the_source_text_record_is_found_in_the_text_group() {
         let doc = b"/1 << /1 [ << /0 << /0 (\xfe\xff\0H\0\r) /6 << /0 [ << /0 << /0 << /6 << /0 0 /1 50 /53 << /0 << /1 [ 1 1 0 0 ] >> >> >> >> >> /1 2 >> ] >> >> >> ] >>";
diff --git a/crates/aep/src/container/typed.rs b/crates/aep/src/container/typed.rs
index 8cd35aced..7e7bfd0ec 100644
--- a/crates/aep/src/container/typed.rs
+++ b/crates/aep/src/container/typed.rs
@@ -46,6 +46,7 @@ impl<'f, 'a> Project<'f, 'a> {
         Self::of(Root::from(index))
     }
 
+    /// The project view of either tree: its `LIST Fold` and `LIST EfdG`.
     pub(crate) fn of(root: Root<'f, 'a>) -> Option<Self> {
         root.list(b"Fold").map(|fold| Self { fold, effect_defs: root.list(b"EfdG") })
     }
@@ -572,6 +573,7 @@ mod tests {
         assert_eq!(g.names(), ["A", "B", "A"]);
     }
 
+    /// Match name is agrees with comparing the decoded name.
     #[test]
     fn match_name_is_agrees_with_comparing_the_decoded_name() {
         let bodies: [&[u8]; 9] =
diff --git a/crates/aep/src/container/write.rs b/crates/aep/src/container/write.rs
index 35a5b6276..9f401b3d4 100644
--- a/crates/aep/src/container/write.rs
+++ b/crates/aep/src/container/write.rs
@@ -125,6 +125,7 @@ mod tests {
 
     use super::*;
 
+    /// The output is sized once to its exact length.
     #[test]
     fn the_output_is_sized_once_to_its_exact_length() {
         let odd = |n: u8| Chunk::data(*b"cdat", vec![n; usize::from(n)]);
@@ -151,6 +152,7 @@ mod tests {
         }
     }
 
+    /// A tree past the container size fails before serialising.
     #[cfg(target_pointer_width = "64")]
     #[test]
     fn a_tree_past_the_container_size_fails_before_serialising() {
@@ -163,6 +165,7 @@ mod tests {
         assert!(sequence_len(&file.chunks[..4000], 1).is_some_and(|n| u32::try_from(n + 4).is_ok()));
     }
 
+    /// A tree past the depth limit has no size.
     #[test]
     fn a_tree_past_the_depth_limit_has_no_size() {
         let mut deep = Chunk::data(*b"cdat", vec![0]);
diff --git a/crates/aep/src/export/base.rs b/crates/aep/src/export/base.rs
index dfaca7321..05aa15891 100644
--- a/crates/aep/src/export/base.rs
+++ b/crates/aep/src/export/base.rs
@@ -15,6 +15,7 @@ pub(crate) fn bytes(len: usize, fields: &[(usize, &[u8])]) -> Vec<u8> {
     layout(len, fields).finish(|| format!("base::bytes ({len} bytes, fields at {:?})", fields.iter().map(|(at, v)| (*at, v.len())).collect::<Vec<_>>()))
 }
 
+/// The fixed layout of `len` zero bytes with `fields` written at their offsets.
 fn layout(len: usize, fields: &[(usize, &[u8])]) -> Fixed {
     let mut b = Fixed::zeroed(len);
     for (at, v) in fields {
@@ -280,6 +281,7 @@ pub(crate) fn solid_item() -> Chunk<'static> {
 mod tests {
     use super::*;
 
+    /// A field out of range is an error.
     #[test]
     fn a_field_out_of_range_is_an_error() {
         let ok = layout(4, &[(0, &[1]), (3, &[2])]);
diff --git a/crates/aep/src/export/emit.rs b/crates/aep/src/export/emit.rs
index 08ab82904..f7b0ec6b8 100644
--- a/crates/aep/src/export/emit.rs
+++ b/crates/aep/src/export/emit.rs
@@ -6,7 +6,9 @@ use std::collections::HashMap;
 use crate::{AepFile, Chunk};
 use effectcraft_project::{ItemId, LayerId};
 
+use crate::export::keys::fill_key_list;
 use crate::export::plan::{CompPlan, Entry, ItemPlan, KeyPlan, LayerPlan, LayerSrc, ProjectPlan, PropKind, PropPlan, SolidPlan, natural_key};
+use crate::export::synth::{is_tdmn, tdmn_name};
 use crate::export::template::{self, Template};
 use crate::export::tree::{
     R, child_data, data_mut, kids_mut, list_mut, put, put_bits, put_cstr, put_f32, put_f64, put_i32, put_u8, put_u16, put_u32, set_utf8, tpl,
@@ -437,7 +439,7 @@ fn put_used_comps(cx: &Cx<'_>, item: &mut Chunk<'static>, cp: &CompPlan) -> R<()
 fn put_time_remap_max(layr: &mut Chunk<'static>, seconds: f64) -> R<()> {
     let root = list_mut(layr, b"tdgp")?;
     let kids = kids_mut(root)?;
-    let at = kids.iter().position(|c| c.is(b"tdmn") && tdmn_is(c, "ADBE Time Remapping")).ok_or_else(|| tpl("layer without Time Remapping"))?;
+    let at = kids.iter().position(|c| is_tdmn(c, "ADBE Time Remapping")).ok_or_else(|| tpl("layer without Time Remapping"))?;
     let tdbs = kids.get_mut(at + 1).ok_or_else(|| tpl("Time Remapping without a record"))?;
     put_f64(child_data(tdbs, b"tduM")?, 0, seconds)
 }
@@ -452,7 +454,7 @@ fn put_time_remap_max(layr: &mut Chunk<'static>, seconds: f64) -> R<()> {
 fn put_time_remap(cx: &Cx<'_>, layr: &mut Chunk<'static>, remap: &PropPlan) -> R<()> {
     let root = list_mut(layr, b"tdgp")?;
     let kids = kids_mut(root)?;
-    let at = kids.iter().position(|c| c.is(b"tdmn") && tdmn_is(c, "ADBE Time Remapping")).ok_or_else(|| tpl("layer without Time Remapping"))?;
+    let at = kids.iter().position(|c| is_tdmn(c, "ADBE Time Remapping")).ok_or_else(|| tpl("layer without Time Remapping"))?;
     let tdbs = kids.get_mut(at + 1).ok_or_else(|| tpl("Time Remapping without a record"))?;
     put_u32(child_data(tdbs, b"tdsb")?, 0, 1)?;
     {
@@ -490,7 +492,7 @@ fn put_time_remap(cx: &Cx<'_>, layr: &mut Chunk<'static>, remap: &PropPlan) -> R
         for k in &remap.keys {
             ldat.extend(plain_record(1, k, size)?);
         }
-        set_key_list(&mut list, ldat, remap.keys.len(), size)?;
+        fill_key_list(&mut list, ldat, remap.keys.len(), size)?;
         if let Some(slot) = rk.get_mut(cdat_at) {
             *slot = list;
         }
@@ -638,7 +640,7 @@ fn put_masks(cx: &Cx<'_>, layr: &mut Chunk<'static>, lp: &LayerPlan) -> R<()> {
     let parade = crate::export::masks::build_parade(&cx.t.masks, &lp.masks, lp.source_size)?;
     let root = list_mut(layr, b"tdgp")?;
     let kids = kids_mut(root)?;
-    let at = kids.iter().position(|c| c.is(b"tdmn") && tdmn_is(c, "ADBE Transform Group")).ok_or_else(|| tpl("layer without a Transform group"))?;
+    let at = kids.iter().position(|c| is_tdmn(c, "ADBE Transform Group")).ok_or_else(|| tpl("layer without a Transform group"))?;
     kids.splice(at..at, parade);
     Ok(())
 }
@@ -652,7 +654,7 @@ fn put_effects(cx: &mut Cx<'_>, layr: &mut Chunk<'static>, lp: &LayerPlan, layer
     let parade = crate::export::effects::build_parade(&cx.t.effects, &lp.fx, layer_id, layer_ids, lp.source_size, &mut cx.fx_use)?;
     let root = list_mut(layr, b"tdgp")?;
     let kids = kids_mut(root)?;
-    let at = kids.iter().position(|c| c.is(b"tdmn") && tdmn_is(c, "ADBE Transform Group")).ok_or_else(|| tpl("layer without a Transform group"))?;
+    let at = kids.iter().position(|c| is_tdmn(c, "ADBE Transform Group")).ok_or_else(|| tpl("layer without a Transform group"))?;
     kids.splice(at..at, parade);
     Ok(())
 }
@@ -675,19 +677,6 @@ const GROUP_ORDER: [&str; 13] = [
     "ADBE Group End",
 ];
 
-/// The match name of a `tdmn` chunk: its bytes up to the first NUL, not decoded (empty for a chunk
-/// without data). Every name the exporter looks for is ASCII, so comparing bytes is the same as
-/// comparing the Latin-1 text the other exporter modules decode.
-fn tdmn_bytes<'c>(c: &'c Chunk<'_>) -> &'c [u8] {
-    let d = c.bytes().unwrap_or_default();
-    d.split(|b| *b == 0).next().unwrap_or_default()
-}
-
-/// True when `c` has data and names `name`.
-fn tdmn_is(c: &Chunk<'_>, name: &str) -> bool {
-    c.bytes().is_some() && tdmn_bytes(c) == name.as_bytes()
-}
-
 /// Inserts the properties of `lp` into the layer's Transform group, in the order the file uses.
 fn put_properties(cx: &Cx<'_>, layr: &mut Chunk<'static>, lp: &LayerPlan, cp: &CompPlan) -> R<()> {
     if lp.props.is_empty() {
@@ -695,7 +684,7 @@ fn put_properties(cx: &Cx<'_>, layr: &mut Chunk<'static>, lp: &LayerPlan, cp: &C
     }
     let root = list_mut(layr, b"tdgp")?;
     let kids = kids_mut(root)?;
-    let at = kids.iter().position(|c| c.is(b"tdmn") && tdmn_is(c, "ADBE Transform Group")).ok_or_else(|| tpl("layer without a Transform group"))?;
+    let at = kids.iter().position(|c| is_tdmn(c, "ADBE Transform Group")).ok_or_else(|| tpl("layer without a Transform group"))?;
     let group = kids.get_mut(at + 1).ok_or_else(|| tpl("Transform group without a list"))?;
     let gk = kids_mut(group)?;
     // Split the group into its header (up to the first match name) and (tdmn, node) pairs.
@@ -704,7 +693,9 @@ fn put_properties(cx: &Cx<'_>, layr: &mut Chunk<'static>, lp: &LayerPlan, cp: &C
     let mut pairs: Vec<(Vec<u8>, Vec<Chunk<'static>>)> = Vec::new();
     let mut it = std::mem::take(gk).into_iter();
     while let Some(m) = it.next() {
-        let name = tdmn_bytes(&m).to_vec();
+        // The match name as the shared decoder reads it (lossy UTF-8 up to the first NUL). Every
+        // name looked up below is ASCII, so a name matches exactly when its bytes do.
+        let name = tdmn_name(&m).unwrap_or_default().into_bytes();
         if name == b"ADBE Group End" {
             pairs.push((name, vec![m]));
             continue;
@@ -716,7 +707,7 @@ fn put_properties(cx: &Cx<'_>, layr: &mut Chunk<'static>, lp: &LayerPlan, cp: &C
         let name = p.kind.match_name();
         let built = build_prop(cx, p, lp, cp)?;
         let tdmn = pairs.iter().find(|(n, _)| n == name.as_bytes()).and_then(|(_, v)| v.first().cloned()).unwrap_or_else(|| {
-            cx.t.stat.iter().chain(cx.t.keyd.iter()).find(|c| c.is(b"tdmn") && tdmn_is(c, name)).cloned().unwrap_or_else(|| Chunk::data(*b"tdmn", Vec::new()))
+            cx.t.stat.iter().chain(cx.t.keyd.iter()).find(|c| is_tdmn(c, name)).cloned().unwrap_or_else(|| Chunk::data(*b"tdmn", Vec::new()))
         });
         let entry = vec![tdmn, built];
         if let Some(slot) = pairs.iter_mut().find(|(n, _)| n == name.as_bytes()) {
@@ -766,7 +757,7 @@ fn build_prop(cx: &Cx<'_>, p: &PropPlan, lp: &LayerPlan, cp: &CompPlan) -> R<Chu
         for k in &p.keys {
             ldat.extend(key_record(p.kind, k, size)?);
         }
-        set_key_list(list_mut(&mut tdbs, b"list")?, ldat, p.keys.len(), size)?;
+        fill_key_list(list_mut(&mut tdbs, b"list")?, ldat, p.keys.len(), size)?;
     }
     if let Some((text, _)) = &p.expr {
         let kids = kids_mut(&mut tdbs)?;
@@ -776,25 +767,6 @@ fn build_prop(cx: &Cx<'_>, p: &PropPlan, lp: &LayerPlan, cp: &CompPlan) -> R<Chu
     Ok(tdbs)
 }
 
-/// Writes `count` key records of `size` bytes into the key list `list`: the counts into `lhd3`,
-/// the records as its `ldat` (replaced, or added when missing).
-///
-/// The same as `masks::set_key_list`, which takes the property record (`tdbs`) instead of the
-/// list; the time remap fills a list before it is put into its record.
-fn set_key_list(list: &mut Chunk<'static>, records: Vec<u8>, count: usize, size: usize) -> R<()> {
-    let n = u32::try_from(count).map_err(|_| tpl("too many keys"))?;
-    {
-        let lhd3 = child_data(list, b"lhd3")?;
-        crate::export::synth::put_key_counts(lhd3, n, u32::try_from(size).map_err(|_| tpl("record size"))?)?;
-    }
-    let ld = kids_mut(list)?;
-    match ld.iter_mut().find(|c| c.is(b"ldat")) {
-        Some(c) => *c = Chunk::data(*b"ldat", records),
-        None => ld.push(Chunk::data(*b"ldat", records)),
-    }
-    Ok(())
-}
-
 /// One keyframe record (`docs/aep-format.md`, 3.5).
 fn key_record(kind: PropKind, k: &KeyPlan, size: usize) -> R<Vec<u8>> {
     let mut r = vec![0u8; size];
@@ -856,10 +828,12 @@ mod tests {
     use effectcraft_project::{Comp, Expression, ItemKind, LayerSource, Project, Property, Solid, build};
     use effectcraft_time::{FrameRate, TICKS_PER_SECOND, Tick};
 
+    /// Seconds as ticks.
     fn secs(s: f64) -> Tick {
         Tick((s * TICKS_PER_SECOND as f64).round() as i64)
     }
 
+    /// Adds a layer to `comp`, changed by `edit` first.
     fn add_layer(p: &mut Project, comp: ItemId, name: &str, source: LayerSource, edit: impl FnOnce(&mut effectcraft_project::Layer)) {
         let mut c = p.comp(comp).cloned().expect("comp");
         let mut l = build::layer(p, &c, name, source, (640, 360), None);
@@ -871,6 +845,7 @@ mod tests {
         }
     }
 
+    /// Gives the property two keys (0 s and 1.5 s) holding its value.
     fn two_keys(prop: Option<&mut Property>) {
         let prop = prop.expect("property");
         let v = prop.value.clone();
@@ -912,6 +887,7 @@ mod tests {
         p
     }
 
+    /// The export plan of `p`.
     fn plan_of(p: &Project) -> ProjectPlan {
         let mut col = crate::export::report::Collector::default();
         crate::export::plan::plan(p, &mut col)
@@ -973,6 +949,7 @@ mod tests {
     /// The comparator `sort_named` used before its keys were cached: `natural_key` built on every
     /// comparison.
     fn old_sort_named(v: &mut [Sorted]) {
+        /// The natural name order the cached sort keys replaced, as the reference.
         fn natural_cmp(a: &str, b: &str) -> std::cmp::Ordering {
             let (ka, kb) = (natural_key(a), natural_key(b));
             for (x, y) in ka.iter().zip(kb.iter()) {
@@ -1072,10 +1049,11 @@ mod tests {
         assert!(natural_bytes(&worst).len() <= 1_275);
     }
 
-    /// `tdmn_is` and `tdmn_bytes` agree with the Latin-1 decoding they replaced for every name the
-    /// emitter looks up, which holds because those names are ASCII.
+    /// The shared `is_tdmn` / `tdmn_name` the emitter uses agree with the Latin-1 decoding it used
+    /// before for every name it looks up, which holds because those names are ASCII.
     #[test]
     fn match_names_compare_as_the_latin1_decoding_did() {
+        /// The Latin-1 decoding the emitter used before.
         fn old_tdmn_name(c: &Chunk<'_>) -> Option<String> {
             let d = c.bytes()?;
             Some(d.iter().take_while(|b| **b != 0).map(|b| char::from(*b)).collect())
@@ -1096,28 +1074,26 @@ mod tests {
         ]);
         for c in &chunks {
             for n in &wanted {
-                assert_eq!(tdmn_is(c, n), old_tdmn_name(c).as_deref() == Some(*n), "{c:?} {n}");
-            }
-            let old = old_tdmn_name(c).unwrap_or_default();
-            if old.is_ascii() {
-                assert_eq!(tdmn_bytes(c), old.as_bytes());
+                assert_eq!(is_tdmn(c, n), old_tdmn_name(c).as_deref() == Some(*n), "{c:?} {n}");
+                let key = tdmn_name(c).unwrap_or_default().into_bytes();
+                assert_eq!(key == n.as_bytes(), old_tdmn_name(c).as_deref() == Some(*n), "{c:?} {n}");
             }
         }
     }
 
-    /// `set_key_list` writes the counts and replaces the records, or adds them when the list has
-    /// none.
+    /// `fill_key_list`, which the time remap and the Transform keys use, writes the counts and
+    /// replaces the records, or adds them when the list has none.
     #[test]
-    fn set_key_list_writes_counts_and_records() {
+    fn fill_key_list_writes_counts_and_records() {
         let lhd3 = || Chunk::data(*b"lhd3", vec![0; 52]);
         let mut want_lhd3 = vec![0; 52];
         crate::export::synth::put_key_counts(&mut want_lhd3, 3, 48).expect("counts");
         for start in [vec![lhd3(), Chunk::data(*b"ldat", vec![9; 4])], vec![lhd3()]] {
             let mut list = Chunk::list(*b"list", start);
-            set_key_list(&mut list, vec![7; 144], 3, 48).expect("set");
+            fill_key_list(&mut list, vec![7; 144], 3, 48).expect("set");
             assert_eq!(list.children(), &[Chunk::data(*b"lhd3", want_lhd3.clone()), Chunk::data(*b"ldat", vec![7; 144])]);
         }
         let mut no_header = Chunk::list(*b"list", Vec::new());
-        assert!(set_key_list(&mut no_header, Vec::new(), 0, 48).is_err());
+        assert!(fill_key_list(&mut no_header, Vec::new(), 0, 48).is_err());
     }
 }
diff --git a/crates/aep/src/export/fxsynth.rs b/crates/aep/src/export/fxsynth.rs
index cce25b6f2..611ef7310 100644
--- a/crates/aep/src/export/fxsynth.rs
+++ b/crates/aep/src/export/fxsynth.rs
@@ -51,6 +51,7 @@ pub(crate) fn pard(p: &PDef, popup_items: Option<u16>) -> Vec<u8> {
     pard_layout(p, popup_items).finish(|| format!("pard (type {})", p.code))
 }
 
+/// The 148-byte `pard` layout of a parameter definition: type, name and defaults.
 fn pard_layout(p: &PDef, popup_items: Option<u16>) -> Fixed {
     let mut b = Fixed::zeroed(148);
     b.put(12, &u32::from(p.code).to_be_bytes());
diff --git a/crates/aep/src/export/keys.rs b/crates/aep/src/export/keys.rs
index b3cd1158c..a19187418 100644
--- a/crates/aep/src/export/keys.rs
+++ b/crates/aep/src/export/keys.rs
@@ -90,6 +90,7 @@ mod tests {
     use super::*;
     use crate::export::synth::key_list;
 
+    /// Keys are timed sorted merged and reported.
     #[test]
     fn keys_are_timed_sorted_merged_and_reported() {
         use effectcraft_keyframe::Value;
@@ -122,6 +123,7 @@ mod tests {
         assert!(col.finish().losses.is_empty());
     }
 
+    /// A key list is filled and replaces the value.
     #[test]
     fn a_key_list_is_filled_and_replaces_the_value() {
         let mut list = Chunk::list(*b"list", vec![Chunk::data(*b"lhd3", vec![0; 52])]);
@@ -142,6 +144,7 @@ mod tests {
         assert!(set_key_list(&mut Chunk::list(*b"tdbs", Vec::new()), Vec::new(), 0, 48).is_err());
     }
 
+    /// A spatial record holds the point layout.
     #[test]
     fn a_spatial_record_holds_the_point_layout() {
         let k = KeyPlan {
diff --git a/crates/aep/src/export/masks.rs b/crates/aep/src/export/masks.rs
index b46811500..9b235eb28 100644
--- a/crates/aep/src/export/masks.rs
+++ b/crates/aep/src/export/masks.rs
@@ -368,6 +368,7 @@ pub(crate) fn shph() -> Vec<u8> {
     shph_layout().finish(|| "shph".to_string())
 }
 
+/// The 24-byte `shph` layout of a closed path with a unit box.
 fn shph_layout() -> Fixed {
     let mut b = Fixed::zeroed(24);
     b.put(0, &[0xb3, 0xde, 0x02, 0x01]);
@@ -634,6 +635,7 @@ mod tests {
     use super::*;
     use crate::export::synth::is_tdmn;
 
+    /// A closed three-point mask.
     fn mask() -> MaskPlan {
         let shape = ShapePlan { bbox: [0.0, 0.0, 1.0, 1.0], open: false, points: vec![[0.0, 0.0]; 3] };
         MaskPlan {
@@ -649,6 +651,7 @@ mod tests {
         }
     }
 
+    /// An atom without its path is an error.
     #[test]
     fn an_atom_without_its_path_is_an_error() {
         let mut t = MaskProtos::build();
diff --git a/crates/aep/src/export/report.rs b/crates/aep/src/export/report.rs
index 309f564e8..b6094e791 100644
--- a/crates/aep/src/export/report.rs
+++ b/crates/aep/src/export/report.rs
@@ -262,6 +262,7 @@ impl Collector {
 mod tests {
     use super::*;
 
+    /// A report with losses in two categories, as the collector finishes it.
     fn collected() -> ExportReport {
         let mut col = Collector::default();
         col.exported.layers = 2;
@@ -286,6 +287,7 @@ mod tests {
         assert_eq!(back, collected());
     }
 
+    /// The queries read the losses.
     #[test]
     fn the_queries_read_the_losses() {
         let report = collected();
@@ -296,6 +298,7 @@ mod tests {
         assert_eq!((empty.total_losses(), empty.is_lossless(), empty.summary()), (0, true, String::new()));
     }
 
+    /// Details stop at the cap.
     #[test]
     fn details_stop_at_the_cap() {
         let mut col = Collector::default();
diff --git a/crates/aep/src/export/synth.rs b/crates/aep/src/export/synth.rs
index 80678baa3..8af515f24 100644
--- a/crates/aep/src/export/synth.rs
+++ b/crates/aep/src/export/synth.rs
@@ -126,6 +126,7 @@ pub(crate) fn tdb4(spec: &RecSpec, keyed: bool, time_scale: u32) -> Vec<u8> {
     tdb4_layout(spec, keyed, time_scale).finish(|| "tdb4".to_string())
 }
 
+/// The 124-byte `tdb4` property header layout for a record spec.
 fn tdb4_layout(spec: &RecSpec, keyed: bool, time_scale: u32) -> Fixed {
     let mut b = Fixed::zeroed(124);
     b.put(0, &[0xdb, 0x99, 0x00, spec.dims]);
@@ -161,6 +162,7 @@ pub(crate) fn key_list(size: u32, count: u32, records: Vec<u8>) -> Chunk<'static
     Chunk::list(*b"list", vec![Chunk::data(*b"lhd3", lhd3), Chunk::data(*b"ldat", records)])
 }
 
+/// The 52-byte `lhd3` key list header for `count` records of `size` bytes.
 fn key_list_header(size: u32, count: u32) -> Fixed {
     let mut lhd3 = Fixed::zeroed(52);
     lhd3.put(0, &0x00d0_0bee_u32.to_be_bytes());
@@ -229,6 +231,7 @@ mod tests {
         assert_eq!(rec.child(b"cdat").and_then(|c| c.bytes()).map(<[u8]>::len), Some(40));
     }
 
+    /// Every record header fits.
     #[test]
     fn every_record_header_fits() {
         for dims in 0..=u8::MAX {
@@ -246,6 +249,7 @@ mod tests {
         }
     }
 
+    /// A match name reads as the importer reads it.
     #[test]
     fn a_match_name_reads_as_the_importer_reads_it() {
         let m = tdmn("ADBE Group End");
diff --git a/crates/aep/src/export/tree.rs b/crates/aep/src/export/tree.rs
index 9c71a27b8..9b06ddcba 100644
--- a/crates/aep/src/export/tree.rs
+++ b/crates/aep/src/export/tree.rs
@@ -188,6 +188,7 @@ pub(crate) fn set_utf8(c: &mut Chunk<'static>, text: &str) -> R<()> {
 mod tests {
     use super::*;
 
+    /// The writer errors instead of dropping.
     #[test]
     fn the_writer_errors_instead_of_dropping() {
         let mut d = [0u8; 4];
@@ -200,6 +201,7 @@ mod tests {
         assert_eq!(d, [0, 0, 1, 2]);
     }
 
+    /// A cut string keeps a nul and whole characters.
     #[test]
     fn a_cut_string_keeps_a_nul_and_whole_characters() {
         let mut d = [0xffu8; 6];
@@ -219,6 +221,7 @@ mod tests {
         assert_eq!(fixed_layout_errors(), before);
     }
 
+    /// A broken fixed layout writes what fits and is counted.
     #[test]
     fn a_broken_fixed_layout_writes_what_fits_and_is_counted() {
         let before = fixed_layout_errors();
@@ -231,6 +234,7 @@ mod tests {
         assert_eq!(fixed_layout_errors(), before + 1);
     }
 
+    /// A group splits into header and entries.
     #[test]
     fn a_group_splits_into_header_and_entries() {
         use crate::export::synth::{tdmn, tdsn};
diff --git a/crates/aep/src/import.rs b/crates/aep/src/import.rs
index 8662e182c..79e416563 100644
--- a/crates/aep/src/import.rs
+++ b/crates/aep/src/import.rs
@@ -191,12 +191,14 @@ mod tests {
         }
     }
 
+    /// A 40-byte NUL-padded match name.
     fn tdmn(name: &str) -> Chunk<'static> {
         let mut b = name.as_bytes().to_vec();
         b.resize(40, 0);
         Chunk::data(*b"tdmn", b)
     }
 
+    /// A synthetic project imports the same through the index.
     #[test]
     fn a_synthetic_project_imports_the_same_through_the_index() {
         // A composition with a layer whose effect stores arbitrary data and a named value group.
diff --git a/crates/aep/src/import/report.rs b/crates/aep/src/import/report.rs
index c72fb8528..bbf6b2724 100644
--- a/crates/aep/src/import/report.rs
+++ b/crates/aep/src/import/report.rs
@@ -251,6 +251,7 @@ impl AeVersionInfo {
         Self::of_root(Root::from(file))
     }
 
+    /// Reads the versions from the top-level chunks of either tree.
     pub(crate) fn of_root(file: Root<'_, '_>) -> Self {
         let file_version = file.file_version();
         Self {
@@ -342,6 +343,7 @@ pub const LIMITATIONS: &[&str] = &[
 mod tests {
     use super::*;
 
+    /// A report with losses in two categories and a missing file, as the collector finishes it.
     fn collected() -> ImportReport {
         let mut col = Collector::default();
         col.imported.layers = 2;
@@ -366,6 +368,7 @@ mod tests {
         assert_eq!(back, collected());
     }
 
+    /// The queries read the losses.
     #[test]
     fn the_queries_read_the_losses() {
         let report = collected();
diff --git a/crates/aep/tests/it/container/batch3_objects.rs b/crates/aep/tests/it/container/batch3_objects.rs
index ca24d385d..714938312 100644
--- a/crates/aep/tests/it/container/batch3_objects.rs
+++ b/crates/aep/tests/it/container/batch3_objects.rs
@@ -386,6 +386,7 @@ fn the_last_style_run_absorbs_the_final_carriage_return() {
 
 // ------------------------------------------------------------------ camera and light (341-345)
 
+/// Camera zoom keeps the auto position.
 #[test]
 fn camera_zoom_keeps_the_auto_position() {
     // 341: Zoom 2000 is stored (checked on import); the auto Position keeps [0, 0, -2666.67].
diff --git a/crates/aep/tests/it/container/layer_switches.rs b/crates/aep/tests/it/container/layer_switches.rs
index 1f8565752..3d1f764fb 100644
--- a/crates/aep/tests/it/container/layer_switches.rs
+++ b/crates/aep/tests/it/container/layer_switches.rs
@@ -170,6 +170,7 @@ fn cameras_auto_orient_and_position() {
     assert_eq!(pos.stored, [100.0, 200.0, -1000.0]);
 }
 
+/// Lights type and position.
 #[test]
 fn lights_type_and_position() {
     // 254: a spot light (its Intensity 50 is checked on import).
diff --git a/crates/aep/tests/it/container/tree_index.rs b/crates/aep/tests/it/container/tree_index.rs
index e49d641a0..bd36493cd 100644
--- a/crates/aep/tests/it/container/tree_index.rs
+++ b/crates/aep/tests/it/container/tree_index.rs
@@ -74,6 +74,7 @@ fn arbitrary(fx: &Effect<'_, '_>, name: &str, s: &mut String) {
     let _ = writeln!(s, "        {:?} {:?} {:?}", CurvesData::parse(data), MeshData::parse(data), CryptomatteData::parse(data));
 }
 
+/// Appends a group and everything below it to the dump, depth-limited.
 fn tree(group: &PropGroup<'_, '_>, depth: usize, s: &mut String) {
     if depth > 32 {
         return;
@@ -93,6 +94,7 @@ fn tree(group: &PropGroup<'_, '_>, depth: usize, s: &mut String) {
     }
 }
 
+/// The index is the parsed tree and the view reads the same on every file.
 #[test]
 fn the_index_is_the_parsed_tree_and_the_view_reads_the_same_on_every_file() {
     for path in every_file() {
@@ -124,6 +126,7 @@ fn the_index_is_the_parsed_tree_and_the_view_reads_the_same_on_every_file() {
     }
 }
 
+/// The index and the parser fail alike under tight limits.
 #[test]
 fn the_index_and_the_parser_fail_alike_under_tight_limits() {
     for path in every_file().into_iter().filter(|p| p.extension().is_some_and(|x| x == "aep")) {
@@ -155,6 +158,7 @@ fn tdmn(name: &str) -> Chunk<'static> {
     Chunk::data(*b"tdmn", b)
 }
 
+/// A nested chunk `id` holding one `Utf8` with `text`.
 fn utf8(id: [u8; 4], text: &str) -> Chunk<'static> {
     Chunk { id, body: effectcraft_aep::Body::Chunks(vec![Chunk::data(*b"Utf8", text.as_bytes().to_vec())]), pad: None }
 }
@@ -196,6 +200,7 @@ fn synthetic() -> Vec<u8> {
     write(&file).expect("write")
 }
 
+/// The view reads arbitrary effect data the same through the index.
 #[test]
 fn the_view_reads_arbitrary_effect_data_the_same_through_the_index() {
     let bytes = synthetic();
diff --git a/crates/aep/tests/it/export/built.rs b/crates/aep/tests/it/export/built.rs
index dc4c8dc3c..0f9784428 100644
--- a/crates/aep/tests/it/export/built.rs
+++ b/crates/aep/tests/it/export/built.rs
@@ -83,6 +83,7 @@ fn ntsc_and_odd_frame_rates_use_the_time_bases_after_effects_writes() {
     }
 }
 
+/// Every ntsc rate reads back as the rate it was written for.
 #[test]
 fn every_ntsc_rate_reads_back_as_the_rate_it_was_written_for() {
     // The export's time base for each NTSC rate and the import's rate for that time base use the

From 39628a2ba0a5683eb6e310e9c716c19d3ad01b10 Mon Sep 17 00:00:00 2001
From: vangel76 <vangel1976@googlemail.com>
Date: Sun, 8 Nov 2026 18:05:27 +0100
Subject: [PATCH 25/30] #3299: aep: one pard decoder, bounded precomp loop
 search inside a loop

The container's `Pard` is now the only decoder of parameter definitions:
`EffectParam` delegates to it and the export's test reference reads its
encoded table back through it (no big-endian readers of its own). The
export stores a checkbox default as on/off, as the importer reads it.

Inside a strongly connected component of candidate precomp links (a file
with a precomp loop), the per-composition searches share one budget of
link visits; past it, a layer that would need a search is refused and
reported, which never lets a loop in. Below the budget the decisions are
the old ones exactly.
---
 crates/aep/src/container.rs         |   3 +
 crates/aep/src/container/effects.rs | 128 +++++++++++++++++-------
 crates/aep/src/export/effects.rs    |  93 ++++++++---------
 crates/aep/src/import/build.rs      | 150 +++++++++++++++++++++++-----
 4 files changed, 262 insertions(+), 112 deletions(-)

diff --git a/crates/aep/src/container.rs b/crates/aep/src/container.rs
index 5f2e3b2bc..43b1cf627 100644
--- a/crates/aep/src/container.rs
+++ b/crates/aep/src/container.rs
@@ -44,6 +44,9 @@ pub use arbitrary::{
 pub use camera::{CameraPosition, DEFAULT_CAMERA_ZOOM};
 pub use chunk::{AepFile, Body, Chunk, LIST, NESTED_IDS, Walk};
 pub use effects::{DefinitionSource, Effect, EffectDefinitions, EffectParam, LayerRef, ParamKind, ParamValue};
+// The export's tests read their encoded definitions back through the importer's decoder.
+#[cfg(test)]
+pub(crate) use effects::Pard;
 pub use error::AepError;
 pub use footage::{Footage, SequenceInfo};
 pub use header::{BlendMode, CompHeader, LayerHeader, LayerType, LightType, Quality, Rational, Renderer};
diff --git a/crates/aep/src/container/effects.rs b/crates/aep/src/container/effects.rs
index 6ccfa3af6..1ec0933cc 100644
--- a/crates/aep/src/container/effects.rs
+++ b/crates/aep/src/container/effects.rs
@@ -271,8 +271,8 @@ impl<'f, 'a> Effect<'f, 'a> {
                 out.push(EffectParam {
                     index: out.len(),
                     match_name,
-                    kind: ParamKind::from_u32(be_u32(pard, 12).unwrap_or(u32::MAX)),
-                    name: cstr(pard, 16, 32).unwrap_or_default(),
+                    kind: Pard(pard).kind(),
+                    name: Pard(pard).name().unwrap_or_default(),
                     items: None,
                     borrowed_definition: borrowed,
                     pard,
@@ -485,26 +485,7 @@ impl<'f, 'a> EffectParam<'f, 'a> {
     pub fn pard_default(&self) -> Option<ParamValue> {
         match self.kind {
             ParamKind::Popup if self.borrowed_definition => None,
-            ParamKind::FloatSlider => be_f64(self.pard, 56).map(ParamValue::Number),
-            ParamKind::FixedSlider | ParamKind::Angle => be_i32(self.pard, 56).map(|v| ParamValue::Number(f64::from(v) / 65536.0)),
-            ParamKind::IntSlider => be_i32(self.pard, 56).map(|v| ParamValue::Number(f64::from(v))),
-            ParamKind::Checkbox => be_u32(self.pard, 56).map(|v| ParamValue::Bool(v != 0)),
-            ParamKind::Popup => be_u32(self.pard, 56).map(ParamValue::Index),
-            ParamKind::Point => {
-                let p = [f64::from(be_i32(self.pard, 56)?) / 65536.0, f64::from(be_i32(self.pard, 60)?) / 65536.0];
-                // A fresh instance stores fractions of the layer (0.5, 0.5); After Effects' save of
-                // a project it opened stores percent (50, 50: the re-saves of read-back tests e1 and
-                // e2, where Gradient Ramp's Start and End and every other point default came back
-                // as 50 / 0 and 50 / 100). Point
-                // defaults lie inside the layer, so a component beyond 1 tells percent.
-                let percent = p.iter().any(|c| c.abs() > 1.0 + 1e-9);
-                Some(ParamValue::Point(if percent { p.map(|c| c / 100.0) } else { p }))
-            }
-            ParamKind::Color => {
-                let [a, r, g, b] = array::<4>(self.pard, 56)?.map(|c| f64::from(c) / 255.0);
-                Some(ParamValue::Argb([a, r, g, b]))
-            }
-            _ => None,
+            kind => Pard(self.pard).default(kind),
         }
     }
 
@@ -558,22 +539,14 @@ impl<'f, 'a> EffectParam<'f, 'a> {
     /// slider differs per parameter (Amount 37.5 % is stored 37.5, Blend 25 % is stored 0.25), so
     /// this is what tells a reader the scale. `None` for other types.
     pub fn valid_max(&self) -> Option<f64> {
-        match self.kind {
-            ParamKind::FixedSlider => be_i32(self.pard, 128).map(|v| f64::from(v) / 65536.0),
-            ParamKind::FloatSlider => be_f32(self.pard, 108).map(f64::from),
-            ParamKind::IntSlider => be_i32(self.pard, 128).map(f64::from),
-            _ => None,
-        }
+        Pard(self.pard).valid_max(self.kind)
     }
 
     /// The smallest valid value of a float slider, the `f32` at byte 104 of `pard` (Exposure
     /// -100, Offset -2, Gamma Correction 0.1: 389). `None` for other types (a fixed slider's
     /// minimum is not decoded).
     pub fn valid_min(&self) -> Option<f64> {
-        match self.kind {
-            ParamKind::FloatSlider => be_f32(self.pard, 104).map(f64::from),
-            _ => None,
-        }
+        Pard(self.pard).valid_min(self.kind)
     }
 
     /// The range of a float slider's slider (what the control's drag covers, inside the valid
@@ -582,7 +555,7 @@ impl<'f, 'a> EffectParam<'f, 'a> {
     /// for other types.
     pub fn slider_range(&self) -> Option<(f64, f64)> {
         match self.kind {
-            ParamKind::FloatSlider => Some((f64::from(be_f32(self.pard, 112)?), f64::from(be_f32(self.pard, 116)?))),
+            ParamKind::FloatSlider => Pard(self.pard).slider_range(self.kind),
             _ => None,
         }
     }
@@ -592,7 +565,7 @@ impl<'f, 'a> EffectParam<'f, 'a> {
         if self.kind != ParamKind::Popup {
             return None;
         }
-        be_u16(self.pard, 60)
+        Pard(self.pard).popup_item_count()
     }
 
     /// For a popup: the selected item index (1-based): the stored selection, else the default.
@@ -620,6 +593,93 @@ impl<'f, 'a> EffectParam<'f, 'a> {
     }
 }
 
+/// A parameter definition (`pard`, 148 bytes; aep-format.md 3.7): the one decoder of its fields.
+/// The import reads them through [`EffectParam`]; the export writes them from its effect table and
+/// its tests read them back through this.
+#[derive(Clone, Copy, Debug)]
+pub(crate) struct Pard<'f>(pub(crate) &'f [u8]);
+
+impl Pard<'_> {
+    /// The type code, the `u32` at byte 12.
+    pub(crate) fn code(self) -> Option<u32> {
+        be_u32(self.0, 12)
+    }
+
+    /// The parameter type (an unreadable code is [`ParamKind::Other`]).
+    pub(crate) fn kind(self) -> ParamKind {
+        ParamKind::from_u32(self.code().unwrap_or(u32::MAX))
+    }
+
+    /// The parameter name at byte 16 (32 bytes).
+    pub(crate) fn name(self) -> Option<String> {
+        cstr(self.0, 16, 32)
+    }
+
+    /// The default at byte 56 as a parameter of type `kind` reads it (see
+    /// [`EffectParam::pard_default`]).
+    pub(crate) fn default(self, kind: ParamKind) -> Option<ParamValue> {
+        let p = self.0;
+        match kind {
+            ParamKind::FloatSlider => be_f64(p, 56).map(ParamValue::Number),
+            ParamKind::FixedSlider | ParamKind::Angle => be_i32(p, 56).map(|v| ParamValue::Number(f64::from(v) / 65536.0)),
+            ParamKind::IntSlider => be_i32(p, 56).map(|v| ParamValue::Number(f64::from(v))),
+            ParamKind::Checkbox => be_u32(p, 56).map(|v| ParamValue::Bool(v != 0)),
+            ParamKind::Popup => be_u32(p, 56).map(ParamValue::Index),
+            ParamKind::Point => {
+                let pt = [f64::from(be_i32(p, 56)?) / 65536.0, f64::from(be_i32(p, 60)?) / 65536.0];
+                // A fresh instance stores fractions of the layer (0.5, 0.5); After Effects' save of
+                // a project it opened stores percent (50, 50: the re-saves of read-back tests e1 and
+                // e2, where Gradient Ramp's Start and End and every other point default came back
+                // as 50 / 0 and 50 / 100). Point
+                // defaults lie inside the layer, so a component beyond 1 tells percent.
+                let percent = pt.iter().any(|c| c.abs() > 1.0 + 1e-9);
+                Some(ParamValue::Point(if percent { pt.map(|c| c / 100.0) } else { pt }))
+            }
+            ParamKind::Color => {
+                let [a, r, g, b] = array::<4>(p, 56)?.map(|c| f64::from(c) / 255.0);
+                Some(ParamValue::Argb([a, r, g, b]))
+            }
+            _ => None,
+        }
+    }
+
+    /// The valid maximum of a slider (see [`EffectParam::valid_max`]).
+    pub(crate) fn valid_max(self, kind: ParamKind) -> Option<f64> {
+        match kind {
+            ParamKind::FixedSlider => be_i32(self.0, 128).map(|v| f64::from(v) / 65536.0),
+            ParamKind::FloatSlider => be_f32(self.0, 108).map(f64::from),
+            ParamKind::IntSlider => be_i32(self.0, 128).map(f64::from),
+            _ => None,
+        }
+    }
+
+    /// The valid minimum of a float slider (see [`EffectParam::valid_min`]).
+    pub(crate) fn valid_min(self, kind: ParamKind) -> Option<f64> {
+        match kind {
+            ParamKind::FloatSlider => be_f32(self.0, 104).map(f64::from),
+            _ => None,
+        }
+    }
+
+    /// A slider's range, the one its value records repeat as `tdum` / `tduM`: a float slider's
+    /// `f32` pair at 112 / 116, a fixed slider's 16.16 pair and an integer slider's `i32` pair at
+    /// 132 / 136.
+    pub(crate) fn slider_range(self, kind: ParamKind) -> Option<(f64, f64)> {
+        let p = self.0;
+        match kind {
+            ParamKind::FloatSlider => Some((f64::from(be_f32(p, 112)?), f64::from(be_f32(p, 116)?))),
+            ParamKind::FixedSlider => Some((f64::from(be_i32(p, 132)?) / 65536.0, f64::from(be_i32(p, 136)?) / 65536.0)),
+            ParamKind::IntSlider => Some((f64::from(be_i32(p, 132)?), f64::from(be_i32(p, 136)?))),
+            _ => None,
+        }
+    }
+
+    /// A popup's item count, the `u16` at byte 60.
+    pub(crate) fn popup_item_count(self) -> Option<u16> {
+        be_u16(self.0, 60)
+    }
+}
+
 impl<'f, 'a> Layer<'f, 'a> {
     /// The effects on the layer, in stack order (`ADBE Effect Parade`).
     pub fn effects(&self) -> Vec<Effect<'f, 'a>> {
diff --git a/crates/aep/src/export/effects.rs b/crates/aep/src/export/effects.rs
index 1090f59f7..c3a82be52 100644
--- a/crates/aep/src/export/effects.rs
+++ b/crates/aep/src/export/effects.rs
@@ -186,7 +186,8 @@ impl ParDef {
             10 => vec![d(0)],
             2 | 3 => vec![fixed(d(0))],
             1 => vec![int(d(0))],
-            4 => vec![f64::from(d(0).round().max(0.0) as u32)],
+            // On when the stored word is not 0 (as the importer reads it).
+            4 => vec![if d(0).round().max(0.0) as u32 != 0 { 1.0 } else { 0.0 }],
             7 => vec![f64::from(d(0).round().clamp(0.0, f64::from(u16::MAX)) as u32)],
             // Fractions of the layer, or percent after an After Effects re-save (see the reader).
             6 => {
@@ -1113,28 +1114,11 @@ pub(crate) fn put_project_lists(protos: &FxProtos, file: &mut AepFile<'static>,
 mod tests {
     use super::*;
 
-    /// The definitions as they were found before: the prototype's `parT` encoded from the table
-    /// and parsed back (the reference for [`ParDef::from_table`]).
+    /// The definitions as the importer's decoder reads them back from the prototype's `parT`
+    /// encoded from the table (the reference for [`ParDef::from_table`]; one `pard` decoder).
     mod reference {
         use super::super::*;
 
-        fn be_i32(d: &[u8], at: usize) -> Option<i32> {
-            Some(i32::from_be_bytes(d.get(at..at.checked_add(4)?)?.try_into().ok()?))
-        }
-        fn be_u32(d: &[u8], at: usize) -> Option<u32> {
-            Some(u32::from_be_bytes(d.get(at..at.checked_add(4)?)?.try_into().ok()?))
-        }
-        fn be_f32(d: &[u8], at: usize) -> Option<f64> {
-            Some(f64::from(f32::from_be_bytes(d.get(at..at.checked_add(4)?)?.try_into().ok()?)))
-        }
-        fn be_f64(d: &[u8], at: usize) -> Option<f64> {
-            Some(f64::from_be_bytes(d.get(at..at.checked_add(8)?)?.try_into().ok()?))
-        }
-
-        fn cname(d: &[u8]) -> String {
-            d.iter().take_while(|b| **b != 0).map(|b| char::from(*b)).collect()
-        }
-
         /// A definition as the decoder read it, with the name and popup items it also read.
         pub(super) struct Old {
             pub def: ParDef,
@@ -1142,42 +1126,38 @@ mod tests {
             pub items: Vec<String>,
         }
 
-        /// The decoder of an encoded `pard` that `ParDef::from_table` replaces.
+        /// An encoded `pard` as the importer's decoder (`container::Pard`) reads it, in the
+        /// export's stored units: what `ParDef::from_table` must agree with.
         pub(super) fn from_pard(pard: &[u8], pdnm: Option<&str>, data: Option<&[u8]>) -> Old {
-            let code = be_u32(pard, 12).unwrap_or(u32::MAX);
-            let fx = |at: usize| be_i32(pard, at).map(|v| f64::from(v) / 65536.0);
-            let default: Vec<f64> = match code {
-                10 => be_f64(pard, 56).into_iter().collect(),
-                2 | 3 => fx(56).into_iter().collect(),
-                1 => be_i32(pard, 56).map(f64::from).into_iter().collect(),
-                4 | 7 => be_u32(pard, 56).map(f64::from).into_iter().collect(),
-                // Fractions of the layer, or percent after an After Effects re-save (see the reader).
-                6 => {
-                    let p: Vec<f64> = [fx(56), fx(60)].into_iter().flatten().collect();
-                    if p.iter().any(|c| c.abs() > 1.0 + 1e-9) { p.iter().map(|c| c / 100.0).collect() } else { p }
-                }
-                5 => pard.get(56..60).map(|c| c.iter().map(|b| f64::from(*b)).collect()).unwrap_or_default(),
+            use crate::ParamValue as Pv;
+            let d = crate::container::Pard(pard);
+            let kind = d.kind();
+            let default: Vec<f64> = match d.default(kind) {
+                Some(Pv::Number(x)) => vec![x],
+                Some(Pv::Bool(on)) => vec![if on { 1.0 } else { 0.0 }],
+                Some(Pv::Index(i)) => vec![f64::from(i)],
+                Some(Pv::Point(pt)) => pt.to_vec(),
+                // Bytes 0..255, read as fractions.
+                Some(Pv::Argb(c)) => c.iter().map(|x| (x * 255.0).round()).collect(),
+                Some(Pv::Layer(_)) | None => Vec::new(),
+            };
+            let items = match pdnm {
+                Some(text) if kind == crate::ParamKind::Popup && !text.is_empty() => text.split('|').map(str::to_string).collect(),
                 _ => Vec::new(),
             };
-            let range = match code {
-                10 => be_f32(pard, 112).zip(be_f32(pard, 116)),
-                2 => fx(132).zip(fx(136)),
-                1 => be_i32(pard, 132).map(f64::from).zip(be_i32(pard, 136).map(f64::from)),
-                _ => None,
+            let name = match (kind, pdnm) {
+                (crate::ParamKind::Checkbox, Some(text)) if d.name().unwrap_or_default().trim().is_empty() => text.to_string(),
+                _ => d.name().unwrap_or_default(),
             };
-            let valid_max = match code {
-                10 => be_f32(pard, 108),
-                2 => fx(128),
-                1 => be_i32(pard, 128).map(f64::from),
-                _ => None,
+            let def = ParDef {
+                record: String::new(),
+                code: d.code().unwrap_or(u32::MAX),
+                default,
+                range: d.slider_range(kind),
+                valid_max: d.valid_max(kind),
+                data: data.map(<[u8]>::to_vec),
             };
-            let pname = pard.get(16..48).map(cname).unwrap_or_default();
-            let (name, items) = match (code, pdnm) {
-                (7, Some(p)) if !p.is_empty() => (pname, p.split('|').map(str::to_string).collect()),
-                (4, Some(p)) if pname.trim().is_empty() => (p.to_string(), Vec::new()),
-                _ => (pname, Vec::new()),
-            };
-            Old { def: ParDef { record: String::new(), code, default, range, valid_max, data: data.map(<[u8]>::to_vec) }, name, items }
+            Old { def, name, items }
         }
 
         /// The parameter definitions of an instance's `parT`, by position (the table's index).
@@ -1247,7 +1227,16 @@ mod tests {
     #[test]
     fn the_table_definitions_equal_the_encoded_and_parsed_ones() {
         for fx in FX_DEFS {
-            let parsed = reference::par_defs(&crate::export::fxsynth::default_sspc(fx));
+            let sspc = crate::export::fxsynth::default_sspc(fx);
+            // The decoder only tells a checkbox on from off: the table's words are 0 or 1.
+            let part = sspc.child_list(b"parT").map(|p| p.children()).unwrap_or_default();
+            for pard in part.iter().filter(|c| c.is(b"pard")).filter_map(|c| c.bytes()) {
+                if crate::container::Pard(pard).kind() == crate::ParamKind::Checkbox {
+                    let word = pard.get(56..60).map(|b| u32::from_be_bytes([b[0], b[1], b[2], b[3]]));
+                    assert!(matches!(word, Some(0 | 1)), "{}: checkbox word {word:?}", fx.match_name);
+                }
+            }
+            let parsed = reference::par_defs(&sspc);
             assert_same(&parsed, &ParDef::of_effect(fx), fx.match_name);
         }
     }
diff --git a/crates/aep/src/import/build.rs b/crates/aep/src/import/build.rs
index 8d1f640c0..21bfc70d8 100644
--- a/crates/aep/src/import/build.rs
+++ b/crates/aep/src/import/build.rs
@@ -480,7 +480,7 @@ fn build_layers(project: &mut Project, cx: &mut Ctx<'_>, defs: &EffectDefinition
     let mut above: Option<u32> = None;
     // The comps that use this one, directly or through others: a precomp layer of one of them
     // would close a loop. Found once, at the first precomp layer (see `Precomps`).
-    let mut users: Option<HashSet<ItemId>> = None;
+    let mut users = Users::NotSearched;
 
     for layer in comp_view.layers() {
         let Some(h) = layer.header() else {
@@ -548,9 +548,16 @@ fn build_layers(project: &mut Project, cx: &mut Ctx<'_>, defs: &EffectDefinition
                 SourceKind::Solid => (LayerSource::Solid { item: s.item }, (s.width.max(1), s.height.max(1))),
                 SourceKind::Footage => (LayerSource::Footage { item: s.item }, (s.width.max(1), s.height.max(1))),
                 SourceKind::Comp => {
-                    if !cx.precomps.accept(p.id, s.item, &mut users) {
-                        skip(cx, &mut skipped, LossCategory::UnsupportedLayers, "precomposition loop, layer");
-                        continue;
+                    match cx.precomps.accept(p.id, s.item, &mut users) {
+                        Link::Accepted => {}
+                        Link::Loop => {
+                            skip(cx, &mut skipped, LossCategory::UnsupportedLayers, "precomposition loop, layer");
+                            continue;
+                        }
+                        Link::Unchecked => {
+                            skip(cx, &mut skipped, LossCategory::UnsupportedLayers, "precomposition in a loop of compositions too large to check, layer");
+                            continue;
+                        }
                     }
                     (LayerSource::Comp { item: s.item }, (s.width.max(1), s.height.max(1)))
                 }
@@ -777,26 +784,75 @@ pub(crate) fn components(edges: &HashMap<ItemId, HashSet<ItemId>>) -> HashMap<It
 /// `from`'s layers are built the only links added start at `from`, and a path that reaches `from`
 /// never needs one of them. (Before, every precomp layer walked the whole graph, which held one
 /// link per layer.)
-#[derive(Default)]
+///
+/// Which links of a loop are refused depends on the order they come in (the first link that
+/// closes it), so inside a component the answer cannot be computed once for all compositions:
+/// each composition's search covers the links accepted so far, and a component of K compositions
+/// and L links costs up to K x L steps. Those searches share one budget
+/// ([`MAX_LOOP_SEARCH_STEPS`] links visited per import); once it is spent, a precomp layer inside a
+/// loop's component whose search would have to visit a link is refused unchecked (reported),
+/// which never closes a loop; a search that needs no step still decides exactly. Every file of
+/// the corpus has no precomp loop and never searches.
 struct Precomps {
     used_by: HashMap<ItemId, HashSet<ItemId>>,
     component: HashMap<ItemId, usize>,
+    /// Links the searches may still visit.
+    steps_left: usize,
+}
+
+impl Default for Precomps {
+    fn default() -> Self {
+        Precomps { used_by: HashMap::new(), component: HashMap::new(), steps_left: MAX_LOOP_SEARCH_STEPS }
+    }
+}
+
+/// The most links the precomp loop searches of one import visit together (see [`Precomps`]).
+const MAX_LOOP_SEARCH_STEPS: usize = 4_000_000;
+
+/// The comps that use the composition being built, as far as they were needed.
+enum Users {
+    /// Not looked for yet (no layer needed them).
+    NotSearched,
+    Found(HashSet<ItemId>),
+    /// The search budget ran out.
+    OutOfBudget,
+}
+
+/// What becomes of a precomp layer.
+#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash)]
+enum Link {
+    Accepted,
+    /// It would close a loop.
+    Loop,
+    /// Inside a loop's component after the search budget is spent: refused without a check.
+    Unchecked,
 }
 
 impl Precomps {
     /// `candidates`: comp -> the comps its layers could show.
     fn new(candidates: &HashMap<ItemId, HashSet<ItemId>>) -> Self {
-        Precomps { used_by: HashMap::new(), component: components(candidates) }
+        Precomps { component: components(candidates), ..Precomps::default() }
     }
 
-    /// Decides a precomp layer of `to` in `from`: recorded and `true`, or `false` when it closes a
-    /// loop. `users` holds the comps that use `from` once they are needed (one per composition).
-    fn accept(&mut self, from: ItemId, to: ItemId, users: &mut Option<HashSet<ItemId>>) -> bool {
-        let looped = closes_loop(from, to, |to| self.same_component(from, to) && users.get_or_insert_with(|| self.users_of(from)).contains(&to));
-        if !looped {
-            self.used_by.entry(to).or_default().insert(from);
+    /// Decides a precomp layer of `to` in `from`, recording it when it is accepted. `users` holds
+    /// the comps that use `from` once they are needed (one search per composition).
+    fn accept(&mut self, from: ItemId, to: ItemId, users: &mut Users) -> Link {
+        let inside = to != from && self.same_component(from, to);
+        if inside && matches!(users, Users::NotSearched) {
+            *users = self.users_of(from).map_or(Users::OutOfBudget, Users::Found);
         }
-        !looped
+        let found = match users {
+            Users::Found(u) => Some(&*u),
+            Users::NotSearched | Users::OutOfBudget => None,
+        };
+        if inside && found.is_none() {
+            return Link::Unchecked;
+        }
+        if closes_loop(from, to, |to| inside && found.is_some_and(|u| u.contains(&to))) {
+            return Link::Loop;
+        }
+        self.used_by.entry(to).or_default().insert(from);
+        Link::Accepted
     }
 
     /// Whether `a` and `b` are in one component of the candidate graph.
@@ -805,18 +861,19 @@ impl Precomps {
     }
 
     /// The comps of `comp`'s component that use it over accepted links, directly or through
-    /// others (each visited once).
-    fn users_of(&self, comp: ItemId) -> HashSet<ItemId> {
+    /// others (each visited once); `None` when the search budget runs out.
+    fn users_of(&mut self, comp: ItemId) -> Option<HashSet<ItemId>> {
         let mut found = HashSet::new();
         let mut stack = vec![comp];
         while let Some(c) = stack.pop() {
             for u in self.used_by.get(&c).into_iter().flatten() {
+                self.steps_left = self.steps_left.checked_sub(1)?;
                 if self.same_component(*u, comp) && found.insert(*u) {
                     stack.push(*u);
                 }
             }
         }
-        found
+        Some(found)
     }
 }
 
@@ -1124,11 +1181,12 @@ mod tests {
         let (mut uses, mut new) = (HashMap::<ItemId, Vec<ItemId>>::new(), Precomps::new(&candidates));
         let mut refused = 0;
         for (from, tos) in &plan {
-            let mut users: Option<HashSet<ItemId>> = None;
+            let mut users = Users::NotSearched;
             for to in tos {
-                let accepted = new.accept(*from, *to, &mut users);
-                assert_eq!(!accepted, old_would_loop(&uses, *from, *to), "{from:?} -> {to:?}");
-                if accepted {
+                let link = new.accept(*from, *to, &mut users);
+                assert_ne!(link, Link::Unchecked, "the budget is not reached here");
+                assert_eq!(link == Link::Loop, old_would_loop(&uses, *from, *to), "{from:?} -> {to:?}");
+                if link == Link::Accepted {
                     uses.entry(*from).or_default().push(*to);
                 } else {
                     refused += 1;
@@ -1156,11 +1214,11 @@ mod tests {
         let candidates = HashMap::from([(b, HashSet::from([a])), (c, HashSet::from([b]))]);
         let mut p = Precomps::new(&candidates);
         for (from, to) in [(b, a), (c, b)] {
-            let mut users = None;
+            let mut users = Users::NotSearched;
             for _ in 0..200_000 {
-                assert!(p.accept(from, to, &mut users));
+                assert_eq!(p.accept(from, to, &mut users), Link::Accepted);
             }
-            assert!(users.is_none(), "no search");
+            assert!(matches!(users, Users::NotSearched), "no search");
         }
     }
 
@@ -1178,14 +1236,54 @@ mod tests {
         }
         let mut p = Precomps::new(&candidates);
         for from in (0..k).map(top).chain((0..k).map(mid)) {
-            let mut users = None;
+            let mut users = Users::NotSearched;
             for to in candidates.get(&from).into_iter().flatten() {
-                assert!(p.accept(from, *to, &mut users));
+                assert_eq!(p.accept(from, *to, &mut users), Link::Accepted);
             }
-            assert!(users.is_none(), "no search");
+            assert!(matches!(users, Users::NotSearched), "no search");
         }
     }
 
+    #[test]
+    fn a_large_loop_of_compositions_is_checked_within_the_budget() {
+        // 100 000 compositions in one loop (each shows the next, the last the first), built in
+        // order: the users of each one are all the ones before it, so checking every layer
+        // exactly is 5e9 steps. The searches stop at the budget; past it the layers inside the
+        // loop that need a search are refused unchecked (one whose composition has no accepted
+        // user needs none and is still decided exactly). The loop never closes.
+        let n = 100_000u64;
+        let c = |i: u64| ItemId(i);
+        let candidates: HashMap<ItemId, HashSet<ItemId>> = (0..n).map(|i| (c(i), HashSet::from([c((i + 1) % n)]))).collect();
+        let mut p = Precomps::new(&candidates);
+        let mut seen = HashMap::new();
+        for i in 0..n {
+            let link = p.accept(c(i), c((i + 1) % n), &mut Users::NotSearched);
+            *seen.entry(link).or_insert(0usize) += 1;
+        }
+        // Before the budget runs out every link is accepted (none closes the loop yet); after
+        // it, the ones that need a search are refused unchecked; the closing one never gets in.
+        let accepted = seen.get(&Link::Accepted).copied().unwrap_or(0);
+        assert!(accepted > 1000 && accepted < n as usize, "{seen:?}");
+        assert!(seen.get(&Link::Unchecked).copied().unwrap_or(0) > 0, "{seen:?}");
+        assert!(!seen.contains_key(&Link::Loop), "{seen:?}");
+        assert_eq!(accepted + seen.get(&Link::Unchecked).copied().unwrap_or(0), n as usize, "{seen:?}");
+        // The accepted links hold no loop: every component of them is a single composition.
+        let mut forward: HashMap<ItemId, HashSet<ItemId>> = HashMap::new();
+        for (to, froms) in &p.used_by {
+            for from in froms {
+                forward.entry(*from).or_default().insert(*to);
+            }
+        }
+        let parts = components(&forward);
+        assert_eq!(parts.values().collect::<HashSet<_>>().len(), parts.len());
+        // Below the budget the same loop is decided exactly: the closing link is refused.
+        let small: HashMap<ItemId, HashSet<ItemId>> = (0..100).map(|i| (c(i), HashSet::from([c((i + 1) % 100)]))).collect();
+        let mut p = Precomps::new(&small);
+        let links: Vec<Link> = (0..100).map(|i| p.accept(c(i), c((i + 1) % 100), &mut Users::NotSearched)).collect();
+        assert!(links[..99].iter().all(|l| *l == Link::Accepted));
+        assert_eq!(links[99], Link::Loop);
+    }
+
     #[test]
     fn components_are_the_loops() {
         let n = |i: u64| ItemId(i);

From a33fb4abf60ab0cdc3d6db984295ca3ceff3c77a Mon Sep 17 00:00:00 2001
From: vangel76 <vangel1976@googlemail.com>
Date: Sun, 8 Nov 2026 18:19:12 +0100
Subject: [PATCH 26/30] #3300: import .aepx through the flat index

The .aepx reader no longer builds the owned chunk tree element by
element. It decodes every body (hex, text, alias JSON, numbers) into
one buffer and records the chunks as depth-first entries whose bodies
are ranges of that buffer; TreeIndex::from_drafts turns them into the
index the importer reads, which borrows the buffer. read_aepx converts
that index into the owned tree in one pass.

The tree and the errors are those of the previous reader, which the
tests keep as the reference: generated and damaged documents under
seven limit sets, invalid UTF-8, hostile input, the fixture directory,
and imports through both. Bound tests pin the chunk list to the input
and the limit, and check that dropped content leaves nothing behind.
---
 crates/aep/README.md                       |   4 +-
 crates/aep/src/container.rs                |   3 +
 crates/aep/src/container/aepx.rs           | 658 +++++++++++++++++----
 crates/aep/src/container/aepx/reference.rs | 361 +++++++++++
 crates/aep/src/container/index.rs          |  60 +-
 crates/aep/src/import.rs                   |  55 +-
 docs/aep-format.md                         |   5 +
 7 files changed, 1024 insertions(+), 122 deletions(-)
 create mode 100644 crates/aep/src/container/aepx/reference.rs

diff --git a/crates/aep/README.md b/crates/aep/README.md
index 965bea317..db415a026 100644
--- a/crates/aep/README.md
+++ b/crates/aep/README.md
@@ -21,7 +21,9 @@ tree; pad bytes, odd bodies and the bytes after the container, an XMP packet, ar
 
 The XML form of a project (`.aepx`) is read into the same tree by `read_aepx` (a small bounded
 XML tokenizer, no dependency); `parse_any` picks the reader by content, so the typed view and the
-importer take either form. The mapping is in `docs/aep-format.md`, section 1.
+importer take either form. The mapping is in `docs/aep-format.md`, section 1. The importer, which
+only reads, does not build the owned tree: it reads either form through the flat index
+`TreeIndex`, an `.aep` in place and an `.aepx` decoded into one buffer first.
 
 Bodies that look like lists but are not chunk sequences (for example `LIST btdk`, raw text) stay
 opaque rather than failing the parse. Input is untrusted: sizes are checked against the remaining
diff --git a/crates/aep/src/container.rs b/crates/aep/src/container.rs
index 5f2e3b2bc..3701647c4 100644
--- a/crates/aep/src/container.rs
+++ b/crates/aep/src/container.rs
@@ -37,6 +37,9 @@ mod values;
 mod version;
 mod write;
 
+#[cfg(test)]
+pub(crate) use aepx::reference as aepx_reference;
+pub(crate) use aepx::{AepxDrafts, index_aepx};
 pub use aepx::{is_aepx, parse_any, read_aepx, read_aepx_with_limits};
 pub use arbitrary::{
     CURVE_IDENTITY, CryptomatteData, CurvesData, ExtractorChannels, HueSaturationData, LevelsData, MeshData, curve_lut, identifier_channel_type,
diff --git a/crates/aep/src/container/aepx.rs b/crates/aep/src/container/aepx.rs
index 6ca729807..99c969011 100644
--- a/crates/aep/src/container/aepx.rs
+++ b/crates/aep/src/container/aepx.rs
@@ -12,13 +12,24 @@
 //! instructions. A document type declaration is refused (no entity expansion). It runs without
 //! recursion; the nesting depth and the element count are bounded by [`Limits`], and everything
 //! it allocates is bounded by the size of the input.
+//!
+//! It does not build the owned tree element by element. It decodes every body (hex, text, the
+//! alias JSON, the numbers) into one buffer and records the chunks as entries of the flat index
+//! ([`Draft`]s, in depth-first order, bodies as ranges of the buffer). The importer indexes that
+//! buffer ([`TreeIndex::from_drafts`]) and reads it like an `.aep`; [`read_aepx`] converts the
+//! index into the owned tree. The reader this replaced is kept in the tests as the reference
+//! (`aepx/reference.rs`): both give the same tree and the same errors.
 
 use std::borrow::Cow;
 
-use crate::container::chunk::{AepFile, Body, Chunk, LIST, NESTED_IDS};
+use crate::container::chunk::{AepFile, LIST, NESTED_IDS};
 use crate::container::error::AepError;
+use crate::container::index::{Draft, Kind as EntryKind, TreeIndex};
 use crate::container::read::{Limits, parse};
 
+#[cfg(test)]
+pub(crate) mod reference;
+
 /// The root element of an `.aepx`.
 const ROOT: &[u8] = b"AfterEffectsProject";
 /// The element that holds the XMP packet (the trailer of an `.aep`).
@@ -66,19 +77,61 @@ pub fn read_aepx(data: &[u8]) -> Result<AepFile<'static>, AepError> {
 /// element's children are depth 1), `max_chunks` the number of elements.
 ///
 /// # Errors
-/// See [`read_aepx`].
+/// See [`read_aepx`]. Two errors are only reachable when memory runs out, where the reader
+/// before the flat index would abort or could have succeeded: [`AepError::TooLarge`] when the
+/// chunk list cannot grow, and [`AepError::Xml`] "bdata is too large to hold in memory" when the
+/// shared body buffer cannot grow.
 pub fn read_aepx_with_limits(data: &[u8], limits: Limits) -> Result<AepFile<'static>, AepError> {
+    let AepxDrafts { buffer, nodes, trailer } = index_aepx(data, limits)?;
+    Ok(TreeIndex::from_drafts(&buffer, nodes, trailer).to_owned_file())
+}
+
+/// An `.aepx` read for the flat index: every body decoded into one buffer, and the chunks as
+/// [`Draft`]s in depth-first order with their bodies as ranges of that buffer.
+/// [`TreeIndex::from_drafts`] makes the index, which borrows the buffer.
+pub(crate) struct AepxDrafts {
+    /// The decoded bodies (hex, text, alias JSON, numbers) and the XMP packet.
+    pub(crate) buffer: Vec<u8>,
+    pub(crate) nodes: Vec<Draft>,
+    /// The XMP packet: a range of `buffer` (empty without one).
+    pub(crate) trailer: (usize, usize),
+}
+
+/// Reads an `.aepx` into [`AepxDrafts`]: the tree [`read_aepx_with_limits`] gives, with the same
+/// errors, without one allocation per chunk.
+///
+/// # Errors
+/// See [`read_aepx_with_limits`].
+pub(crate) fn index_aepx(data: &[u8], limits: Limits) -> Result<AepxDrafts, AepError> {
     let text = match std::str::from_utf8(data) {
         Ok(t) => t.as_bytes(),
         Err(e) => return Err(xml(e.valid_up_to(), "the file is not valid UTF-8")),
     };
-    Reader { data: text, pos: 0, limits, count: 0, stack: Vec::new(), top: None, trailer: None }.run()
+    // Every counted element takes at least 3 bytes (`<a>` in a document cut short), so there are
+    // never more chunks than this.
+    let bound = (text.len() / 3).min(limits.max_chunks);
+    let mut nodes = Vec::new();
+    let _ = nodes.try_reserve_exact(bound.min(INITIAL_SLOTS));
+    // Hex is most of an `.aepx` and decodes to half its length: one buffer of that size usually
+    // holds everything. A failed reservation is not an error here; the buffer grows as it goes.
+    let mut buffer = Vec::new();
+    let _ = buffer.try_reserve_exact(text.len() / 2);
+    let reader = Reader { data: text, pos: 0, limits, count: 0, stack: Vec::new(), root_closed: false, trailer: None, buffer, nodes, bound, attrs: Vec::new() };
+    reader.run()
 }
 
+/// The slots the chunk list starts with; it doubles from there (as [`TreeIndex`]'s does).
+const INITIAL_SLOTS: usize = 1024;
+
 fn xml(offset: usize, what: &'static str) -> AepError {
     AepError::Xml { offset, what }
 }
 
+/// The pad byte of a body of `len` bytes, as [`crate::container::Chunk::data`] sets it.
+fn pad_of(len: usize) -> Option<u8> {
+    if len % 2 == 1 { Some(0) } else { None }
+}
+
 /// What an open element becomes when it closes.
 #[derive(Debug, Clone, Copy, PartialEq, Eq)]
 enum Kind {
@@ -102,13 +155,14 @@ struct Frame {
     at: usize,
     /// The name as written, to match the end tag.
     name: (usize, usize),
-    /// The decoded `bdata` attribute.
-    bdata: Option<Vec<u8>>,
+    /// The chunk's entry in the list (for `Chunk`, `Utf8` and `Alias`).
+    entry: Option<usize>,
+    /// The buffer length when the element opened: its body starts here.
+    mark: usize,
+    /// The end of the decoded `bdata` attribute in the buffer.
+    bdata_end: Option<usize>,
     /// The attributes of a `fileReference`, in document order.
     attrs: Vec<(String, String)>,
-    /// Collected text (only for `string` and the XMP packet).
-    text: Vec<u8>,
-    children: Vec<Chunk<'static>>,
 }
 
 struct Reader<'d> {
@@ -117,13 +171,19 @@ struct Reader<'d> {
     limits: Limits,
     count: usize,
     stack: Vec<Frame>,
-    /// The top-level chunks once the root element has closed.
-    top: Option<Vec<Chunk<'static>>>,
-    trailer: Option<Vec<u8>>,
+    /// True once the root element has closed.
+    root_closed: bool,
+    trailer: Option<(usize, usize)>,
+    buffer: Vec<u8>,
+    nodes: Vec<Draft>,
+    /// The most chunks the input can hold under the limits: `nodes` never reserves past it.
+    bound: usize,
+    /// The attributes of the current start tag; kept to reuse its allocation.
+    attrs: Vec<((usize, usize), Cow<'d, [u8]>)>,
 }
 
-impl Reader<'_> {
-    fn run(mut self) -> Result<AepFile<'static>, AepError> {
+impl<'d> Reader<'d> {
+    fn run(mut self) -> Result<AepxDrafts, AepError> {
         if self.data.starts_with(&[0xef, 0xbb, 0xbf]) {
             self.pos = 3;
         }
@@ -137,11 +197,13 @@ impl Reader<'_> {
         if let Some(open) = self.stack.last() {
             return Err(xml(open.at, "an element is not closed before the end of the file"));
         }
-        let chunks = self.top.ok_or_else(|| xml(self.data.len(), "no AfterEffectsProject root element"))?;
-        Ok(AepFile { chunks, trailer: Cow::Owned(self.trailer.unwrap_or_default()) })
+        if !self.root_closed {
+            return Err(xml(self.data.len(), "no AfterEffectsProject root element"));
+        }
+        Ok(AepxDrafts { buffer: self.buffer, nodes: self.nodes, trailer: self.trailer.unwrap_or((0, 0)) })
     }
 
-    fn rest(&self) -> &[u8] {
+    fn rest(&self) -> &'d [u8] {
         self.data.get(self.pos..).unwrap_or(&[])
     }
 
@@ -181,14 +243,13 @@ impl Reader<'_> {
             self.pos = start;
             let end = self.skip_past(b"]]>", "a CDATA section is not closed")?;
             let content = self.data.get(start..end).unwrap_or(&[]);
-            let at = start;
-            match self.stack.last_mut() {
+            match self.stack.last() {
                 Some(frame) => {
                     if matches!(frame.kind, Kind::Utf8 | Kind::Xmp) {
-                        frame.text.extend_from_slice(content);
+                        self.buffer.extend_from_slice(content);
                     }
                 }
-                None => return Err(xml(at, "CDATA outside the root element")),
+                None => return Err(xml(start, "CDATA outside the root element")),
             }
         } else if rest.starts_with(b"<!") {
             return Err(xml(self.pos, "document type declarations are not supported"));
@@ -219,25 +280,22 @@ impl Reader<'_> {
         self.pos = self.pos.saturating_add(n);
     }
 
-    fn slice(&self, (a, b): (usize, usize)) -> &[u8] {
+    fn slice(&self, (a, b): (usize, usize)) -> &'d [u8] {
         self.data.get(a..b).unwrap_or(&[])
     }
 
-    fn start_tag(&mut self) -> Result<(), AepError> {
-        let at = self.pos;
-        self.pos = self.pos.saturating_add(1);
-        let name = self.name()?;
-        let mut attrs = Vec::new();
-        let self_closing = loop {
+    /// Reads the attributes of a start tag into `attrs`; true when the tag closes itself.
+    fn attributes(&mut self, at: usize, attrs: &mut Vec<((usize, usize), Cow<'d, [u8]>)>) -> Result<bool, AepError> {
+        loop {
             self.skip_ws();
             let rest = self.rest();
             if rest.starts_with(b"/>") {
                 self.pos = self.pos.saturating_add(2);
-                break true;
+                return Ok(true);
             }
             if rest.starts_with(b">") {
                 self.pos = self.pos.saturating_add(1);
-                break false;
+                return Ok(false);
             }
             if rest.is_empty() {
                 return Err(xml(at, "a start tag is not closed"));
@@ -270,7 +328,16 @@ impl Reader<'_> {
             };
             self.pos = vend.saturating_add(1);
             attrs.push((key, value));
-        };
+        }
+    }
+
+    fn start_tag(&mut self) -> Result<(), AepError> {
+        let at = self.pos;
+        self.pos = self.pos.saturating_add(1);
+        let name = self.name()?;
+        let mut attrs = std::mem::take(&mut self.attrs);
+        attrs.clear();
+        let self_closing = self.attributes(at, &mut attrs)?;
         let kind = self.kind_of(name, at)?;
         if kind != Kind::Root {
             self.count = self.count.saturating_add(1);
@@ -282,14 +349,25 @@ impl Reader<'_> {
                 return Err(AepError::TooDeep);
             }
         }
-        let mut frame = Frame { kind, at, name, bdata: None, attrs: Vec::new(), text: Vec::new(), children: Vec::new() };
-        if matches!(kind, Kind::Chunk(_)) {
-            if let Some((key, value)) = attrs.iter().find(|(k, _)| self.slice(*k) == b"bdata") {
-                frame.bdata = Some(decode_hex(value, key.1)?);
+        let mark = self.buffer.len();
+        let mut frame = Frame { kind, at, name, entry: None, mark, bdata_end: None, attrs: Vec::new() };
+        match kind {
+            Kind::Chunk(id) => {
+                if let Some((key, value)) = attrs.iter().find(|(k, _)| self.slice(*k) == b"bdata") {
+                    decode_hex_into(value, key.1, MAX_BDATA, &mut self.buffer)?;
+                    frame.bdata_end = Some(self.buffer.len());
+                }
+                frame.entry = Some(self.open_entry(id)?);
             }
-        } else if kind == Kind::Alias {
-            frame.attrs = attrs.iter().map(|(k, v)| (String::from_utf8_lossy(self.slice(*k)).into_owned(), String::from_utf8_lossy(v).into_owned())).collect();
+            Kind::Utf8 => frame.entry = Some(self.open_entry(*b"Utf8")?),
+            Kind::Alias => {
+                frame.attrs =
+                    attrs.iter().map(|(k, v)| (String::from_utf8_lossy(self.slice(*k)).into_owned(), String::from_utf8_lossy(v).into_owned())).collect();
+                frame.entry = Some(self.open_entry(*b"alas")?);
+            }
+            Kind::Root | Kind::Xmp | Kind::Skip => {}
         }
+        self.attrs = attrs;
         self.stack.push(frame);
         if self_closing {
             self.close()?;
@@ -297,12 +375,38 @@ impl Reader<'_> {
         Ok(())
     }
 
+    /// Appends the entry of a chunk whose element just opened; its body is filled in when it
+    /// closes. The list grows by its length (at least 16) but never past [`Self::bound`]; an
+    /// allocation the target cannot make is an error, not an abort.
+    fn open_entry(&mut self, id: [u8; 4]) -> Result<usize, AepError> {
+        let at = self.nodes.len();
+        // This entry and the one after it must have `u32` indices.
+        u32::try_from(at.checked_add(1).ok_or(AepError::TooManyChunks)?).map_err(|_| AepError::TooManyChunks)?;
+        if at == self.nodes.capacity() {
+            // Past the bound (which only a wrong guess could reach) it keeps doubling.
+            let room = self.bound.saturating_sub(at);
+            let more = if room == 0 { at.max(16) } else { at.max(16).min(room) };
+            self.nodes.try_reserve_exact(more).map_err(|_| AepError::TooLarge)?;
+        }
+        self.nodes.push(Draft::placeholder(id));
+        Ok(at)
+    }
+
+    /// Fills in the entry at `at` once its element has closed; its subtree is what follows it.
+    fn finish(&mut self, at: usize, id: [u8; 4], kind: EntryKind, list_type: [u8; 4], body: (usize, usize), pad: Option<u8>) -> Result<(), AepError> {
+        let end = u32::try_from(self.nodes.len()).map_err(|_| AepError::TooManyChunks)?;
+        if let Some(d) = self.nodes.get_mut(at) {
+            *d = Draft { start: body.0, len: body.1.saturating_sub(body.0), id, list_type, end, kind, pad };
+        }
+        Ok(())
+    }
+
     /// Classifies an element by its name and where it is.
     fn kind_of(&self, name: (usize, usize), at: usize) -> Result<Kind, AepError> {
         let n = self.slice(name);
         let parent = match self.stack.last() {
             None => {
-                if self.top.is_some() {
+                if self.root_closed {
                     return Err(xml(at, "a second root element"));
                 }
                 if n != ROOT {
@@ -346,39 +450,102 @@ impl Reader<'_> {
         self.close()
     }
 
-    /// Closes the innermost element and hands its chunk to the parent.
+    /// Closes the innermost element and fills in its chunk's entry.
     fn close(&mut self) -> Result<(), AepError> {
         let frame = self.stack.pop().ok_or(xml(self.pos, "an end tag without a start tag"))?;
-        let chunk = match frame.kind {
-            Kind::Root => {
-                self.top = Some(frame.children);
-                return Ok(());
-            }
-            Kind::Skip => return Ok(()),
+        match frame.kind {
+            Kind::Root => self.root_closed = true,
+            Kind::Skip => {}
             Kind::Xmp => {
+                // Only the first packet is kept; a later one is dropped from the buffer (its
+                // children are skipped, so nothing else was written after it opened).
                 if self.trailer.is_none() {
-                    self.trailer = Some(frame.text);
+                    self.trailer = Some((frame.mark, self.buffer.len()));
+                } else {
+                    self.buffer.truncate(frame.mark);
                 }
-                return Ok(());
             }
-            Kind::Utf8 => Chunk::data(*b"Utf8", frame.text),
-            Kind::Alias => Chunk::data(*b"alas", alias_json(&frame.attrs).into_bytes()),
-            Kind::Chunk(id) => chunk_of(id, frame)?,
-        };
-        if let Some(parent) = self.stack.last_mut() {
-            parent.children.push(chunk);
+            Kind::Utf8 => {
+                let at = frame.entry.ok_or(xml(frame.at, "an element lost its chunk"))?;
+                let end = self.buffer.len();
+                self.finish(at, *b"Utf8", EntryKind::Data, [0; 4], (frame.mark, end), pad_of(end.saturating_sub(frame.mark)))?;
+            }
+            Kind::Alias => {
+                let at = frame.entry.ok_or(xml(frame.at, "an element lost its chunk"))?;
+                self.buffer.extend_from_slice(alias_json(&frame.attrs).as_bytes());
+                let end = self.buffer.len();
+                self.finish(at, *b"alas", EntryKind::Data, [0; 4], (frame.mark, end), pad_of(end.saturating_sub(frame.mark)))?;
+            }
+            Kind::Chunk(id) => self.close_chunk(id, &frame)?,
         }
         Ok(())
     }
 
+    /// The chunk of a closed element named by a chunk id (what the owned reader's `chunk_of`
+    /// built): `bdata` wins over children, `numS` / `ppSn` hold their number, a nested id holds its
+    /// children (or nothing), any other name is a `LIST` of that type.
+    fn close_chunk(&mut self, id: [u8; 4], frame: &Frame) -> Result<(), AepError> {
+        let at = frame.entry.ok_or(xml(frame.at, "an element lost its chunk"))?;
+        let after = at.checked_add(1).ok_or(AepError::TooManyChunks)?;
+        if let Some(bdata_end) = frame.bdata_end {
+            // The children were read (and counted, and checked) but are not part of the chunk.
+            self.nodes.truncate(after);
+            self.buffer.truncate(bdata_end);
+            let body = (frame.mark, bdata_end);
+            let pad = pad_of(bdata_end.saturating_sub(frame.mark));
+            if OPAQUE_LIST_TYPES.contains(&id) {
+                return self.finish(at, LIST, EntryKind::OpaqueList, id, body, pad);
+            }
+            return self.finish(at, id, EntryKind::Data, [0; 4], body, pad);
+        }
+        // Numbers written as text: `<numS><string>0</string></numS>` and `<ppSn><string>150.000000000</string></ppSn>`.
+        if &id == b"numS" || &id == b"ppSn" {
+            let missing = || xml(frame.at, "a numS or ppSn element without its number");
+            // Exactly one child chunk, a `Utf8`: the entry after this one, whose subtree runs to the end.
+            let only = self.nodes.get(after).copied().filter(|c| usize::try_from(c.end).ok() == Some(self.nodes.len())).ok_or_else(missing)?;
+            if only.id != *b"Utf8" {
+                return Err(missing());
+            }
+            let text = match only.kind {
+                EntryKind::Data | EntryKind::OpaqueList => only.start.checked_add(only.len).and_then(|end| self.buffer.get(only.start..end)).unwrap_or(&[]),
+                EntryKind::List | EntryKind::Nested => &[],
+            };
+            let text = std::str::from_utf8(text).map_err(|_| xml(frame.at, "a number is not text"))?.trim();
+            let body: [u8; 8];
+            let bytes: &[u8] = if &id == b"numS" {
+                // Only `0` is sampled, so whether the field is signed is open: accept both readings of 4 bytes.
+                let n = text.parse::<i64>().ok().filter(|n| (i64::from(i32::MIN)..=i64::from(u32::MAX)).contains(n));
+                let n = n.ok_or(xml(frame.at, "numS is not a 32-bit integer"))?;
+                body = u64::from(n as u32).to_be_bytes();
+                body.get(4..).unwrap_or(&[])
+            } else {
+                body = text.parse::<f64>().map_err(|_| xml(frame.at, "ppSn is not a number"))?.to_be_bytes();
+                &body
+            };
+            self.nodes.truncate(after);
+            self.buffer.truncate(frame.mark);
+            self.buffer.extend_from_slice(bytes);
+            let end = self.buffer.len();
+            return self.finish(at, id, EntryKind::Data, [0; 4], (frame.mark, end), pad_of(bytes.len()));
+        }
+        let empty = (frame.mark, frame.mark);
+        if NESTED_IDS.contains(&id) {
+            if self.nodes.len() == after {
+                return self.finish(at, id, EntryKind::Data, [0; 4], empty, None);
+            }
+            return self.finish(at, id, EntryKind::Nested, [0; 4], empty, None);
+        }
+        self.finish(at, LIST, EntryKind::List, id, empty, None)
+    }
+
     fn text(&mut self) -> Result<(), AepError> {
         let start = self.pos;
         let len = self.rest().iter().position(|b| *b == b'<').unwrap_or(self.rest().len());
         let end = start.saturating_add(len);
         self.pos = end;
         let raw = self.data.get(start..end).unwrap_or(&[]);
-        match self.stack.last_mut() {
-            Some(frame) if matches!(frame.kind, Kind::Utf8 | Kind::Xmp) => decode_entities(raw, start, &mut frame.text),
+        match self.stack.last() {
+            Some(frame) if matches!(frame.kind, Kind::Utf8 | Kind::Xmp) => decode_entities(raw, start, &mut self.buffer),
             Some(_) => Ok(()),
             None if raw.iter().all(u8::is_ascii_whitespace) => Ok(()),
             None => Err(xml(start, "text outside the root element")),
@@ -399,41 +566,6 @@ fn chunk_id(name: &[u8]) -> Option<[u8; 4]> {
     Some(id)
 }
 
-/// The chunk of a closed element named by a chunk id.
-fn chunk_of(id: [u8; 4], frame: Frame) -> Result<Chunk<'static>, AepError> {
-    if let Some(bytes) = frame.bdata {
-        if OPAQUE_LIST_TYPES.contains(&id) {
-            let pad = if bytes.len() % 2 == 1 { Some(0) } else { None };
-            return Ok(Chunk { id: LIST, body: Body::OpaqueList { list_type: id, data: Cow::Owned(bytes) }, pad });
-        }
-        return Ok(Chunk::data(id, bytes));
-    }
-    // Numbers written as text: `<numS><string>0</string></numS>` and `<ppSn><string>150.000000000</string></ppSn>`.
-    if &id == b"numS" || &id == b"ppSn" {
-        let text = match frame.children.as_slice() {
-            [only] if only.is(b"Utf8") => only.bytes().unwrap_or(&[]),
-            _ => return Err(xml(frame.at, "a numS or ppSn element without its number")),
-        };
-        let text = std::str::from_utf8(text).map_err(|_| xml(frame.at, "a number is not text"))?.trim();
-        let body = if &id == b"numS" {
-            // Only `0` is sampled, so whether the field is signed is open: accept both readings of 4 bytes.
-            let n = text.parse::<i64>().ok().filter(|n| (i64::from(i32::MIN)..=i64::from(u32::MAX)).contains(n));
-            let n = n.ok_or(xml(frame.at, "numS is not a 32-bit integer"))?;
-            (n as u32).to_be_bytes().to_vec()
-        } else {
-            text.parse::<f64>().map_err(|_| xml(frame.at, "ppSn is not a number"))?.to_be_bytes().to_vec()
-        };
-        return Ok(Chunk::data(id, body));
-    }
-    if NESTED_IDS.contains(&id) {
-        if frame.children.is_empty() {
-            return Ok(Chunk::data(id, Vec::new()));
-        }
-        return Ok(Chunk { id, body: Body::Chunks(frame.children), pad: None });
-    }
-    Ok(Chunk::list(id, frame.children))
-}
-
 /// Appends `raw` with the predefined entities and character references decoded.
 fn decode_entities(raw: &[u8], offset: usize, out: &mut Vec<u8>) -> Result<(), AepError> {
     let mut i = 0;
@@ -471,7 +603,8 @@ fn decode_entities(raw: &[u8], offset: usize, out: &mut Vec<u8>) -> Result<(), A
     Ok(())
 }
 
-/// Decodes a `bdata` value (hex digits, two per byte).
+/// Decodes a `bdata` value (hex digits, two per byte) into a new `Vec` of exactly its size.
+#[cfg(test)]
 fn decode_hex(text: &[u8], offset: usize) -> Result<Vec<u8>, AepError> {
     decode_hex_at_most(text, offset, MAX_BDATA)
 }
@@ -481,36 +614,58 @@ fn decode_hex(text: &[u8], offset: usize) -> Result<Vec<u8>, AepError> {
 const MAX_BDATA: usize = u32::MAX as usize;
 
 /// [`decode_hex`] with the decoded-size limit as a parameter (so tests can reach it).
+#[cfg(test)]
 fn decode_hex_at_most(text: &[u8], offset: usize, max: usize) -> Result<Vec<u8>, AepError> {
-    if text.len() % 2 == 1 {
-        return Err(xml(offset, "bdata has an odd number of hex digits"));
-    }
+    // Checked before anything is reserved, then sized once.
+    let pairs = check_hex(text, offset, max)?;
+    let mut out = Vec::new();
+    out.try_reserve_exact(pairs).map_err(|_| xml(offset, "bdata is too large to hold in memory"))?;
+    decode_hex_into(text, offset, max, &mut out)?;
+    Ok(out)
+}
+
+/// Appends the bytes of a `bdata` value (hex digits, two per byte, at most `max` bytes) to `out`.
+/// On an error `out` is unchanged.
+fn decode_hex_into(text: &[u8], offset: usize, max: usize, out: &mut Vec<u8>) -> Result<(), AepError> {
+    let pairs = check_hex(text, offset, max)?;
     let digit = |b: u8| match b {
         b'0'..=b'9' => Some(b - b'0'),
         b'a'..=b'f' => Some(b - b'a' + 10),
         b'A'..=b'F' => Some(b - b'A' + 10),
         _ => None,
     };
-    let (pairs, _) = text.as_chunks::<2>();
-    if pairs.len() > max {
+    // Grown at most once per value (amortised over a shared buffer), and without aborting when the
+    // memory is not there.
+    out.try_reserve(pairs).map_err(|_| xml(offset, "bdata is too large to hold in memory"))?;
+    let mark = out.len();
+    for [hi, lo] in text.as_chunks::<2>().0 {
+        match (digit(*hi), digit(*lo)) {
+            (Some(h), Some(l)) => out.push((h << 4) | l),
+            _ => {
+                out.truncate(mark);
+                return Err(xml(offset, "bdata holds a character that is not a hex digit"));
+            }
+        }
+    }
+    Ok(())
+}
+
+/// Checks a `bdata` value before anything is reserved for it: an even number of hex digits, at
+/// most `max` bytes. Returns the number of bytes it decodes to.
+fn check_hex(text: &[u8], offset: usize, max: usize) -> Result<usize, AepError> {
+    if text.len() % 2 == 1 {
+        return Err(xml(offset, "bdata has an odd number of hex digits"));
+    }
+    let pairs = text.len() / 2;
+    if pairs > max {
         return Err(AepError::TooLarge);
     }
-    // Nothing is reserved for a value that does not decode: one cheap pass checks every digit first.
-    // Blocks without an early exit inside, so the check vectorises; it stops at the first bad block.
+    // One cheap pass checks every digit first. Blocks without an early exit inside, so the check
+    // vectorises; it stops at the first bad block.
     if !text.chunks(4096).all(|block| block.iter().fold(true, |ok, b| ok & b.is_ascii_hexdigit())) {
         return Err(xml(offset, "bdata holds a character that is not a hex digit"));
     }
-    // Sized once (collecting into `Option<Vec>` has no size hint and regrows step by step), and
-    // without aborting when the memory is not there.
-    let mut out = Vec::new();
-    out.try_reserve_exact(pairs.len()).map_err(|_| xml(offset, "bdata is too large to hold in memory"))?;
-    for [hi, lo] in pairs {
-        match (digit(*hi), digit(*lo)) {
-            (Some(h), Some(l)) => out.push((h << 4) | l),
-            _ => return Err(xml(offset, "bdata holds a character that is not a hex digit")),
-        }
-    }
-    Ok(out)
+    Ok(pairs)
 }
 
 /// The JSON body of an `alas` chunk from the attributes of a `fileReference`, keys in document
@@ -753,4 +908,291 @@ mod tests {
         let many = format!("<AfterEffectsProject>{}</AfterEffectsProject>", "<a/>".repeat(10));
         assert_eq!(read_aepx_with_limits(many.as_bytes(), Limits { max_depth: 64, max_chunks: 9 }), Err(AepError::TooManyChunks));
     }
+
+    /// A tiny deterministic generator (xorshift64*), so the tests need no extra crate.
+    struct Rng(u64);
+
+    impl Rng {
+        /// The next pseudo-random number.
+        fn next(&mut self) -> u64 {
+            let mut x = self.0;
+            x ^= x >> 12;
+            x ^= x << 25;
+            x ^= x >> 27;
+            self.0 = x;
+            x.wrapping_mul(0x2545_f491_4f6c_dd1d)
+        }
+
+        /// A number below `n` (0 for `n == 0`).
+        fn below(&mut self, n: usize) -> usize {
+            if n == 0 { 0 } else { usize::try_from(self.next() % n as u64).unwrap() }
+        }
+
+        /// One of `items`.
+        fn pick<'s>(&mut self, items: &[&'s str]) -> &'s str {
+            items[self.below(items.len())]
+        }
+    }
+
+    /// `n` random bytes as hex, upper or lower case.
+    fn hex(rng: &mut Rng, n: usize) -> String {
+        let upper = rng.below(4) == 0;
+        (0..n).map(|_| if upper { format!("{:02X}", rng.below(256)) } else { format!("{:02x}", rng.below(256)) }).collect()
+    }
+
+    /// Random `.aepx` content: every element form the reader knows (data, lists, nested ids,
+    /// strings, numbers, `btdk`, file references, skipped elements, XMP packets), `bdata` next to
+    /// children, bodies that read as chunk sequences, entities, CDATA, comments and stray text.
+    fn content(rng: &mut Rng, depth: usize, budget: &mut usize, out: &mut String) {
+        for _ in 0..rng.below(6) {
+            if *budget == 0 {
+                return;
+            }
+            *budget -= 1;
+            match rng.below(20) {
+                0..=3 => {
+                    let id = rng.pick(&["cdat", "tdmn", "head", "Utf8", "idta", "LIST", "a"]);
+                    let n = rng.below(9);
+                    out.push_str(&format!("<{id} bdata=\"{}\"/>", hex(rng, n)));
+                }
+                4..=6 if depth < 10 => {
+                    let id = rng.pick(&["Fold", "tdgp", "Layr", "Pin", "LIST", "btdk", "sspc"]);
+                    let attr = if rng.below(5) == 0 { format!(" bdata=\"{}\"", hex(rng, 3)) } else { String::new() };
+                    out.push_str(&format!("<{id}{attr}>"));
+                    content(rng, depth + 1, budget, out);
+                    out.push_str(&format!("</{id}>"));
+                }
+                7 => {
+                    let id = rng.pick(&["tdsn", "pdnm", "fnam"]);
+                    match rng.below(4) {
+                        0 => out.push_str(&format!("<{id}/>")),
+                        1 => out.push_str(&format!("<{id}><string>name &amp; &#x41;</string></{id}>")),
+                        // A body that is itself a chunk sequence (`Utf8`, 1 byte, pad): still data.
+                        2 => out.push_str(&format!("<{id} bdata=\"557466380000000161{}\"/>", if rng.below(2) == 0 { "00" } else { "" })),
+                        _ => out.push_str(&format!("<{id}><string>a</string><string>b</string></{id}>")),
+                    }
+                }
+                8 => {
+                    let text = rng.pick(&["plain", "A &lt; B", "<![CDATA[x<y]]>", "a<!-- c -->b", "", "&#233;t&#xE9;", "x<Skip>gone</Skip>y", "\r\n"]);
+                    out.push_str(&format!("<string>{text}</string>"));
+                }
+                9 => {
+                    let id = rng.pick(&["numS", "ppSn"]);
+                    let inner = rng.pick(&[
+                        "<string>0</string>",
+                        "<string> 7 </string>",
+                        "<string>-2147483648</string>",
+                        "<string>150.000000000</string>",
+                        "<string>x</string>",
+                        "",
+                        "<string>1</string><string>2</string>",
+                        "<Utf8 bdata=\"31\"/>",
+                        "<cdat bdata=\"31\"/>",
+                        "<Comment>3</Comment><string>4</string>",
+                    ]);
+                    let attr = if rng.below(6) == 0 { " bdata=\"00000002\"" } else { "" };
+                    out.push_str(&format!("<{id}{attr}>{inner}</{id}>"));
+                }
+                10 => {
+                    let n = rng.pick(&["", "41", "414243", "4c495354000000000000"]);
+                    out.push_str(&format!("<btdk bdata=\"{n}\"/>"));
+                }
+                11 => {
+                    let platform = rng.pick(&["Win", "1", "Mac"]);
+                    out.push_str(&format!(
+                        "<Als2><fileReference ascendcount_base=\"1\" fullpath=\"C:\\a\\&quot;b&#x9;.png\" platform=\"{platform}\" target_is_folder=\"{}\"/></Als2>",
+                        rng.below(3)
+                    ));
+                }
+                12 if depth < 10 => {
+                    out.push_str("<Comment note=\"&amp;\">text<a bdata=\"00\"/>");
+                    content(rng, depth + 1, budget, out);
+                    out.push_str("</Comment>");
+                }
+                13 => {
+                    let packet = rng.pick(&["<![CDATA[<?xpacket begin?>x<?xpacket end?>]]>", "plain &amp; text", ""]);
+                    out.push_str(&format!("<ProjectXMPMetadata>{packet}</ProjectXMPMetadata>"));
+                }
+                14 => out.push_str(rng.pick(&["<!-- comment -->", "<?pi x?>", "\n  ", "stray"])),
+                _ => {
+                    let n = rng.below(5);
+                    out.push_str(&format!("<tdb4 bdata=\"{}\" x='y'></tdb4>", hex(rng, n)));
+                }
+            }
+        }
+    }
+
+    /// The default limits and six tight ones (depth 0, 1 and 3; 0, 7 and 40 chunks).
+    fn limit_sets() -> [Limits; 7] {
+        [
+            Limits { max_depth: 0, max_chunks: 10_000_000 },
+            Limits { max_depth: 64, max_chunks: 0 },
+            Limits::default(),
+            Limits { max_depth: 1, max_chunks: 10_000_000 },
+            Limits { max_depth: 3, max_chunks: 10_000_000 },
+            Limits { max_depth: 64, max_chunks: 7 },
+            Limits { max_depth: 64, max_chunks: 40 },
+        ]
+    }
+
+    /// The reader and the reference give the same `Result` (the tree, or the error), and the index
+    /// of the reader is the index of the reference's tree.
+    fn same(bytes: &[u8], limits: Limits) {
+        let old = reference::read(bytes, limits);
+        let new = read_aepx_with_limits(bytes, limits);
+        assert_eq!(new, old, "{}", String::from_utf8_lossy(bytes));
+        if let Ok(file) = &old {
+            let AepxDrafts { buffer, nodes, trailer } = index_aepx(bytes, limits).unwrap();
+            let index = TreeIndex::from_drafts(&buffer, nodes, trailer);
+            let expected = TreeIndex::from_file(file).unwrap();
+            assert_eq!(index.len(), expected.len());
+            assert_eq!(index.trailer(), expected.trailer());
+            let a: Vec<String> = index.walk().map(|(d, n)| format!("{d} {n:?}")).collect();
+            let b: Vec<String> = expected.walk().map(|(d, n)| format!("{d} {n:?}")).collect();
+            assert_eq!(a, b);
+        }
+    }
+
+    /// The reader gives the reference's tree and errors on generated and damaged documents.
+    #[test]
+    fn the_index_reader_matches_the_reference_on_generated_and_damaged_documents() {
+        let mut rng = Rng(0x9e37_79b9_7f4a_7c15);
+        let noise = b"<>/=\"'&;#x0aZ \n![]-?";
+        for _ in 0..600 {
+            let mut budget = 80;
+            let mut body = String::new();
+            content(&mut rng, 0, &mut budget, &mut body);
+            let x = doc(&body);
+            for l in limit_sets() {
+                same(x.as_bytes(), l);
+            }
+            for _ in 0..4 {
+                let mut bad = x.clone().into_bytes();
+                for _ in 0..1 + rng.below(3) {
+                    let at = rng.below(bad.len());
+                    bad[at] = noise[rng.below(noise.len())];
+                }
+                for l in limit_sets() {
+                    same(&bad, l);
+                }
+            }
+            let cut = rng.below(x.len());
+            same(&x.as_bytes()[..cut], Limits::default());
+            // Bytes that are not UTF-8, and a multi-byte character cut in half.
+            let mut bad = x.clone().into_bytes();
+            let at = rng.below(bad.len());
+            bad.insert(at, 0xff);
+            same(&bad, Limits::default());
+            let open = format!("{}<string>é", x.trim_end().trim_end_matches("</AfterEffectsProject>")).into_bytes();
+            same(&open[..open.len() - 1], Limits::default());
+        }
+    }
+
+    /// The flat chunk list never reserves more slots than the input or the chunk limit allows.
+    #[test]
+    fn the_chunk_list_is_bounded_by_the_input_and_the_limit() {
+        let many = format!("<AfterEffectsProject>{}</AfterEffectsProject>", "<a/>".repeat(10_000));
+        let d = index_aepx(many.as_bytes(), Limits::default()).unwrap();
+        assert_eq!(d.nodes.len(), 10_000);
+        assert!(d.nodes.capacity() <= 2 * 10_000, "{} slots for 10 000 chunks", d.nodes.capacity());
+        // The buffer is reserved once, at half the input, and holds nothing here.
+        assert!(d.buffer.is_empty() && d.buffer.capacity() <= many.len() / 2);
+        // At the limit the list never holds more slots than the limit.
+        let d = index_aepx(many.as_bytes(), Limits { max_depth: 64, max_chunks: 10_000 }).unwrap();
+        assert!(d.nodes.capacity() <= 10_000);
+        let few = format!("<AfterEffectsProject>{}</AfterEffectsProject>", "<a/>".repeat(100));
+        let d = index_aepx(few.as_bytes(), Limits { max_depth: 64, max_chunks: 100 }).unwrap();
+        assert!(d.nodes.capacity() <= 100, "{} slots for at most 100 chunks", d.nodes.capacity());
+        assert_eq!(index_aepx(few.as_bytes(), Limits { max_depth: 64, max_chunks: 99 }).err(), Some(AepError::TooManyChunks));
+        // A tiny input cannot hold more than a third of its bytes in elements.
+        let tiny = doc("<a/>");
+        assert!(index_aepx(tiny.as_bytes(), Limits::default()).unwrap().nodes.capacity() <= tiny.len() / 3);
+    }
+
+    /// What a closed element drops is gone from the buffer and the chunk list, but was counted.
+    #[test]
+    fn dropped_content_leaves_nothing_behind_but_still_counts() {
+        // `bdata` wins over the children: they are read, counted and dropped.
+        let x = doc("<a bdata=\"01\"><b bdata=\"0203\"/><string>xyz</string><tdsn><string>q</string></tdsn></a>");
+        let d = index_aepx(x.as_bytes(), Limits::default()).unwrap();
+        assert_eq!((d.buffer.as_slice(), d.nodes.len()), (&[1u8][..], 1));
+        assert_eq!(index_aepx(x.as_bytes(), Limits { max_depth: 64, max_chunks: 4 }).err(), Some(AepError::TooManyChunks));
+        assert!(index_aepx(x.as_bytes(), Limits { max_depth: 64, max_chunks: 5 }).is_ok());
+        // A child's error is raised although the child would be dropped.
+        assert!(matches!(index_aepx(doc("<a bdata=\"01\"><numS></numS></a>").as_bytes(), Limits::default()), Err(AepError::Xml { .. })));
+        // Only the first XMP packet stays in the buffer.
+        let packets = doc(&"<ProjectXMPMetadata>packet</ProjectXMPMetadata>".repeat(1000));
+        let d = index_aepx(packets.as_bytes(), Limits::default()).unwrap();
+        assert_eq!((d.buffer.as_slice(), d.trailer), (&b"packet"[..], (0, 6)));
+        // A number keeps its 4 or 8 bytes, not its text.
+        let d = index_aepx(doc("<numS><string>   7   </string></numS><ppSn><string>1.5</string></ppSn>").as_bytes(), Limits::default()).unwrap();
+        assert_eq!(d.buffer, [&[0, 0, 0, 7][..], &1.5f64.to_be_bytes()[..]].concat());
+        assert_eq!(d.nodes.len(), 2);
+    }
+
+    /// Bodies keep what the element says they are, even where reading the same bytes as an `.aep`
+    /// would decide otherwise: a nested id whose `bdata` is a chunk sequence stays data, an empty
+    /// `btdk` stays an opaque list, an empty list at the deepest level stays a list.
+    #[test]
+    fn bodies_keep_the_kind_the_element_gives_them() {
+        let x = doc("<tdsn bdata=\"5574663800000001610000\"/><btdk bdata=\"\"/><btdk bdata=\"4c4953540000000474657374\"/>");
+        let AepxDrafts { buffer, nodes, trailer } = index_aepx(x.as_bytes(), Limits::default()).unwrap();
+        let index = TreeIndex::from_drafts(&buffer, nodes, trailer);
+        let top: Vec<_> = index.chunks().collect();
+        assert_eq!(top.len(), 3);
+        assert_eq!(top[0].bytes().map(<[u8]>::len), Some(11));
+        assert!(top[0].children().next().is_none());
+        assert!(top[1].is_opaque_list() && top[1].bytes() == Some(&[][..]));
+        assert!(top[2].is_opaque_list() && top[2].bytes().map(<[u8]>::len) == Some(12));
+        // 64 levels: the innermost (empty) list is a list, not opaque.
+        let deep = format!("<AfterEffectsProject>{}{}</AfterEffectsProject>", "<Fold>".repeat(64), "</Fold>".repeat(64));
+        let AepxDrafts { buffer, nodes, trailer } = index_aepx(deep.as_bytes(), Limits::default()).unwrap();
+        let index = TreeIndex::from_drafts(&buffer, nodes, trailer);
+        assert_eq!(index.walk().map(|(d, _)| d).max(), Some(64));
+        assert!(index.walk().all(|(_, n)| n.is_list(b"Fold") && !n.is_opaque_list()));
+        same(x.as_bytes(), Limits::default());
+        same(deep.as_bytes(), Limits::default());
+    }
+
+    /// Hostile input is refused with the reference's errors, without allocating from what it declares.
+    #[test]
+    fn hostile_input_is_refused_like_the_reference() {
+        let hostile = [
+            format!("<AfterEffectsProject>{}{}</AfterEffectsProject>", "<a>".repeat(100_000), "</a>".repeat(100_000)),
+            format!("<AfterEffectsProject>{}", "<string>".repeat(1000)),
+            doc(&format!("<a bdata=\"{}0\"/>", "00".repeat(100_000))),
+            doc(&format!("<a bdata=\"{}zz\"/>", "00".repeat(100_000))),
+            doc("<numS><string>4294967296</string></numS>"),
+            doc("<ppSn><string>1e400x</string></ppSn>"),
+            doc("<string>&#xD800;</string>"),
+            doc("<string>&#99999999999;</string>"),
+            doc(&format!("<Fold>{}", "<b/>".repeat(1000))),
+            format!("<AfterEffectsProject>{}</AfterEffectsProject><x/>", "<a/>".repeat(10)),
+            "<AfterEffectsProject><a bdata=\"00".to_string(),
+            "<AfterEffectsProject><![CDATA[x".to_string(),
+        ];
+        for x in &hostile {
+            assert!(read_aepx(x.as_bytes()).is_err(), "{}", &x[..x.len().min(80)]);
+            for l in limit_sets() {
+                same(x.as_bytes(), l);
+            }
+        }
+    }
+
+    /// Every `.aepx` of the fixture directory gives the reference's tree (skipped without
+    /// `EFFECTCRAFT_AEP_FIXTURES`).
+    #[test]
+    fn every_fixture_aepx_gives_the_reference_tree() {
+        let Some(dir) = std::env::var_os("EFFECTCRAFT_AEP_FIXTURES").filter(|d| !d.is_empty()) else { return };
+        let Ok(entries) = std::fs::read_dir(dir) else { return };
+        let mut paths: Vec<std::path::PathBuf> =
+            entries.filter_map(Result::ok).map(|e| e.path()).filter(|p| p.extension().is_some_and(|x| x == "aepx")).collect();
+        paths.sort();
+        for path in paths {
+            let bytes = std::fs::read(&path).unwrap();
+            for l in limit_sets() {
+                assert_eq!(read_aepx_with_limits(&bytes, l), reference::read(&bytes, l), "{}", path.display());
+            }
+        }
+    }
 }
diff --git a/crates/aep/src/container/aepx/reference.rs b/crates/aep/src/container/aepx/reference.rs
new file mode 100644
index 000000000..dca6b77c4
--- /dev/null
+++ b/crates/aep/src/container/aepx/reference.rs
@@ -0,0 +1,361 @@
+//! The `.aepx` reader as it was before it fed the flat index: it builds the owned chunk tree
+//! element by element. Kept for the tests only, as the reference the index reader is compared
+//! with (the same tree and the same errors on generated, damaged and corpus input).
+
+use std::borrow::Cow;
+
+use super::{FILE_REFERENCE, OPAQUE_LIST_TYPES, ROOT, STRING, XMP, alias_json, chunk_id, decode_entities, decode_hex, xml};
+use crate::container::chunk::{AepFile, Body, Chunk, LIST, NESTED_IDS};
+use crate::container::error::AepError;
+use crate::container::read::Limits;
+
+/// [`super::read_aepx_with_limits`] as it was.
+pub(crate) fn read(data: &[u8], limits: Limits) -> Result<AepFile<'static>, AepError> {
+    let text = match std::str::from_utf8(data) {
+        Ok(t) => t.as_bytes(),
+        Err(e) => return Err(xml(e.valid_up_to(), "the file is not valid UTF-8")),
+    };
+    Reader { data: text, pos: 0, limits, count: 0, stack: Vec::new(), top: None, trailer: None }.run()
+}
+
+/// What an open element becomes when it closes.
+#[derive(Debug, Clone, Copy, PartialEq, Eq)]
+enum Kind {
+    /// The root element: its children are the top-level chunks.
+    Root,
+    /// A chunk with this id (or a `LIST` with this list type).
+    Chunk([u8; 4]),
+    /// A `Utf8` chunk.
+    Utf8,
+    /// An `alas` chunk built from the attributes.
+    Alias,
+    /// The XMP packet (only directly below the root).
+    Xmp,
+    /// An element without a chunk counterpart (a name that is no chunk id); skipped with its content.
+    Skip,
+}
+
+struct Frame {
+    kind: Kind,
+    /// Offset of the start tag (for errors).
+    at: usize,
+    /// The name as written, to match the end tag.
+    name: (usize, usize),
+    /// The decoded `bdata` attribute.
+    bdata: Option<Vec<u8>>,
+    /// The attributes of a `fileReference`, in document order.
+    attrs: Vec<(String, String)>,
+    /// Collected text (only for `string` and the XMP packet).
+    text: Vec<u8>,
+    children: Vec<Chunk<'static>>,
+}
+
+struct Reader<'d> {
+    data: &'d [u8],
+    pos: usize,
+    limits: Limits,
+    count: usize,
+    stack: Vec<Frame>,
+    /// The top-level chunks once the root element has closed.
+    top: Option<Vec<Chunk<'static>>>,
+    trailer: Option<Vec<u8>>,
+}
+
+impl Reader<'_> {
+    fn run(mut self) -> Result<AepFile<'static>, AepError> {
+        if self.data.starts_with(&[0xef, 0xbb, 0xbf]) {
+            self.pos = 3;
+        }
+        while self.pos < self.data.len() {
+            if self.rest().starts_with(b"<") {
+                self.markup()?;
+            } else {
+                self.text()?;
+            }
+        }
+        if let Some(open) = self.stack.last() {
+            return Err(xml(open.at, "an element is not closed before the end of the file"));
+        }
+        let chunks = self.top.ok_or_else(|| xml(self.data.len(), "no AfterEffectsProject root element"))?;
+        Ok(AepFile { chunks, trailer: Cow::Owned(self.trailer.unwrap_or_default()) })
+    }
+
+    fn rest(&self) -> &[u8] {
+        self.data.get(self.pos..).unwrap_or(&[])
+    }
+
+    /// The offset of `needle` at or after `from`.
+    fn find(&self, from: usize, needle: &[u8]) -> Option<usize> {
+        let hay = self.data.get(from..)?;
+        if needle.is_empty() || hay.len() < needle.len() {
+            return None;
+        }
+        let first = *needle.first()?;
+        let mut i = 0;
+        while let Some(p) = hay.get(i..)?.iter().position(|b| *b == first) {
+            let at = i.checked_add(p)?;
+            if hay.get(at..)?.starts_with(needle) {
+                return from.checked_add(at);
+            }
+            i = at.checked_add(1)?;
+        }
+        None
+    }
+
+    /// Skips to just after `close`, which must follow.
+    fn skip_past(&mut self, close: &[u8], what: &'static str) -> Result<usize, AepError> {
+        let at = self.find(self.pos, close).ok_or(xml(self.pos, what))?;
+        self.pos = at.saturating_add(close.len());
+        Ok(at)
+    }
+
+    fn markup(&mut self) -> Result<(), AepError> {
+        let rest = self.rest();
+        if rest.starts_with(b"<?") {
+            self.skip_past(b"?>", "a processing instruction is not closed")?;
+        } else if rest.starts_with(b"<!--") {
+            self.skip_past(b"-->", "a comment is not closed")?;
+        } else if rest.starts_with(b"<![CDATA[") {
+            let start = self.pos.saturating_add(9);
+            self.pos = start;
+            let end = self.skip_past(b"]]>", "a CDATA section is not closed")?;
+            let content = self.data.get(start..end).unwrap_or(&[]);
+            let at = start;
+            match self.stack.last_mut() {
+                Some(frame) => {
+                    if matches!(frame.kind, Kind::Utf8 | Kind::Xmp) {
+                        frame.text.extend_from_slice(content);
+                    }
+                }
+                None => return Err(xml(at, "CDATA outside the root element")),
+            }
+        } else if rest.starts_with(b"<!") {
+            return Err(xml(self.pos, "document type declarations are not supported"));
+        } else if rest.starts_with(b"</") {
+            self.end_tag()?;
+        } else {
+            self.start_tag()?;
+        }
+        Ok(())
+    }
+
+    fn is_name_byte(b: u8) -> bool {
+        !(b.is_ascii_whitespace() || matches!(b, b'<' | b'>' | b'/' | b'=' | b'"' | b'\'' | b'&'))
+    }
+
+    fn name(&mut self) -> Result<(usize, usize), AepError> {
+        let start = self.pos;
+        let len = self.rest().iter().position(|b| !Self::is_name_byte(*b)).unwrap_or(self.rest().len());
+        if len == 0 {
+            return Err(xml(start, "a tag or attribute has no name"));
+        }
+        self.pos = start.saturating_add(len);
+        Ok((start, self.pos))
+    }
+
+    fn skip_ws(&mut self) {
+        let n = self.rest().iter().position(|b| !b.is_ascii_whitespace()).unwrap_or(self.rest().len());
+        self.pos = self.pos.saturating_add(n);
+    }
+
+    fn slice(&self, (a, b): (usize, usize)) -> &[u8] {
+        self.data.get(a..b).unwrap_or(&[])
+    }
+
+    fn start_tag(&mut self) -> Result<(), AepError> {
+        let at = self.pos;
+        self.pos = self.pos.saturating_add(1);
+        let name = self.name()?;
+        let mut attrs = Vec::new();
+        let self_closing = loop {
+            self.skip_ws();
+            let rest = self.rest();
+            if rest.starts_with(b"/>") {
+                self.pos = self.pos.saturating_add(2);
+                break true;
+            }
+            if rest.starts_with(b">") {
+                self.pos = self.pos.saturating_add(1);
+                break false;
+            }
+            if rest.is_empty() {
+                return Err(xml(at, "a start tag is not closed"));
+            }
+            let key = self.name()?;
+            self.skip_ws();
+            if !self.rest().starts_with(b"=") {
+                return Err(xml(self.pos, "an attribute has no value"));
+            }
+            self.pos = self.pos.saturating_add(1);
+            self.skip_ws();
+            let quote = *self.rest().first().ok_or(xml(self.pos, "a start tag is not closed"))?;
+            if quote != b'"' && quote != b'\'' {
+                return Err(xml(self.pos, "an attribute value is not quoted"));
+            }
+            let vstart = self.pos.saturating_add(1);
+            let vend = self.find(vstart, &[quote]).ok_or(xml(vstart, "an attribute value is not closed"))?;
+            let raw = self.data.get(vstart..vend).unwrap_or(&[]);
+            if raw.contains(&b'<') {
+                return Err(xml(vstart, "`<` inside an attribute value"));
+            }
+            // A value without `&` is its own decoding (most of them, every `bdata` After Effects
+            // writes): borrow it instead of copying it.
+            let value = if raw.contains(&b'&') {
+                let mut value = Vec::new();
+                decode_entities(raw, vstart, &mut value)?;
+                Cow::Owned(value)
+            } else {
+                Cow::Borrowed(raw)
+            };
+            self.pos = vend.saturating_add(1);
+            attrs.push((key, value));
+        };
+        let kind = self.kind_of(name, at)?;
+        if kind != Kind::Root {
+            self.count = self.count.saturating_add(1);
+            if self.count > self.limits.max_chunks {
+                return Err(AepError::TooManyChunks);
+            }
+            // The root's children are depth 1, like the top-level chunks of an `.aep`.
+            if self.stack.len() > self.limits.max_depth {
+                return Err(AepError::TooDeep);
+            }
+        }
+        let mut frame = Frame { kind, at, name, bdata: None, attrs: Vec::new(), text: Vec::new(), children: Vec::new() };
+        if matches!(kind, Kind::Chunk(_)) {
+            if let Some((key, value)) = attrs.iter().find(|(k, _)| self.slice(*k) == b"bdata") {
+                frame.bdata = Some(decode_hex(value, key.1)?);
+            }
+        } else if kind == Kind::Alias {
+            frame.attrs = attrs.iter().map(|(k, v)| (String::from_utf8_lossy(self.slice(*k)).into_owned(), String::from_utf8_lossy(v).into_owned())).collect();
+        }
+        self.stack.push(frame);
+        if self_closing {
+            self.close()?;
+        }
+        Ok(())
+    }
+
+    /// Classifies an element by its name and where it is.
+    fn kind_of(&self, name: (usize, usize), at: usize) -> Result<Kind, AepError> {
+        let n = self.slice(name);
+        let parent = match self.stack.last() {
+            None => {
+                if self.top.is_some() {
+                    return Err(xml(at, "a second root element"));
+                }
+                if n != ROOT {
+                    return Err(xml(at, "the root element is not AfterEffectsProject"));
+                }
+                return Ok(Kind::Root);
+            }
+            Some(p) => p.kind,
+        };
+        Ok(match parent {
+            Kind::Skip | Kind::Utf8 | Kind::Xmp | Kind::Alias => Kind::Skip,
+            Kind::Root | Kind::Chunk(_) => {
+                if n == STRING {
+                    Kind::Utf8
+                } else if n == FILE_REFERENCE {
+                    Kind::Alias
+                } else if n == XMP && parent == Kind::Root {
+                    Kind::Xmp
+                } else if let Some(id) = chunk_id(n) {
+                    Kind::Chunk(id)
+                } else {
+                    Kind::Skip
+                }
+            }
+        })
+    }
+
+    fn end_tag(&mut self) -> Result<(), AepError> {
+        let at = self.pos;
+        self.pos = self.pos.saturating_add(2);
+        let name = self.name()?;
+        self.skip_ws();
+        if !self.rest().starts_with(b">") {
+            return Err(xml(at, "an end tag is not closed"));
+        }
+        self.pos = self.pos.saturating_add(1);
+        let open = self.stack.last().ok_or(xml(at, "an end tag without a start tag"))?;
+        if self.slice(open.name) != self.slice(name) {
+            return Err(xml(at, "an end tag does not match its start tag"));
+        }
+        self.close()
+    }
+
+    /// Closes the innermost element and hands its chunk to the parent.
+    fn close(&mut self) -> Result<(), AepError> {
+        let frame = self.stack.pop().ok_or(xml(self.pos, "an end tag without a start tag"))?;
+        let chunk = match frame.kind {
+            Kind::Root => {
+                self.top = Some(frame.children);
+                return Ok(());
+            }
+            Kind::Skip => return Ok(()),
+            Kind::Xmp => {
+                if self.trailer.is_none() {
+                    self.trailer = Some(frame.text);
+                }
+                return Ok(());
+            }
+            Kind::Utf8 => Chunk::data(*b"Utf8", frame.text),
+            Kind::Alias => Chunk::data(*b"alas", alias_json(&frame.attrs).into_bytes()),
+            Kind::Chunk(id) => chunk_of(id, frame)?,
+        };
+        if let Some(parent) = self.stack.last_mut() {
+            parent.children.push(chunk);
+        }
+        Ok(())
+    }
+
+    fn text(&mut self) -> Result<(), AepError> {
+        let start = self.pos;
+        let len = self.rest().iter().position(|b| *b == b'<').unwrap_or(self.rest().len());
+        let end = start.saturating_add(len);
+        self.pos = end;
+        let raw = self.data.get(start..end).unwrap_or(&[]);
+        match self.stack.last_mut() {
+            Some(frame) if matches!(frame.kind, Kind::Utf8 | Kind::Xmp) => decode_entities(raw, start, &mut frame.text),
+            Some(_) => Ok(()),
+            None if raw.iter().all(u8::is_ascii_whitespace) => Ok(()),
+            None => Err(xml(start, "text outside the root element")),
+        }
+    }
+}
+
+/// The chunk of a closed element named by a chunk id.
+fn chunk_of(id: [u8; 4], frame: Frame) -> Result<Chunk<'static>, AepError> {
+    if let Some(bytes) = frame.bdata {
+        if OPAQUE_LIST_TYPES.contains(&id) {
+            let pad = if bytes.len() % 2 == 1 { Some(0) } else { None };
+            return Ok(Chunk { id: LIST, body: Body::OpaqueList { list_type: id, data: Cow::Owned(bytes) }, pad });
+        }
+        return Ok(Chunk::data(id, bytes));
+    }
+    // Numbers written as text: `<numS><string>0</string></numS>` and `<ppSn><string>150.000000000</string></ppSn>`.
+    if &id == b"numS" || &id == b"ppSn" {
+        let text = match frame.children.as_slice() {
+            [only] if only.is(b"Utf8") => only.bytes().unwrap_or(&[]),
+            _ => return Err(xml(frame.at, "a numS or ppSn element without its number")),
+        };
+        let text = std::str::from_utf8(text).map_err(|_| xml(frame.at, "a number is not text"))?.trim();
+        let body = if &id == b"numS" {
+            // Only `0` is sampled, so whether the field is signed is open: accept both readings of 4 bytes.
+            let n = text.parse::<i64>().ok().filter(|n| (i64::from(i32::MIN)..=i64::from(u32::MAX)).contains(n));
+            let n = n.ok_or(xml(frame.at, "numS is not a 32-bit integer"))?;
+            (n as u32).to_be_bytes().to_vec()
+        } else {
+            text.parse::<f64>().map_err(|_| xml(frame.at, "ppSn is not a number"))?.to_be_bytes().to_vec()
+        };
+        return Ok(Chunk::data(id, body));
+    }
+    if NESTED_IDS.contains(&id) {
+        if frame.children.is_empty() {
+            return Ok(Chunk::data(id, Vec::new()));
+        }
+        return Ok(Chunk { id, body: Body::Chunks(frame.children), pad: None });
+    }
+    Ok(Chunk::list(id, frame.children))
+}
diff --git a/crates/aep/src/container/index.rs b/crates/aep/src/container/index.rs
index 30d7fcb9d..3ae8b97ac 100644
--- a/crates/aep/src/container/index.rs
+++ b/crates/aep/src/container/index.rs
@@ -20,6 +20,10 @@
 //! [`AepError::TooLarge`] when the array cannot grow (a failed `try_reserve`), and
 //! [`AepError::TooManyChunks`] for a tree of more than `u32::MAX` chunks.
 //!
+//! An `.aepx` is indexed by its own reader (`container/aepx.rs`), which decodes every body into
+//! one buffer and fills the entries as it reads; the index then borrows that buffer
+//! (`TreeIndex::from_drafts`). It gives the tree [`crate::container::read_aepx`] gives.
+//!
 //! [`Node`] is the handle the typed view ([`crate::container::Project`] and the types below it)
 //! reads through: a chunk of either tree. The view works the same on both.
 
@@ -33,7 +37,7 @@ use crate::container::read::{Limits, container_end, id4};
 
 /// What an entry's body is (the [`Body`] variants).
 #[derive(Debug, Clone, Copy, PartialEq, Eq)]
-enum Kind {
+pub(crate) enum Kind {
     Data,
     /// [`Body::Chunks`].
     Nested,
@@ -63,6 +67,28 @@ impl<'a> Entry<'a> {
     }
 }
 
+/// An entry of an index whose bytes are still being written (the `.aepx` reader decodes into a
+/// buffer that grows, so it keeps positions, not slices): the body is `start..start + len` of
+/// that buffer. The fields are those of [`Entry`]; [`TreeIndex::from_drafts`] turns the list
+/// into an index once the buffer is final.
+#[derive(Debug, Clone, Copy)]
+pub(crate) struct Draft {
+    pub(crate) start: usize,
+    pub(crate) len: usize,
+    pub(crate) id: [u8; 4],
+    pub(crate) list_type: [u8; 4],
+    pub(crate) end: u32,
+    pub(crate) kind: Kind,
+    pub(crate) pad: Option<u8>,
+}
+
+impl Draft {
+    /// A data chunk with no body yet.
+    pub(crate) fn placeholder(id: [u8; 4]) -> Self {
+        Self { start: 0, len: 0, id, list_type: [0; 4], end: 0, kind: Kind::Data, pad: None }
+    }
+}
+
 /// The chunk tree of a file as one flat, read-only array (see the module documentation).
 #[derive(Clone)]
 pub struct TreeIndex<'a> {
@@ -112,8 +138,19 @@ impl<'a> TreeIndex<'a> {
         Ok(Self { nodes: builder.nodes, trailer })
     }
 
-    /// Indexes an already parsed (or built, or `.aepx`) chunk tree. The index borrows the file's
-    /// bytes.
+    /// The index of the entries `drafts` (in depth-first order, see [`Draft`]) whose bodies and
+    /// trailer are ranges of `buffer`. A range outside `buffer` reads as empty. The list is turned
+    /// into entries; a [`Draft`] and an [`Entry`] have the same size and alignment, so the standard
+    /// library reuses the list's allocation for them.
+    pub(crate) fn from_drafts(buffer: &'a [u8], drafts: Vec<Draft>, trailer: (usize, usize)) -> Self {
+        let slice = |start: usize, len: usize| start.checked_add(len).and_then(|end| buffer.get(start..end)).unwrap_or(&[]);
+        let nodes =
+            drafts.into_iter().map(|d| Entry { data: slice(d.start, d.len), id: d.id, list_type: d.list_type, end: d.end, kind: d.kind, pad: d.pad }).collect();
+        let trailer = buffer.get(trailer.0..trailer.1).unwrap_or(&[]);
+        Self { nodes, trailer }
+    }
+
+    /// Indexes an already parsed (or built) chunk tree. The index borrows the file's bytes.
     ///
     /// # Errors
     /// [`AepError::TooManyChunks`] for a tree of more than `u32::MAX` chunks.
@@ -195,7 +232,14 @@ impl<'a> TreeIndex<'a> {
     /// The owned chunk tree (the bodies stay borrowed from the input): what
     /// [`crate::container::parse`] gives for the same file.
     pub fn to_file(&self) -> AepFile<'a> {
-        AepFile { chunks: self.build(0, u32::try_from(self.nodes.len()).unwrap_or(u32::MAX)), trailer: Cow::Borrowed(self.trailer) }
+        AepFile { chunks: self.build(0, u32::try_from(self.nodes.len()).unwrap_or(u32::MAX), Cow::Borrowed), trailer: Cow::Borrowed(self.trailer) }
+    }
+
+    /// [`Self::to_file`] with every body copied, in one pass without recursion (what
+    /// `to_file().into_owned()` gives, without the borrowed tree in between).
+    pub(crate) fn to_owned_file(&self) -> AepFile<'static> {
+        let owned = |d: &[u8]| Cow::Owned(d.to_vec());
+        AepFile { chunks: self.build(0, u32::try_from(self.nodes.len()).unwrap_or(u32::MAX), owned), trailer: Cow::Owned(self.trailer.to_vec()) }
     }
 
     /// The entry at `at`, `None` past the end.
@@ -210,7 +254,7 @@ impl<'a> TreeIndex<'a> {
 
     /// The owned chunks for the siblings that start at `next` and fill `next..end`, without
     /// recursion.
-    fn build(&self, next: u32, end: u32) -> Vec<Chunk<'a>> {
+    fn build<'o>(&self, next: u32, end: u32, body_of: impl Fn(&'a [u8]) -> Cow<'o, [u8]>) -> Vec<Chunk<'o>> {
         struct Frame<'a> {
             /// The list or nested chunk being filled; `None` for the outermost range.
             at: Option<u32>,
@@ -233,9 +277,9 @@ impl<'a> TreeIndex<'a> {
                         let sub_end = self.end_of(at);
                         stack.push(Frame { at: Some(at), kids: Vec::new(), next: at.saturating_add(1), end: sub_end });
                     }
-                    Kind::Data => top.kids.push(Chunk { id: e.id, body: Body::Data(Cow::Borrowed(e.data)), pad: e.pad }),
+                    Kind::Data => top.kids.push(Chunk { id: e.id, body: Body::Data(body_of(e.data)), pad: e.pad }),
                     Kind::OpaqueList => {
-                        top.kids.push(Chunk { id: e.id, body: Body::OpaqueList { list_type: e.list_type, data: Cow::Borrowed(e.data) }, pad: e.pad });
+                        top.kids.push(Chunk { id: e.id, body: Body::OpaqueList { list_type: e.list_type, data: body_of(e.data) }, pad: e.pad });
                     }
                 }
             } else {
@@ -453,7 +497,7 @@ impl<'f, 'a> Node<'f, 'a> {
     pub fn to_chunk(self) -> Chunk<'a> {
         match self.0 {
             NodeRepr::Chunk(c) => c.clone(),
-            NodeRepr::Index(tree, at) => tree.build(at, tree.end_of(at)).into_iter().next().unwrap_or_else(|| Chunk::data(self.id(), &[][..])),
+            NodeRepr::Index(tree, at) => tree.build(at, tree.end_of(at), Cow::Borrowed).into_iter().next().unwrap_or_else(|| Chunk::data(self.id(), &[][..])),
         }
     }
 
diff --git a/crates/aep/src/import.rs b/crates/aep/src/import.rs
index 140a96e44..f31ee03e5 100644
--- a/crates/aep/src/import.rs
+++ b/crates/aep/src/import.rs
@@ -1,6 +1,6 @@
 //! After Effects project (`.aep`) import: the typed view of [`effectcraft_aep`] mapped into an
-//! EffectCraft [`Project`]. The XML form (`.aepx`) is accepted as well: it is read into the same
-//! chunk tree ([`crate::parse_any`] picks the reader by content).
+//! EffectCraft [`Project`]. The XML form (`.aepx`) is accepted as well: both are read into the same
+//! flat chunk index (an `.aep` in place, an `.aepx` decoded into one buffer first).
 //!
 //! What arrives: the project item tree (folders), project settings (depth, working space, time
 //! display), compositions (size, exact frame rate, duration, work area, background, pixel
@@ -42,6 +42,7 @@ mod time;
 use effectcraft_project::{ItemId, Project, ProjectSettings};
 
 use crate::container::index::{Root, TreeIndex};
+use crate::container::{AepxDrafts, Limits, index_aepx};
 
 pub use effects::supported_effects;
 pub use report::{AeVersionInfo, ImportReport, Imported, LIMITATIONS, Loss, LossCategory, MAX_DETAILS, TESTED_MAJORS, UNKNOWN};
@@ -117,10 +118,11 @@ pub struct ImportResult {
 /// error `project` is unchanged.
 pub fn import(project: &mut Project, bytes: &[u8], options: &ImportOptions<'_>) -> Result<ImportResult, AepImportError> {
     // The importer only reads: an `.aep` is indexed in place (one flat array that borrows the
-    // bytes); an `.aepx` is read into the chunk tree, which the view reads directly.
+    // bytes); an `.aepx` is decoded into one buffer, which the index borrows.
     if crate::is_aepx(bytes) {
-        let file = crate::read_aepx(bytes)?;
-        import_root(project, Root::from(&file), options)
+        let AepxDrafts { buffer, nodes, trailer } = index_aepx(bytes, Limits::default())?;
+        let index = TreeIndex::from_drafts(&buffer, nodes, trailer);
+        import_root(project, Root::from(&index), options)
     } else {
         let index = TreeIndex::parse(bytes)?;
         import_root(project, Root::from(&index), options)
@@ -242,4 +244,47 @@ mod tests {
             both(&bytes, &path.display().to_string());
         }
     }
+
+    /// Imports an `.aepx` through the owned tree of the reader this replaced and through the
+    /// index ([`import`]): the same project, report and settings, or the same error.
+    fn both_aepx(bytes: &[u8], name: &str) -> Result<ImportResult, AepImportError> {
+        let exists = |_: &str| true;
+        let options = ImportOptions { allow_losses: true, ..ImportOptions::new(&exists) };
+        let a = crate::container::aepx_reference::read(bytes, Limits::default())
+            .map_err(AepImportError::from)
+            .and_then(|file| import_root(&mut Project::default(), Root::from(&file), &options));
+        let b = import(&mut Project::default(), bytes, &options);
+        assert!(a == b, "{name}: the .aepx import differs through the index");
+        b
+    }
+
+    /// A synthetic `.aepx` imports the same through the index as through the owned tree.
+    #[test]
+    fn a_synthetic_aepx_imports_the_same_through_the_index() {
+        // The comp of the owned-tree test above (`idta` type 4, `cdta` 1/30 s frame duration).
+        let idta = format!("0004{}", "00".repeat(62));
+        let cdta = format!("00000000000000010000001e{}", "00".repeat(188));
+        let x = format!(
+            "<?xml version=\"1.0\"?><AfterEffectsProject><head bdata=\"{}\"/><Fold><Item><idta bdata=\"{idta}\"/><string>Comp</string><cdta bdata=\"{cdta}\"/></Item></Fold><ProjectXMPMetadata>x</ProjectXMPMetadata></AfterEffectsProject>",
+            "00".repeat(20)
+        );
+        let imported = both_aepx(x.as_bytes(), "synthetic").expect("the synthetic project imports");
+        assert_eq!(imported.comps.len(), 1);
+        assert_eq!(both_aepx(b"<AfterEffectsProject/>", "empty").err(), Some(AepImportError::NoProject));
+        assert!(matches!(both_aepx(b"<AfterEffectsProject><a>", "broken"), Err(AepImportError::Container(crate::AepError::Xml { .. }))));
+    }
+
+    /// Every `.aepx` of the fixture directory (skipped without `EFFECTCRAFT_AEP_FIXTURES`).
+    #[test]
+    fn every_fixture_aepx_imports_the_same_through_the_index() {
+        let Some(dir) = std::env::var_os("EFFECTCRAFT_AEP_FIXTURES").filter(|d| !d.is_empty()) else { return };
+        let Ok(entries) = std::fs::read_dir(dir) else { return };
+        let mut paths: Vec<std::path::PathBuf> =
+            entries.filter_map(Result::ok).map(|e| e.path()).filter(|p| p.extension().is_some_and(|x| x == "aepx")).collect();
+        paths.sort();
+        for path in paths {
+            let bytes = std::fs::read(&path).unwrap_or_else(|e| panic!("{}: {e}", path.display()));
+            let _ = both_aepx(&bytes, &path.display().to_string());
+        }
+    }
 }
diff --git a/docs/aep-format.md b/docs/aep-format.md
index 7f83131a8..a6e7cc730 100644
--- a/docs/aep-format.md
+++ b/docs/aep-format.md
@@ -119,6 +119,11 @@ counterpart (a name that is not 1 to 4 characters) are skipped with their conten
   with the byte offset. It runs without recursion; the nesting depth (`Limits::max_depth`) and the
   element count (`Limits::max_chunks`) are bounded, and everything it allocates is bounded by the
   size of the input.
+- The reader decodes every body (hex, text, the alias JSON, the numbers) into one buffer and records
+  the chunks as a flat depth-first list whose bodies are ranges of that buffer. The importer
+  indexes that buffer (`TreeIndex`) as it indexes an `.aep`; `read_aepx` converts it into the
+  owned tree. The tree is the one the element-by-element reader gave, which the crate's tests keep
+  as the reference.
 - Tests: `tests/aepx.rs` compares the five fixture pairs chunk by chunk and byte by byte, compares
   the typed view of both forms, and runs truncated, bit-flipped, deeply nested and oversized
   inputs; `crates/aep/tests/it/import/aepx.rs` imports both forms of each pair and expects the same

From 6dcaea2ac6ab079542e1f6ca486eb832dd5fe393 Mon Sep 17 00:00:00 2001
From: vangel76 <vangel1976@googlemail.com>
Date: Sun, 8 Nov 2026 18:49:19 +0100
Subject: [PATCH 27/30] #3300: read_aepx keeps its own owned-tree reader

read_aepx, read_aepx_with_limits and parse_any build the owned chunk
tree element by element again, as before the .aepx index, instead of
converting the index (which held the decoded buffer and the owned tree
at the same time). Import keeps the index reader. The tests now
compare the two production readers.
---
 crates/aep/src/container.rs                   |  2 -
 crates/aep/src/container/aepx.rs              | 80 ++++++++++---------
 .../container/aepx/{reference.rs => tree.rs}  | 10 +--
 crates/aep/src/container/index.rs             | 17 ++--
 crates/aep/src/import.rs                      |  8 +-
 docs/aep-format.md                            | 10 +--
 6 files changed, 61 insertions(+), 66 deletions(-)
 rename crates/aep/src/container/aepx/{reference.rs => tree.rs} (97%)

diff --git a/crates/aep/src/container.rs b/crates/aep/src/container.rs
index 3701647c4..35f6f5954 100644
--- a/crates/aep/src/container.rs
+++ b/crates/aep/src/container.rs
@@ -37,8 +37,6 @@ mod values;
 mod version;
 mod write;
 
-#[cfg(test)]
-pub(crate) use aepx::reference as aepx_reference;
 pub(crate) use aepx::{AepxDrafts, index_aepx};
 pub use aepx::{is_aepx, parse_any, read_aepx, read_aepx_with_limits};
 pub use arbitrary::{
diff --git a/crates/aep/src/container/aepx.rs b/crates/aep/src/container/aepx.rs
index 99c969011..c4d2865ff 100644
--- a/crates/aep/src/container/aepx.rs
+++ b/crates/aep/src/container/aepx.rs
@@ -13,22 +13,21 @@
 //! recursion; the nesting depth and the element count are bounded by [`Limits`], and everything
 //! it allocates is bounded by the size of the input.
 //!
-//! It does not build the owned tree element by element. It decodes every body (hex, text, the
-//! alias JSON, the numbers) into one buffer and records the chunks as entries of the flat index
-//! ([`Draft`]s, in depth-first order, bodies as ranges of the buffer). The importer indexes that
-//! buffer ([`TreeIndex::from_drafts`]) and reads it like an `.aep`; [`read_aepx`] converts the
-//! index into the owned tree. The reader this replaced is kept in the tests as the reference
-//! (`aepx/reference.rs`): both give the same tree and the same errors.
+//! There are two readers. [`read_aepx`] builds the owned tree element by element
+//! (`aepx/tree.rs`). The importer, which only reads, uses `index_aepx`: it decodes every body
+//! (hex, text, the alias JSON, the numbers) into one buffer and records the chunks as entries of
+//! the flat index ([`Draft`]s, in depth-first order, bodies as ranges of the buffer), which
+//! [`crate::container::TreeIndex::from_drafts`] turns into an index that borrows the buffer.
+//! The tests hold both to the same tree and the same errors.
 
 use std::borrow::Cow;
 
 use crate::container::chunk::{AepFile, LIST, NESTED_IDS};
 use crate::container::error::AepError;
-use crate::container::index::{Draft, Kind as EntryKind, TreeIndex};
+use crate::container::index::{Draft, Kind as EntryKind};
 use crate::container::read::{Limits, parse};
 
-#[cfg(test)]
-pub(crate) mod reference;
+mod tree;
 
 /// The root element of an `.aepx`.
 const ROOT: &[u8] = b"AfterEffectsProject";
@@ -77,18 +76,14 @@ pub fn read_aepx(data: &[u8]) -> Result<AepFile<'static>, AepError> {
 /// element's children are depth 1), `max_chunks` the number of elements.
 ///
 /// # Errors
-/// See [`read_aepx`]. Two errors are only reachable when memory runs out, where the reader
-/// before the flat index would abort or could have succeeded: [`AepError::TooLarge`] when the
-/// chunk list cannot grow, and [`AepError::Xml`] "bdata is too large to hold in memory" when the
-/// shared body buffer cannot grow.
+/// See [`read_aepx`].
 pub fn read_aepx_with_limits(data: &[u8], limits: Limits) -> Result<AepFile<'static>, AepError> {
-    let AepxDrafts { buffer, nodes, trailer } = index_aepx(data, limits)?;
-    Ok(TreeIndex::from_drafts(&buffer, nodes, trailer).to_owned_file())
+    tree::read(data, limits)
 }
 
 /// An `.aepx` read for the flat index: every body decoded into one buffer, and the chunks as
 /// [`Draft`]s in depth-first order with their bodies as ranges of that buffer.
-/// [`TreeIndex::from_drafts`] makes the index, which borrows the buffer.
+/// [`crate::container::TreeIndex::from_drafts`] makes the index, which borrows the buffer.
 pub(crate) struct AepxDrafts {
     /// The decoded bodies (hex, text, alias JSON, numbers) and the XMP packet.
     pub(crate) buffer: Vec<u8>,
@@ -101,7 +96,10 @@ pub(crate) struct AepxDrafts {
 /// errors, without one allocation per chunk.
 ///
 /// # Errors
-/// See [`read_aepx_with_limits`].
+/// See [`read_aepx_with_limits`]. When memory runs out, two errors come up in more cases than
+/// there: [`AepError::TooLarge`] when the chunk list cannot grow (the owned-tree reader would
+/// abort), and [`AepError::Xml`] "bdata is too large to hold in memory" also when the shared body
+/// buffer cannot grow (the owned-tree reader reserves each value on its own).
 pub(crate) fn index_aepx(data: &[u8], limits: Limits) -> Result<AepxDrafts, AepError> {
     let text = match std::str::from_utf8(data) {
         Ok(t) => t.as_bytes(),
@@ -120,7 +118,8 @@ pub(crate) fn index_aepx(data: &[u8], limits: Limits) -> Result<AepxDrafts, AepE
     reader.run()
 }
 
-/// The slots the chunk list starts with; it doubles from there (as [`TreeIndex`]'s does).
+/// The slots the chunk list starts with; it doubles from there (as the array of
+/// [`crate::container::TreeIndex`] does).
 const INITIAL_SLOTS: usize = 1024;
 
 fn xml(offset: usize, what: &'static str) -> AepError {
@@ -604,7 +603,6 @@ fn decode_entities(raw: &[u8], offset: usize, out: &mut Vec<u8>) -> Result<(), A
 }
 
 /// Decodes a `bdata` value (hex digits, two per byte) into a new `Vec` of exactly its size.
-#[cfg(test)]
 fn decode_hex(text: &[u8], offset: usize) -> Result<Vec<u8>, AepError> {
     decode_hex_at_most(text, offset, MAX_BDATA)
 }
@@ -614,13 +612,13 @@ fn decode_hex(text: &[u8], offset: usize) -> Result<Vec<u8>, AepError> {
 const MAX_BDATA: usize = u32::MAX as usize;
 
 /// [`decode_hex`] with the decoded-size limit as a parameter (so tests can reach it).
-#[cfg(test)]
 fn decode_hex_at_most(text: &[u8], offset: usize, max: usize) -> Result<Vec<u8>, AepError> {
-    // Checked before anything is reserved, then sized once.
+    // Checked before anything is reserved, then sized once (collecting into `Option<Vec>` has no
+    // size hint and regrows step by step), and without aborting when the memory is not there.
     let pairs = check_hex(text, offset, max)?;
     let mut out = Vec::new();
     out.try_reserve_exact(pairs).map_err(|_| xml(offset, "bdata is too large to hold in memory"))?;
-    decode_hex_into(text, offset, max, &mut out)?;
+    decode_checked(text, offset, &mut out)?;
     Ok(out)
 }
 
@@ -628,15 +626,21 @@ fn decode_hex_at_most(text: &[u8], offset: usize, max: usize) -> Result<Vec<u8>,
 /// On an error `out` is unchanged.
 fn decode_hex_into(text: &[u8], offset: usize, max: usize, out: &mut Vec<u8>) -> Result<(), AepError> {
     let pairs = check_hex(text, offset, max)?;
+    // Grown at most once per value (amortised over a shared buffer), and without aborting when the
+    // memory is not there.
+    out.try_reserve(pairs).map_err(|_| xml(offset, "bdata is too large to hold in memory"))?;
+    decode_checked(text, offset, out)
+}
+
+/// Appends the bytes of a `bdata` value that [`check_hex`] accepted. On an error (a digit the
+/// check let through, which it does not) `out` is unchanged.
+fn decode_checked(text: &[u8], offset: usize, out: &mut Vec<u8>) -> Result<(), AepError> {
     let digit = |b: u8| match b {
         b'0'..=b'9' => Some(b - b'0'),
         b'a'..=b'f' => Some(b - b'a' + 10),
         b'A'..=b'F' => Some(b - b'A' + 10),
         _ => None,
     };
-    // Grown at most once per value (amortised over a shared buffer), and without aborting when the
-    // memory is not there.
-    out.try_reserve(pairs).map_err(|_| xml(offset, "bdata is too large to hold in memory"))?;
     let mark = out.len();
     for [hi, lo] in text.as_chunks::<2>().0 {
         match (digit(*hi), digit(*lo)) {
@@ -713,6 +717,7 @@ fn json_str(out: &mut String, s: &str) {
 #[cfg(test)]
 mod tests {
     use super::*;
+    use crate::container::index::TreeIndex;
 
     fn doc(body: &str) -> String {
         format!("<?xml version=\"1.0\" encoding=\"UTF-8\"?>\n<AfterEffectsProject xmlns=\"x\">{body}</AfterEffectsProject>\n")
@@ -1035,11 +1040,11 @@ mod tests {
         ]
     }
 
-    /// The reader and the reference give the same `Result` (the tree, or the error), and the index
-    /// of the reader is the index of the reference's tree.
+    /// The index reader and the owned-tree reader give the same `Result` (the tree, or the error),
+    /// and the index walks like the index of the owned tree.
     fn same(bytes: &[u8], limits: Limits) {
-        let old = reference::read(bytes, limits);
-        let new = read_aepx_with_limits(bytes, limits);
+        let old = read_aepx_with_limits(bytes, limits);
+        let new = index_aepx(bytes, limits).map(|d| TreeIndex::from_drafts(&d.buffer, d.nodes, d.trailer).to_file().into_owned());
         assert_eq!(new, old, "{}", String::from_utf8_lossy(bytes));
         if let Ok(file) = &old {
             let AepxDrafts { buffer, nodes, trailer } = index_aepx(bytes, limits).unwrap();
@@ -1053,9 +1058,9 @@ mod tests {
         }
     }
 
-    /// The reader gives the reference's tree and errors on generated and damaged documents.
+    /// The two readers give the same tree and errors on generated and damaged documents.
     #[test]
-    fn the_index_reader_matches_the_reference_on_generated_and_damaged_documents() {
+    fn the_two_readers_agree_on_generated_and_damaged_documents() {
         let mut rng = Rng(0x9e37_79b9_7f4a_7c15);
         let noise = b"<>/=\"'&;#x0aZ \n![]-?";
         for _ in 0..600 {
@@ -1154,9 +1159,9 @@ mod tests {
         same(deep.as_bytes(), Limits::default());
     }
 
-    /// Hostile input is refused with the reference's errors, without allocating from what it declares.
+    /// Hostile input is refused by both readers with the same errors.
     #[test]
-    fn hostile_input_is_refused_like_the_reference() {
+    fn hostile_input_is_refused_alike_by_both_readers() {
         let hostile = [
             format!("<AfterEffectsProject>{}{}</AfterEffectsProject>", "<a>".repeat(100_000), "</a>".repeat(100_000)),
             format!("<AfterEffectsProject>{}", "<string>".repeat(1000)),
@@ -1179,10 +1184,10 @@ mod tests {
         }
     }
 
-    /// Every `.aepx` of the fixture directory gives the reference's tree (skipped without
-    /// `EFFECTCRAFT_AEP_FIXTURES`).
+    /// Every `.aepx` of the fixture directory gives the same tree through both readers (skipped
+    /// without `EFFECTCRAFT_AEP_FIXTURES`).
     #[test]
-    fn every_fixture_aepx_gives_the_reference_tree() {
+    fn every_fixture_aepx_gives_the_same_tree_through_both_readers() {
         let Some(dir) = std::env::var_os("EFFECTCRAFT_AEP_FIXTURES").filter(|d| !d.is_empty()) else { return };
         let Ok(entries) = std::fs::read_dir(dir) else { return };
         let mut paths: Vec<std::path::PathBuf> =
@@ -1191,7 +1196,8 @@ mod tests {
         for path in paths {
             let bytes = std::fs::read(&path).unwrap();
             for l in limit_sets() {
-                assert_eq!(read_aepx_with_limits(&bytes, l), reference::read(&bytes, l), "{}", path.display());
+                let index = index_aepx(&bytes, l).map(|d| TreeIndex::from_drafts(&d.buffer, d.nodes, d.trailer).to_file().into_owned());
+                assert_eq!(index, read_aepx_with_limits(&bytes, l), "{}", path.display());
             }
         }
     }
diff --git a/crates/aep/src/container/aepx/reference.rs b/crates/aep/src/container/aepx/tree.rs
similarity index 97%
rename from crates/aep/src/container/aepx/reference.rs
rename to crates/aep/src/container/aepx/tree.rs
index dca6b77c4..ba7e20ed5 100644
--- a/crates/aep/src/container/aepx/reference.rs
+++ b/crates/aep/src/container/aepx/tree.rs
@@ -1,6 +1,6 @@
-//! The `.aepx` reader as it was before it fed the flat index: it builds the owned chunk tree
-//! element by element. Kept for the tests only, as the reference the index reader is compared
-//! with (the same tree and the same errors on generated, damaged and corpus input).
+//! The `.aepx` reader of the owned chunk tree ([`super::read_aepx`]): it builds the tree element by
+//! element. The importer uses the index reader in `aepx.rs` instead; the tests compare the two on
+//! generated, damaged and corpus input (the same tree and the same errors).
 
 use std::borrow::Cow;
 
@@ -9,8 +9,8 @@ use crate::container::chunk::{AepFile, Body, Chunk, LIST, NESTED_IDS};
 use crate::container::error::AepError;
 use crate::container::read::Limits;
 
-/// [`super::read_aepx_with_limits`] as it was.
-pub(crate) fn read(data: &[u8], limits: Limits) -> Result<AepFile<'static>, AepError> {
+/// [`super::read_aepx_with_limits`].
+pub(super) fn read(data: &[u8], limits: Limits) -> Result<AepFile<'static>, AepError> {
     let text = match std::str::from_utf8(data) {
         Ok(t) => t.as_bytes(),
         Err(e) => return Err(xml(e.valid_up_to(), "the file is not valid UTF-8")),
diff --git a/crates/aep/src/container/index.rs b/crates/aep/src/container/index.rs
index 3ae8b97ac..695d1e9f3 100644
--- a/crates/aep/src/container/index.rs
+++ b/crates/aep/src/container/index.rs
@@ -232,14 +232,7 @@ impl<'a> TreeIndex<'a> {
     /// The owned chunk tree (the bodies stay borrowed from the input): what
     /// [`crate::container::parse`] gives for the same file.
     pub fn to_file(&self) -> AepFile<'a> {
-        AepFile { chunks: self.build(0, u32::try_from(self.nodes.len()).unwrap_or(u32::MAX), Cow::Borrowed), trailer: Cow::Borrowed(self.trailer) }
-    }
-
-    /// [`Self::to_file`] with every body copied, in one pass without recursion (what
-    /// `to_file().into_owned()` gives, without the borrowed tree in between).
-    pub(crate) fn to_owned_file(&self) -> AepFile<'static> {
-        let owned = |d: &[u8]| Cow::Owned(d.to_vec());
-        AepFile { chunks: self.build(0, u32::try_from(self.nodes.len()).unwrap_or(u32::MAX), owned), trailer: Cow::Owned(self.trailer.to_vec()) }
+        AepFile { chunks: self.build(0, u32::try_from(self.nodes.len()).unwrap_or(u32::MAX)), trailer: Cow::Borrowed(self.trailer) }
     }
 
     /// The entry at `at`, `None` past the end.
@@ -254,7 +247,7 @@ impl<'a> TreeIndex<'a> {
 
     /// The owned chunks for the siblings that start at `next` and fill `next..end`, without
     /// recursion.
-    fn build<'o>(&self, next: u32, end: u32, body_of: impl Fn(&'a [u8]) -> Cow<'o, [u8]>) -> Vec<Chunk<'o>> {
+    fn build(&self, next: u32, end: u32) -> Vec<Chunk<'a>> {
         struct Frame<'a> {
             /// The list or nested chunk being filled; `None` for the outermost range.
             at: Option<u32>,
@@ -277,9 +270,9 @@ impl<'a> TreeIndex<'a> {
                         let sub_end = self.end_of(at);
                         stack.push(Frame { at: Some(at), kids: Vec::new(), next: at.saturating_add(1), end: sub_end });
                     }
-                    Kind::Data => top.kids.push(Chunk { id: e.id, body: Body::Data(body_of(e.data)), pad: e.pad }),
+                    Kind::Data => top.kids.push(Chunk { id: e.id, body: Body::Data(Cow::Borrowed(e.data)), pad: e.pad }),
                     Kind::OpaqueList => {
-                        top.kids.push(Chunk { id: e.id, body: Body::OpaqueList { list_type: e.list_type, data: body_of(e.data) }, pad: e.pad });
+                        top.kids.push(Chunk { id: e.id, body: Body::OpaqueList { list_type: e.list_type, data: Cow::Borrowed(e.data) }, pad: e.pad });
                     }
                 }
             } else {
@@ -497,7 +490,7 @@ impl<'f, 'a> Node<'f, 'a> {
     pub fn to_chunk(self) -> Chunk<'a> {
         match self.0 {
             NodeRepr::Chunk(c) => c.clone(),
-            NodeRepr::Index(tree, at) => tree.build(at, tree.end_of(at), Cow::Borrowed).into_iter().next().unwrap_or_else(|| Chunk::data(self.id(), &[][..])),
+            NodeRepr::Index(tree, at) => tree.build(at, tree.end_of(at)).into_iter().next().unwrap_or_else(|| Chunk::data(self.id(), &[][..])),
         }
     }
 
diff --git a/crates/aep/src/import.rs b/crates/aep/src/import.rs
index a2f4a4415..3d34b966f 100644
--- a/crates/aep/src/import.rs
+++ b/crates/aep/src/import.rs
@@ -246,14 +246,12 @@ mod tests {
         }
     }
 
-    /// Imports an `.aepx` through the owned tree of the reader this replaced and through the
-    /// index ([`import`]): the same project, report and settings, or the same error.
+    /// Imports an `.aepx` through the owned tree ([`crate::read_aepx`]) and through the index
+    /// ([`import`]): the same project, report and settings, or the same error.
     fn both_aepx(bytes: &[u8], name: &str) -> Result<ImportResult, AepImportError> {
         let exists = |_: &str| true;
         let options = ImportOptions { allow_losses: true, ..ImportOptions::new(&exists) };
-        let a = crate::container::aepx_reference::read(bytes, Limits::default())
-            .map_err(AepImportError::from)
-            .and_then(|file| import_root(&mut Project::default(), Root::from(&file), &options));
+        let a = crate::read_aepx(bytes).map_err(AepImportError::from).and_then(|file| import_root(&mut Project::default(), Root::from(&file), &options));
         let b = import(&mut Project::default(), bytes, &options);
         assert!(a == b, "{name}: the .aepx import differs through the index");
         b
diff --git a/docs/aep-format.md b/docs/aep-format.md
index c8708bf90..21ba31ae1 100644
--- a/docs/aep-format.md
+++ b/docs/aep-format.md
@@ -119,11 +119,11 @@ counterpart (a name that is not 1 to 4 characters) are skipped with their conten
   with the byte offset. It runs without recursion; the nesting depth (`Limits::max_depth`) and the
   element count (`Limits::max_chunks`) are bounded, and everything it allocates is bounded by the
   size of the input.
-- The reader decodes every body (hex, text, the alias JSON, the numbers) into one buffer and records
-  the chunks as a flat depth-first list whose bodies are ranges of that buffer. The importer
-  indexes that buffer (`TreeIndex`) as it indexes an `.aep`; `read_aepx` converts it into the
-  owned tree. The tree is the one the element-by-element reader gave, which the crate's tests keep
-  as the reference.
+- There are two readers. `read_aepx` builds the owned tree element by element. The importer, which
+  only reads, uses a second reader that decodes every body (hex, text, the alias JSON, the
+  numbers) into one buffer and records the chunks as a flat depth-first list whose bodies are
+  ranges of that buffer; it indexes that buffer (`TreeIndex`) as it indexes an `.aep`. The tests
+  hold both readers to the same tree and the same errors.
 - Tests: `tests/aepx.rs` compares the five fixture pairs chunk by chunk and byte by byte, compares
   the typed view of both forms, and runs truncated, bit-flipped, deeply nested and oversized
   inputs; `crates/aep/tests/it/import/aepx.rs` imports both forms of each pair and expects the same

From 9c36d34295925bef7425a203aa74ac60dac14d57 Mon Sep 17 00:00:00 2001
From: vangel76 <vangel1976@googlemail.com>
Date: Thu, 12 Nov 2026 23:57:25 +0100
Subject: [PATCH 28/30] Export report: compute unlisted for losses beyond the
 detail cap

---
 crates/aep/src/export/report.rs | 9 +++++----
 1 file changed, 5 insertions(+), 4 deletions(-)

diff --git a/crates/aep/src/export/report.rs b/crates/aep/src/export/report.rs
index 22145956d..528af5dba 100644
--- a/crates/aep/src/export/report.rs
+++ b/crates/aep/src/export/report.rs
@@ -250,11 +250,11 @@ impl Collector {
     }
 
     pub fn finish(self) -> ExportReport {
-        ExportReport {
-            exported: self.exported,
-            losses: self.losses.into_values().collect(),
-            limitations: LIMITATIONS.iter().map(|s| (*s).to_string()).collect(),
+        let mut losses: Vec<_> = self.losses.into_values().collect();
+        for loss in &mut losses {
+            loss.unlisted = loss.count.saturating_sub(loss.details.len());
         }
+        ExportReport { exported: self.exported, losses, limitations: LIMITATIONS.iter().map(|s| (*s).to_string()).collect() }
     }
 }
 
@@ -308,5 +308,6 @@ mod tests {
         let report = col.finish();
         assert_eq!(report.count(LossCategory::Masks), MAX_DETAILS + 5);
         assert_eq!(report.losses[0].details.len(), MAX_DETAILS);
+        assert_eq!(report.losses[0].unlisted, 5);
     }
 }

From 2042ee13fe316c5e56033a5a014470061415cd29 Mon Sep 17 00:00:00 2001
From: Codex <codex@openai.com>
Date: Fri, 13 Nov 2026 01:22:39 +0100
Subject: [PATCH 29/30] AEP #3319: remove duplicate integrated report test
 module

---
 crates/aep/src/export/report.rs | 53 ---------------------------------
 1 file changed, 53 deletions(-)

diff --git a/crates/aep/src/export/report.rs b/crates/aep/src/export/report.rs
index f409fb4ab..528af5dba 100644
--- a/crates/aep/src/export/report.rs
+++ b/crates/aep/src/export/report.rs
@@ -311,56 +311,3 @@ mod tests {
         assert_eq!(report.losses[0].unlisted, 5);
     }
 }
-
-#[cfg(test)]
-mod tests {
-    use super::*;
-
-    /// A report with losses in two categories, as the collector finishes it.
-    fn collected() -> ExportReport {
-        let mut col = Collector::default();
-        col.exported.layers = 2;
-        col.lose(LossCategory::RoundedTimes, "time 1");
-        col.lose(LossCategory::Effects, String::from("fx 1"));
-        col.lose(LossCategory::Effects, "fx 2");
-        let mut report = col.finish();
-        report.limitations.truncate(1);
-        report.limitations[0] = "limit".into();
-        report
-    }
-
-    /// The JSON shape agents read: field names, category spelling, order and the loss entries.
-    #[test]
-    fn the_json_shape_is_pinned() {
-        let json = serde_json::to_string(&collected()).unwrap();
-        assert_eq!(
-            json,
-            r#"{"exported":{"folders":0,"compositions":0,"solids":0,"layers":2,"solidLayers":0,"nullLayers":0,"adjustmentLayers":0,"properties":0,"keyframes":0,"expressions":0,"masks":0,"precompLayers":0,"effects":0,"footage":0,"footageLayers":0,"textLayers":0,"markers":0,"cameras":0,"lights":0,"shapeLayers":0,"timeRemaps":0,"textAnimators":0,"layerStyles":0},"losses":[{"category":"effects","count":2,"details":["fx 1","fx 2"],"unlisted":0},{"category":"rounded_times","count":1,"details":["time 1"],"unlisted":0}],"limitations":["limit"]}"#
-        );
-        let back: ExportReport = serde_json::from_str(&json).unwrap();
-        assert_eq!(back, collected());
-    }
-
-    /// The queries read the losses.
-    #[test]
-    fn the_queries_read_the_losses() {
-        let report = collected();
-        assert_eq!((report.total_losses(), report.is_lossless()), (3, false));
-        assert_eq!((report.count(LossCategory::Effects), report.count(LossCategory::Lights)), (2, 0));
-        assert_eq!(report.summary(), "effects: 2, rounded times: 1");
-        let empty = Collector::default().finish();
-        assert_eq!((empty.total_losses(), empty.is_lossless(), empty.summary()), (0, true, String::new()));
-    }
-
-    /// Details stop at the cap.
-    #[test]
-    fn details_stop_at_the_cap() {
-        let mut col = Collector::default();
-        for i in 0..MAX_DETAILS + 5 {
-            col.lose(LossCategory::Masks, format!("mask {i}"));
-        }
-        let report = col.finish();
-        assert_eq!(report.count(LossCategory::Masks), MAX_DETAILS + 5);
-        assert_eq!(report.losses[0].details.len(), MAX_DETAILS);
-    }
-}

From 20c4faf37c4936ccdece2f161935084188b59bcc Mon Sep 17 00:00:00 2001
From: vangel76 <vangel1976@googlemail.com>
Date: Fri, 13 Nov 2026 18:42:33 +0100
Subject: [PATCH 30/30] AEP import: precomp loop search counts only
 same-component users; only eligible layers are candidate links; popup keys
 lower whole strings (final sigma)

---
 crates/aep/src/container/effect_map.rs | 23 +++++++-
 crates/aep/src/import/build.rs         | 73 +++++++++++++++++++++++---
 crates/aep/tests/it/import/bounds.rs   | 27 +++++++++-
 3 files changed, 113 insertions(+), 10 deletions(-)

diff --git a/crates/aep/src/container/effect_map.rs b/crates/aep/src/container/effect_map.rs
index 68a905be0..605e0b6f5 100644
--- a/crates/aep/src/container/effect_map.rs
+++ b/crates/aep/src/container/effect_map.rs
@@ -1160,7 +1160,9 @@ pub const GLOW_MIDPOINT_MAX: f64 = 0.990_005_493_164_062_5;
 /// language, so an item can start with a capital outside ASCII (French "Écran"), and its key must
 /// be the same as for the same word in lower case.
 pub fn popup_key(item: &str) -> String {
-    popup_stem(item).chars().flat_map(char::to_lowercase).collect()
+    // The whole string is lowered at once: Unicode's lower case depends on the context (a Greek
+    // capital sigma ends a word as final sigma), which a per-character mapping loses.
+    popup_stem(item).to_lowercase()
 }
 
 /// [`popup_key`] before the lower-casing, borrowed: `item` trimmed, without a final ` channel`
@@ -1178,7 +1180,9 @@ const SUFFIX: &[u8] = b" channel";
 
 /// Whether two popup items have the same [`popup_key`], without building either key.
 pub(crate) fn popup_keys_match(a: &str, b: &str) -> bool {
-    popup_stem(a).chars().flat_map(char::to_lowercase).eq(popup_stem(b).chars().flat_map(char::to_lowercase))
+    let (a, b) = (popup_stem(a), popup_stem(b));
+    // ASCII lowers per byte without a key; anything else lowers as a whole string (see `popup_key`).
+    if a.is_ascii() && b.is_ascii() { a.eq_ignore_ascii_case(b) } else { a.to_lowercase() == b.to_lowercase() }
 }
 
 /// The English [`popup_key`] a non-English After Effects popup item name stands for, when this
@@ -1253,6 +1257,12 @@ mod tests {
             "Luminance",
             "\u{c9}CRAN",
             "\u{e9}cran",
+            // Greek: a capital sigma at the end of a word lowers to the final form.
+            "\u{39f}\u{3a3}",
+            "\u{3bf}\u{3c2}",
+            "\u{3bf}\u{3c3}",
+            "\u{39f}\u{3a3} Channel",
+            "\u{3a3}\u{39f}\u{3a3}",
         ];
         for a in items {
             assert_eq!(popup_key(a), old_key(a), "{a:?}");
@@ -1270,4 +1280,13 @@ mod tests {
         assert_eq!(popup_key("Off for 32 bpc Color"), "off for 32 bpc color");
         assert_eq!(popup_key("Red Channel"), "red");
     }
+
+    /// Lower case is context sensitive: a capital sigma at the end of a word is a final sigma.
+    #[test]
+    fn popup_key_keeps_the_final_sigma() {
+        assert_eq!(popup_key("\u{39f}\u{3a3}"), "\u{3bf}\u{3c2}");
+        assert!(popup_keys_match("\u{39f}\u{3a3}", "\u{3bf}\u{3c2}"));
+        assert!(!popup_keys_match("\u{39f}\u{3a3}", "\u{3bf}\u{3c3}"));
+        assert_eq!(popup_key("\u{3a3}\u{39f}\u{3a3} Channel"), "\u{3c3}\u{3bf}\u{3c2}");
+    }
 }
diff --git a/crates/aep/src/import/build.rs b/crates/aep/src/import/build.rs
index 6f7e4f78f..4113c6c94 100644
--- a/crates/aep/src/import/build.rs
+++ b/crates/aep/src/import/build.rs
@@ -905,7 +905,12 @@ impl Precomps {
         if closes_loop(from, to, |to| inside && found.is_some_and(|u| u.contains(&to))) {
             return Link::Loop;
         }
-        self.used_by.entry(to).or_default().insert(from);
+        // Only a link inside a component can lie on a path the loop search follows (it never
+        // leaves the component of the layer's comp), so only those are kept: the searches never
+        // visit, or pay budget for, a link between components.
+        if self.same_component(from, to) {
+            self.used_by.entry(to).or_default().insert(from);
+        }
         Link::Accepted
     }
 
@@ -921,8 +926,11 @@ impl Precomps {
         let mut stack = vec![comp];
         while let Some(c) = stack.pop() {
             for u in self.used_by.get(&c).into_iter().flatten() {
+                if !self.same_component(*u, comp) {
+                    continue;
+                }
                 self.steps_left = self.steps_left.checked_sub(1)?;
-                if self.same_component(*u, comp) && found.insert(*u) {
+                if found.insert(*u) {
                     stack.push(*u);
                 }
             }
@@ -931,16 +939,32 @@ impl Precomps {
     }
 }
 
+/// The source id of a layer that `build_layers` decides by [`Precomps::accept`] when the source is
+/// a composition: a camera, light, text, shape or null layer never becomes a precomp layer, whatever
+/// source it stores, so it is no candidate link.
+fn precomp_layer_source(h: &LayerHeader) -> Option<u32> {
+    if h.layer_type != LayerType::Av || h.is_null_object() { None } else { h.source_id }
+}
+
 /// Every link a precomp layer of the file could make: comp -> the comps its layers name as their
 /// source (resolved as `build_layers` resolves them).
 fn precomp_candidates(sources: &HashMap<u32, Source>, pending: &[PendingComp<'_, '_>]) -> HashMap<ItemId, HashSet<ItemId>> {
+    candidate_links(
+        sources,
+        pending.iter().filter_map(|p| {
+            let comp = p.item.comp()?;
+            Some((p.id, comp.layers().filter_map(|l| l.header().and_then(|h| precomp_layer_source(&h))).collect::<Vec<_>>()))
+        }),
+    )
+}
+
+/// [`precomp_candidates`] from each comp's precomp-eligible layer source ids.
+fn candidate_links(sources: &HashMap<u32, Source>, comps: impl IntoIterator<Item = (ItemId, Vec<u32>)>) -> HashMap<ItemId, HashSet<ItemId>> {
     let mut links: HashMap<ItemId, HashSet<ItemId>> = HashMap::new();
-    for p in pending {
-        let Some(comp) = p.item.comp() else { continue };
-        for layer in comp.layers() {
-            let Some(s) = layer.header().and_then(|h| h.source_id).and_then(|s| sources.get(&s)) else { continue };
+    for (from, ids) in comps {
+        for s in ids.iter().filter_map(|id| sources.get(id)) {
             if s.kind == SourceKind::Comp {
-                links.entry(p.id).or_default().insert(s.item);
+                links.entry(from).or_default().insert(s.item);
             }
         }
     }
@@ -1262,6 +1286,41 @@ mod tests {
         refused
     }
 
+    #[test]
+    fn outside_users_do_not_spend_the_loop_search_budget() {
+        // A is in a loop with B (A <-> B). 100 comps outside the loop show A; the budget is nearly
+        // spent. Building A: its layer of B needs A's users, which are only B's side of the loop:
+        // the outside comps cannot close a loop and must cost nothing, so A's layer is decided.
+        let (a, b) = (ItemId(1), ItemId(2));
+        let ext = |i: u64| ItemId(10 + i);
+        let mut candidates: HashMap<ItemId, HashSet<ItemId>> = HashMap::from([(a, HashSet::from([b])), (b, HashSet::from([a]))]);
+        for i in 0..100 {
+            candidates.insert(ext(i), HashSet::from([a]));
+        }
+        let mut p = Precomps::new(&candidates);
+        for i in 0..100 {
+            assert_eq!(p.accept(ext(i), a, &mut Users::NotSearched), Link::Accepted);
+        }
+        p.steps_left = 5;
+        // B shows A first (inside the loop, one user of A is B itself once accepted), then A shows B.
+        assert_eq!(p.accept(b, a, &mut Users::NotSearched), Link::Accepted);
+        assert_eq!(p.accept(a, b, &mut Users::NotSearched), Link::Loop);
+    }
+
+    #[test]
+    fn ineligible_layers_are_no_candidate_links() {
+        let source = |item: u64, kind| Source { item: ItemId(item), name: String::new(), kind, width: 1, height: 1 };
+        let sources = HashMap::from([(1, source(1, SourceKind::Comp)), (2, source(2, SourceKind::Comp)), (3, source(3, SourceKind::Solid))]);
+        // Comp 1 shows 2 (eligible); comp 2 has no eligible layer of comp 1 (a null or text layer
+        // with that source is filtered by `precomp_layer_source` before): no loop component.
+        let links = candidate_links(&sources, [(ItemId(1), vec![2, 3]), (ItemId(2), vec![])]);
+        let p = Precomps::new(&links);
+        assert!(!p.same_component(ItemId(1), ItemId(2)));
+        // With the back-edge as a candidate they share one, which is what ineligible layers used to do.
+        let looped = candidate_links(&sources, [(ItemId(1), vec![2]), (ItemId(2), vec![1])]);
+        assert!(Precomps::new(&looped).same_component(ItemId(1), ItemId(2)));
+    }
+
     #[test]
     fn the_precomp_loop_check_decides_as_the_full_walk_did() {
         let mut refused = 0;
diff --git a/crates/aep/tests/it/import/bounds.rs b/crates/aep/tests/it/import/bounds.rs
index 2fa0c3003..ef06696c7 100644
--- a/crates/aep/tests/it/import/bounds.rs
+++ b/crates/aep/tests/it/import/bounds.rs
@@ -89,6 +89,12 @@ fn comp_with<'a>(c: &Chunk<'a>, id: u32, name: &str, layers: Vec<Chunk<'a>>) ->
 /// Composition `B` (id 900) with `n` layers of `C`, and `D` (id 901) with `n` layers of `B`,
 /// after `C` in the file. With `c_uses_d`, `C` also gets a layer of `D`, which closes a loop.
 fn precomp_chain(n: u32, c_uses_d: bool) -> Vec<u8> {
+    precomp_chain_with(n, c_uses_d, false)
+}
+
+/// [`precomp_chain`]; with `null_back_edge` the layer of `D` in `C` is a null object (which shows
+/// nothing, so no loop).
+fn precomp_chain_with(n: u32, c_uses_d: bool, null_back_edge: bool) -> Vec<u8> {
     let mut file = parse(SYNTHETIC).unwrap();
     let c = comp_c(&file);
     let solid = solid_layer(&c);
@@ -102,7 +108,15 @@ fn precomp_chain(n: u32, c_uses_d: bool) -> Vec<u8> {
         let c = fold.iter_mut().find(|k| k.is_list(b"Item") && k.child(b"idta").is_some_and(|i| be_u32(i, 16) == COMP_C)).expect("C");
         let kids = children(c);
         let at = kids.iter().position(|k| k.is_list(b"Layr")).expect("a layer");
-        kids.insert(at, layer_copy(&solid, 300_000, &|l| set_be_u32(l, 40, 901)));
+        kids.insert(
+            at,
+            layer_copy(&solid, 300_000, &|l| {
+                set_be_u32(l, 40, 901);
+                if null_back_edge && let Body::Data(d) = &mut l.body {
+                    d.to_mut()[38] |= 0x80;
+                }
+            }),
+        );
     }
     write(&file).unwrap()
 }
@@ -139,6 +153,17 @@ fn every_precomp_layer_that_closes_a_loop_is_refused() {
     assert!(losses(&r, LossCategory::UnsupportedLayers).iter().any(|d| d.contains("precomposition loop")));
 }
 
+#[test]
+fn a_null_layer_naming_a_composition_closes_no_loop() {
+    // The same files as above, but C's layer of D is a null object: it shows nothing, so D's
+    // layers of B are no loop and all of them are imported.
+    let n = 300;
+    let (p, r) = run(&precomp_chain_with(n, true, true));
+    assert_eq!(comp_named(&p, "D").layers.len(), n as usize);
+    assert!(comp_named(&p, "C").layers.iter().any(|l| l.source == LayerSource::Null));
+    assert!(!losses(&r, LossCategory::UnsupportedLayers).iter().any(|d| d.contains("loop")), "{:?}", r.report.losses);
+}
+
 #[test]
 fn many_parented_and_matted_layers_resolve() {
     // `n` copies of the solid layer in C, each parented to it and using it as an alpha matte.