@pilates/core 1.1.0 → 2.0.1

package/dist/algorithm/spineless/layout.js

@@ -24,6 +24,7 @@
  */
 import { roundLayout, roundLayoutFrom } from '../round.js';
 import { buildAppendFragment, buildFlexGrammar, buildRemoveFragment, buildReorderFragment, } from './flex-grammar.js';
+import { field } from './grammar.js';
 import { SpinelessRuntime } from './runtime.js';
 /** An input field's `compute` never calls `read` — guard against it. */
 const NEVER_READ = () => {
@@ -31,10 +32,10 @@ const NEVER_READ = () => {
 };
 /** Every leaf input Field (`deps: []`) the runtime currently tracks. */
 function collectInputs(grammar, runtime) {
-    const inputs = [];
-    for (const [field, rule] of grammar) {
-        if (rule.deps.length === 0 && runtime.isTracked(field))
-            inputs.push(field);
+    const inputs = new Set();
+    for (const [f, rule] of grammar) {
+        if (rule.deps.length === 0 && runtime.isTracked(f))
+            inputs.add(f);
     }
     return inputs;
 }
@@ -95,21 +96,43 @@ function nodeSig(node) {
         s.position
             .map((p) => (p === undefined ? '_' : String(p)))
             .join(','),
+        // Fold-predicate bits for Phase 17: each bit flips when the
+        // property crosses its fold boundary (default → non-default).
+        // Mutating a folded property must change nodeSig so the
+        // classifier triggers a grammar rebuild.
+        s.minWidth === 0 ? '_' : 'mw',
+        s.minHeight === 0 ? '_' : 'mh',
+        s.maxWidth === undefined ? '_' : 'xw',
+        s.maxHeight === undefined ? '_' : 'xh',
+        s.margin[0] === 0 ? '_' : 'm0',
+        s.margin[1] === 0 ? '_' : 'm1',
+        s.margin[2] === 0 ? '_' : 'm2',
+        s.margin[3] === 0 ? '_' : 'm3',
     ].join('|');
 }
 function captureSnaps(root) {
     const snaps = new Map();
-    function visit(n) {
-        const children = [];
-        for (let i = 0; i < n.getChildCount(); i++)
-            children.push(n.getChild(i));
-        snaps.set(n, { sig: nodeSig(n), measure: n.getMeasureFunc(), children });
-        for (const c of children)
-            visit(c);
-    }
-    visit(root);
+    captureSnapsInto(root, snaps);
     return snaps;
 }
+/** Write `node`'s subtree snaps into `target` (used by the
+ *  fast-path graft to extend the snap map by the appended region
+ *  without rewalking the whole tree). */
+function captureSnapsInto(node, target) {
+    const children = [];
+    for (let i = 0; i < node.getChildCount(); i++)
+        children.push(node.getChild(i));
+    target.set(node, { sig: nodeSig(node), measure: node.getMeasureFunc(), children });
+    for (const c of children)
+        captureSnapsInto(c, target);
+}
+/** A fresh `NodeSnap` for `node` against its current children. */
+function freshSnap(node) {
+    const children = [];
+    for (let i = 0; i < node.getChildCount(); i++)
+        children.push(node.getChild(i));
+    return { sig: nodeSig(node), measure: node.getMeasureFunc(), children };
+}
 /** True iff `node`'s current child list still matches `snap.children`. */
 function childrenUnchanged(snap, node) {
     if (node.getChildCount() !== snap.children.length)
@@ -203,23 +226,43 @@ export class SpinelessLayout {
             this.finishWhole();
             return;
         }
-        // Classify the dirty region: any structural change forces the
-        // graft / rebuild paths; otherwise it is a pure value relayout.
+        // Classify the dirty region. The classifier collects PIVOTS —
+        // dirty nodes whose CHILDREN LIST changed since the last layout —
+        // and short-circuits to a full rebuild when any snapped node's
+        // sig / measure changed (those need a fresh grammar). A dirty
+        // node WITHOUT a snap is a freshly-introduced node (part of an
+        // appended subtree); the graft validator handles it, so the
+        // classifier just skips it.
+        //
+        // Dispatch:
+        //   - sig / measure change         → fullBuild
+        //   - pivots.length === 0          → value relayout
+        //   - pivots.length === 1          → graft / detach / reorder
+        //   - pivots.length > 1            → fullBuild (multi-parent
+        //                                     structural change; no
+        //                                     fast-path handles it)
         const dirty = [];
         collectDirty(this.root, dirty);
         const snaps = this.built.snaps;
-        let structural = false;
+        const pivots = [];
+        let needsRebuild = false;
         for (const n of dirty) {
             const snap = snaps.get(n);
-            if (snap === undefined ||
-                snap.sig !== nodeSig(n) ||
-                snap.measure !== n.getMeasureFunc() ||
-                !childrenUnchanged(snap, n)) {
-                structural = true;
+            if (snap === undefined) {
+                // Freshly-introduced node — has no pre-layout snap. The graft
+                // validator below verifies the new region forms one subtree
+                // rooted under a single pivot; don't treat as a rebuild trigger.
+                continue;
+            }
+            if (snap.sig !== nodeSig(n) || snap.measure !== n.getMeasureFunc()) {
+                needsRebuild = true;
                 break;
             }
+            if (!childrenUnchanged(snap, n)) {
+                pivots.push(n);
+            }
         }
-        if (!structural) {
+        if (!needsRebuild && pivots.length === 0) {
             const moved = this.relayoutValues(dirty, availableWidth, availableHeight);
             this.stats.incrementalRelayouts++;
             const rs = this.built.runtime.stats;
@@ -230,48 +273,73 @@ export class SpinelessLayout {
                 fieldsChanged: rs.recomputeChanged,
                 movedSubtrees: moved.length,
             };
-            this.finishIncremental(moved);
+            this.finishMoved(moved, []);
             clearDirtyRegion(this.root);
             return;
         }
-        if (this.tryGraftAppend(availableWidth, availableHeight)) {
-            this.stats.graftRelayouts++;
-            const rs = this.built.runtime.stats;
-            this._lastTrace = {
-                path: 'graft',
-                dirtyNodes: dirty.length,
-                fieldsRecomputed: rs.recomputeVisited,
-                fieldsChanged: rs.recomputeChanged,
-                movedSubtrees: 0,
-            };
-        }
-        else if (this.tryDetachRemove(availableWidth, availableHeight)) {
-            this.stats.detachRelayouts++;
-            const rs = this.built.runtime.stats;
-            this._lastTrace = {
-                path: 'detach',
-                dirtyNodes: dirty.length,
-                fieldsRecomputed: rs.recomputeVisited,
-                fieldsChanged: rs.recomputeChanged,
-                movedSubtrees: 0,
-            };
-        }
-        else if (this.tryReorder(availableWidth, availableHeight)) {
-            this.stats.reorderRelayouts++;
-            const rs = this.built.runtime.stats;
-            this._lastTrace = {
-                path: 'reorder',
-                dirtyNodes: dirty.length,
-                fieldsRecomputed: rs.recomputeVisited,
-                fieldsChanged: rs.recomputeChanged,
-                movedSubtrees: 0,
-            };
-        }
-        else {
-            this.fullBuild(availableWidth, availableHeight);
-            this.stats.fullBuilds++;
+        if (!needsRebuild && pivots.length === 1) {
+            const pivot = pivots[0];
+            const graft = this.tryGraftAppend(pivot, dirty, availableWidth, availableHeight);
+            if (graft !== null) {
+                this.stats.graftRelayouts++;
+                const rs = this.built.runtime.stats;
+                const survivorRoots = this.movedSubtreeRoots(graft.changed);
+                // CRITICAL: include graft.child explicitly. Its fields were
+                // computed via integrate() at graft time, not via recompute(),
+                // so they don't appear in `changed`. Without this, a simple-
+                // regime append (changed is empty) writes back NOTHING and
+                // the appended subtree ships with _layout = 0. The structural-
+                // differential fuzzer catches this.
+                const roots = [graft.child, ...survivorRoots.filter((r) => !isInSubtree(r, graft.child))];
+                this._lastTrace = {
+                    path: 'graft',
+                    dirtyNodes: dirty.length,
+                    fieldsRecomputed: rs.recomputeVisited,
+                    fieldsChanged: rs.recomputeChanged,
+                    movedSubtrees: roots.length,
+                };
+                this.finishMoved(roots, []);
+                clearDirtyRegion(this.root);
+                return;
+            }
+            const detach = this.tryDetachRemove(pivot, dirty, availableWidth, availableHeight);
+            if (detach !== null) {
+                this.stats.detachRelayouts++;
+                const rs = this.built.runtime.stats;
+                const survivorRoots = this.movedSubtreeRoots(detach.changed);
+                this._lastTrace = {
+                    path: 'detach',
+                    dirtyNodes: dirty.length,
+                    fieldsRecomputed: rs.recomputeVisited,
+                    fieldsChanged: rs.recomputeChanged,
+                    movedSubtrees: survivorRoots.length,
+                };
+                // Survivors may be empty for simple-regime removes; explicitly
+                // include detach.parent so its scroll extent is recomputed.
+                this.finishMoved(survivorRoots, [detach.parent]);
+                clearDirtyRegion(this.root);
+                return;
+            }
+            const reorder = this.tryReorder(pivot, dirty, availableWidth, availableHeight);
+            if (reorder !== null) {
+                this.stats.reorderRelayouts++;
+                const rs = this.built.runtime.stats;
+                const movedRoots = this.movedSubtreeRoots(reorder.changed);
+                this._lastTrace = {
+                    path: 'reorder',
+                    dirtyNodes: dirty.length,
+                    fieldsRecomputed: rs.recomputeVisited,
+                    fieldsChanged: rs.recomputeChanged,
+                    movedSubtrees: movedRoots.length,
+                };
+                this.finishMoved(movedRoots, [reorder.reordered]);
+                clearDirtyRegion(this.root);
+                return;
+            }
         }
-        this.finishWhole();
+        this.fullBuild(availableWidth, availableHeight);
+        this.stats.fullBuilds++;
+        this.finishWhole(); // Only reached by fullBuild fallback now
     }
     /** Discard any persisted state and build the grammar afresh. */
     fullBuild(availableWidth, availableHeight) {
@@ -308,89 +376,137 @@ export class SpinelessLayout {
     }
     /**
      * Fast-path a structural change that is exactly a single child
-     * append: `buildAppendFragment` + `graft`, no whole-tree rebuild.
-     * Returns `false` (and changes nothing) when the change is not a
-     * clean append the fast-path covers — the caller then rebuilds.
+     * append at `pivot`: `buildAppendFragment` + `graft`, no whole-tree
+     * rebuild. Returns `null` (and changes nothing) when the change is
+     * not a clean append the fast-path covers — the caller then tries
+     * the next fast-path / rebuilds.
+     *
+     * The classifier supplies `pivot` — a dirty node whose snapshot
+     * exists (so sig / measure are unchanged) and whose children list
+     * differs from its snap's. The validator inspects ONLY pivot's
+     * children, not the whole tree.
      */
-    tryGraftAppend(availableWidth, availableHeight) {
+    tryGraftAppend(pivot, dirty, availableWidth, availableHeight) {
         const built = this.built;
         const snaps = built.snaps;
-        // Walk the current tree; no previously-snapshotted node may be
-        // gone (a removal is not an append), and at least one must be new.
-        const curNodes = new Set();
-        (function visit(n) {
-            curNodes.add(n);
-            for (let i = 0; i < n.getChildCount(); i++)
-                visit(n.getChild(i));
-        })(this.root);
-        for (const n of snaps.keys()) {
-            if (!curNodes.has(n))
-                return false;
-        }
-        const added = [];
-        for (const n of curNodes) {
-            if (!snaps.has(n))
-                added.push(n);
-        }
-        if (added.length === 0)
-            return false;
-        // No surviving node's signature / measure may have changed —
-        // `graft` patches only the append.
-        for (const [n, snap] of snaps) {
-            if (snap.sig !== nodeSig(n) || snap.measure !== n.getMeasureFunc())
-                return false;
-        }
-        // The added nodes must form exactly one subtree — its root is the
-        // unique added node whose parent is not itself added.
-        const addedSet = new Set(added);
-        let child = null;
-        for (const n of added) {
-            const p = n.getParent();
-            if (p === null || !addedSet.has(p)) {
-                if (child !== null)
-                    return false; // two separate appends
-                child = n;
+        const snap = snaps.get(pivot);
+        // Pivot's live children must be its snapped children with exactly
+        // ONE inserted child (anywhere — last for simple regime, mid-list
+        // for non-simple). Walk pivot's children positionally —
+        // O(pivot's children), not O(tree).
+        const live = pivot.getChildCount();
+        const snapped = snap.children.length;
+        if (live !== snapped + 1)
+            return null;
+        // Find the insertion index: the first position where pivot's live
+        // child diverges from snap. After the new child, the tail must
+        // match the rest of the snap.
+        let insertAt = snapped; // default: appended at the end
+        for (let i = 0; i < snapped; i++) {
+            if (pivot.getChild(i) !== snap.children[i]) {
+                insertAt = i;
+                break;
             }
         }
-        if (child === null)
-            return false;
-        const parent = child.getParent();
-        if (parent === null)
-            return false;
+        // Verify the tail past the insertion matches.
+        for (let i = insertAt; i < snapped; i++) {
+            if (pivot.getChild(i + 1) !== snap.children[i])
+                return null;
+        }
+        const child = pivot.getChild(insertAt);
         // A change inside a `display: 'none'` subtree: the hidden region
         // has no grammar fields to graft onto. A node with no entry in
         // `fields` is hidden (or under a hidden ancestor) — fall back to
         // a rebuild, which correctly skips the whole hidden subtree.
-        if (!built.fields.has(parent))
-            return false;
-        const fragment = buildAppendFragment(built.output, this.root, parent, child, built.available);
+        if (!built.fields.has(pivot))
+            return null;
+        // Every other dirty-with-no-snap node must be a descendant of
+        // `child` (i.e. the appended subtree). The classifier already
+        // collected them; if any escaped this subtree, it would be an
+        // independent append elsewhere — handled by the multi-pivot
+        // fullBuild fallback, but a single-pivot append must be tight.
+        //
+        // Verifying this requires walking just the appended subtree:
+        // O(added subtree).
+        const subtreeMembers = new Set();
+        {
+            const stack = [child];
+            while (stack.length > 0) {
+                const n = stack.pop();
+                subtreeMembers.add(n);
+                for (let i = 0; i < n.getChildCount(); i++)
+                    stack.push(n.getChild(i));
+            }
+        }
+        const fragment = buildAppendFragment(built.output, this.root, pivot, child, built.available);
         if (fragment === null)
-            return false;
+            return null;
         built.runtime.graft(fragment.additions, fragment.newRoots);
-        for (const [field, rule] of fragment.rebinds)
-            built.runtime.rebindRule(field, rule);
+        for (const [rf, rule] of fragment.rebinds)
+            built.runtime.rebindRule(rf, rule);
         built.output = fragment.next;
-        built.inputs = collectInputs(fragment.next.grammar, built.runtime);
-        built.snaps = captureSnaps(this.root);
-        const idx = indexFields(fragment.next);
-        built.fields = idx.fields;
-        built.owner = idx.owner;
-        // Pick up any value mutations in the same gap, then recompute
-        // (covering the grafted / rebound fields too).
-        this.applyAvailable(availableWidth, availableHeight);
-        for (const field of built.inputs) {
-            if (built.output.grammar.get(field).compute(NEVER_READ) !== built.runtime.evaluate(field)) {
-                built.runtime.markDirty(field);
+        // Incremental bookkeeping (Part C):
+        //
+        // `built.snaps` — update pivot's snap (children list changed) and
+        // add a fresh snap for every node in the appended subtree.
+        built.snaps.set(pivot, freshSnap(pivot));
+        captureSnapsInto(child, built.snaps);
+        // `built.fields` / `built.owner` — every new layout field belongs
+        // to a node in the appended subtree. Walk the subtree and gather
+        // each node's four layout fields from `fragment.additions`. A
+        // `display: 'none'` descendant has no fields (it isn't in
+        // additions for its layout-field keys); skip it.
+        for (const n of subtreeMembers) {
+            if (n.style.display === 'none')
+                continue;
+            const w = field(n, 'width');
+            const h = field(n, 'height');
+            const l = field(n, 'left');
+            const t = field(n, 'top');
+            if (!fragment.next.grammar.has(w))
+                continue;
+            built.fields.set(n, { width: w, height: h, left: l, top: t });
+            built.owner.set(w, n);
+            built.owner.set(h, n);
+            built.owner.set(l, n);
+            built.owner.set(t, n);
+        }
+        // `built.inputs` — add new leaf input fields from additions. For
+        // simple regime nothing existing changes tracking, so this is
+        // additive. For non-simple regime, existing inputs may have just
+        // become tracked (e.g. the previous last child's main-END
+        // margin); the runtime's tracking is post-graft, so filter the
+        // OLD list to only tracked + add new tracked leaves.
+        if (fragment.rebinds.length === 0) {
+            // Simple regime: no existing input changed tracking — just
+            // append the new tracked leaves.
+            for (const [f, rule] of fragment.additions) {
+                if (rule.deps.length === 0 && built.runtime.isTracked(f)) {
+                    built.inputs.add(f);
+                }
             }
         }
-        built.runtime.recompute();
-        return true;
+        else {
+            // Non-simple regime: existing inputs may have gained or lost
+            // tracking. The cheapest correct update is a full recompute
+            // (same cost as the fragment builder's O(tree) rebuild).
+            built.inputs = collectInputs(fragment.next.grammar, built.runtime);
+        }
+        // Pick up any value mutations in the same gap, then recompute
+        // (covering the grafted / rebound fields too). Iterate ONLY the
+        // dirty nodes' inputs — every value mutation marks its node
+        // dirty, so we don't need to scan the whole input set.
+        this.applyAvailable(availableWidth, availableHeight);
+        this.markDriftedInputs(dirty);
+        const changed = built.runtime.recompute();
+        return { child, changed };
     }
     /**
      * Fast-path a structural change that is exactly a single subtree
-     * removal: `buildRemoveFragment` + `rebindRule` / `detach`, no
-     * whole-tree rebuild. Returns `false` (changing nothing) when the
-     * change is not a clean removal — the caller then rebuilds.
+     * removal at `pivot`: `buildRemoveFragment` + `rebindRule` /
+     * `detach`, no whole-tree rebuild. Returns `null` (changing nothing)
+     * when the change is not a clean removal — the caller then tries
+     * the next fast-path / rebuilds.
      *
      * `buildRemoveFragment` must see the removed `child` still attached
      * (its regime check reads the parent's live child list and it walks
@@ -398,202 +514,207 @@ export class SpinelessLayout {
      * runs the caller has already detached it — so the removed subtree
      * is briefly re-inserted at its old index for the fragment build,
      * then detached again.
+     *
+     * The classifier supplies `pivot` — the parent whose children list
+     * differs from its snap's. The validator inspects ONLY pivot's
+     * children, not the whole tree.
      */
-    tryDetachRemove(availableWidth, availableHeight) {
+    tryDetachRemove(pivot, dirty, availableWidth, availableHeight) {
         const built = this.built;
         const snaps = built.snaps;
-        // Walk the current tree. No previously-snapshotted node may be new
-        // (an addition is not a removal); at least one must be gone.
-        const curNodes = new Set();
-        (function visit(n) {
-            curNodes.add(n);
-            for (let i = 0; i < n.getChildCount(); i++)
-                visit(n.getChild(i));
-        })(this.root);
-        for (const n of curNodes) {
-            if (!snaps.has(n))
-                return false;
-        }
-        const removed = [];
-        for (const n of snaps.keys()) {
-            if (!curNodes.has(n))
-                removed.push(n);
-        }
-        if (removed.length === 0)
-            return false;
-        // No surviving node's signature / measure may have changed —
-        // `detach` patches only the removal.
-        for (const [n, snap] of snaps) {
-            if (!curNodes.has(n))
-                continue;
-            if (snap.sig !== nodeSig(n) || snap.measure !== n.getMeasureFunc())
-                return false;
-        }
-        // The snapped child -> parent map — the live tree no longer holds
-        // the removed nodes' edges.
-        const snapParent = new Map();
-        for (const [n, snap] of snaps) {
-            for (const c of snap.children)
-                snapParent.set(c, n);
-        }
-        // The removed nodes must form exactly one subtree — its root is
-        // the unique removed node whose snapped parent is not itself
-        // removed; that parent must survive.
-        const removedSet = new Set(removed);
-        let child = null;
-        for (const n of removed) {
-            const p = snapParent.get(n);
-            if (p === undefined || !removedSet.has(p)) {
-                if (child !== null)
-                    return false; // two separate removals
-                child = n;
-            }
-        }
-        if (child === null)
-            return false;
-        const parent = snapParent.get(child);
-        if (parent === undefined || !curNodes.has(parent))
-            return false;
+        const snap = snaps.get(pivot);
+        const snapChildren = snap.children;
+        // Pivot's live children must be its snapped children with exactly
+        // one contiguous removal. Walk pivot's children positionally —
+        // O(pivot's children), not O(tree).
+        const liveCount = pivot.getChildCount();
+        const snappedCount = snapChildren.length;
+        if (liveCount >= snappedCount)
+            return null;
+        // Find the index where they diverge; this is the start of the
+        // removed run.
+        let removedStart = 0;
+        while (removedStart < liveCount &&
+            pivot.getChild(removedStart) === snapChildren[removedStart]) {
+            removedStart++;
+        }
+        const removedCount = snappedCount - liveCount;
+        // Verify the snapped tail past the removed run still matches the
+        // live tail.
+        for (let i = removedStart; i < liveCount; i++) {
+            if (pivot.getChild(i) !== snapChildren[i + removedCount])
+                return null;
+        }
+        // Single-child removal: simple-regime requirement. (A wider
+        // contiguous removal would still be a valid fragment for
+        // non-simple regime, but the fragment builder is single-`child`
+        // only, so split-merge runs fall through to fullBuild.)
+        if (removedCount !== 1)
+            return null;
+        const child = snapChildren[removedStart];
         // A removal inside a `display: 'none'` subtree: the hidden region
         // has no fields to `detach`. A node absent from `fields` is hidden
         // (or under a hidden ancestor) — rebuild instead.
-        if (!built.fields.has(parent))
-            return false;
-        // `removed` must be exactly `child`'s snapped subtree.
-        let subtreeCount = 0;
-        (function count(n) {
-            subtreeCount++;
-            for (const c of snaps.get(n).children)
-                count(c);
-        })(child);
-        if (subtreeCount !== removed.length)
-            return false;
-        // `parent`'s current children must be its snapped children with
-        // `child` spliced out — so re-inserting `child` at `idx` restores
-        // the exact pre-removal tree for `buildRemoveFragment`.
-        const snapChildren = snaps.get(parent).children;
-        const idx = snapChildren.indexOf(child);
-        if (idx === -1 || parent.getChildCount() !== snapChildren.length - 1)
-            return false;
-        for (let i = 0, j = 0; i < snapChildren.length; i++) {
-            if (snapChildren[i] === child)
-                continue;
-            if (parent.getChild(j) !== snapChildren[i])
-                return false;
-            j++;
+        if (!built.fields.has(pivot))
+            return null;
+        // The removed subtree's nodes must still be reachable from
+        // `child` through SNAP edges (the live tree no longer has them).
+        // Collect them via DFS over snaps.
+        const removedNodes = new Set();
+        {
+            const stack = [child];
+            while (stack.length > 0) {
+                const n = stack.pop();
+                removedNodes.add(n);
+                const cs = snaps.get(n);
+                if (cs !== undefined)
+                    for (const c of cs.children)
+                        stack.push(c);
+            }
         }
         // Re-attach `child` for the fragment build, then detach it again.
-        parent.insertChild(child, idx);
-        const fragment = buildRemoveFragment(built.output, this.root, parent, child, built.available);
-        parent.removeChild(child);
+        pivot.insertChild(child, removedStart);
+        const fragment = buildRemoveFragment(built.output, this.root, pivot, child, built.available);
+        pivot.removeChild(child);
         if (fragment === null)
-            return false;
+            return null;
         // Apply: rebind survivors FIRST (so they stop reading the removed
         // fields), then `detach`, then adopt the next grammar.
-        for (const [field, rule] of fragment.rebinds)
-            built.runtime.rebindRule(field, rule);
-        built.runtime.detach(fragment.removed);
+        for (const [f, rule] of fragment.rebinds)
+            built.runtime.rebindRule(f, rule);
+        const dropped = built.runtime.detach(fragment.removed);
         built.output = fragment.next;
-        built.inputs = collectInputs(fragment.next.grammar, built.runtime);
-        built.snaps = captureSnaps(this.root);
-        const ix = indexFields(fragment.next);
-        built.fields = ix.fields;
-        built.owner = ix.owner;
-        // Pick up any value mutations in the same batch, then recompute.
-        this.applyAvailable(availableWidth, availableHeight);
-        for (const field of built.inputs) {
-            if (built.output.grammar.get(field).compute(NEVER_READ) !== built.runtime.evaluate(field)) {
-                built.runtime.markDirty(field);
+        // Incremental bookkeeping (Part C):
+        //
+        // `built.snaps` — update pivot's snap (children list changed) and
+        // drop the removed subtree's snaps.
+        built.snaps.set(pivot, freshSnap(pivot));
+        for (const n of removedNodes)
+            built.snaps.delete(n);
+        // `built.fields` / `built.owner` — drop the removed subtree's
+        // entries. Each removed node may have had `display: 'none'` (no
+        // entry) or normal layout fields — `built.fields.delete` on a
+        // missing key is harmless; `built.owner.delete` likewise.
+        for (const n of removedNodes) {
+            const lf = built.fields.get(n);
+            if (lf !== undefined) {
+                built.owner.delete(lf.width);
+                built.owner.delete(lf.height);
+                built.owner.delete(lf.left);
+                built.owner.delete(lf.top);
+                built.fields.delete(n);
             }
         }
-        built.runtime.recompute();
-        return true;
+        // `built.inputs` — remove every field detach dropped (the removed
+        // subtree's inputs + any survivor orphan-cleaned by detach).
+        // O(|dropped|) — detach's returned set is complete by construction:
+        // its `drop` closure is the single choke point for ALL removals,
+        // including orphan-cleaned surviving deps (e.g. the previous last
+        // child's now-unread main-end margin). Set.delete is a no-op for
+        // absent keys, so iterating all of `dropped` (which includes
+        // non-input layout fields) correctly removes only the dropped
+        // leaf inputs from `built.inputs`.
+        for (const f of dropped)
+            built.inputs.delete(f);
+        // Pick up any value mutations in the same batch, then recompute.
+        // Iterate ONLY the dirty nodes' inputs — every value mutation
+        // marks its node dirty.
+        this.applyAvailable(availableWidth, availableHeight);
+        this.markDriftedInputs(dirty);
+        const changed = built.runtime.recompute();
+        return { parent: pivot, changed };
     }
     /**
-     * Fast-path a structural change that is exactly one parent's
-     * children being reordered (a permutation — no node added or
-     * removed): `buildReorderFragment` + `rebindRule`, no whole-tree
-     * rebuild. Returns `false` (changing nothing) when the change is
-     * not a clean single-parent reorder — the caller then rebuilds.
+     * Fast-path a structural change that is exactly `pivot`'s children
+     * being reordered (a permutation — no node added or removed):
+     * `buildReorderFragment` + `rebindRule`, no whole-tree rebuild.
+     * Returns `null` (changing nothing) when the change is not a clean
+     * single-parent reorder — the caller then rebuilds.
+     *
+     * The classifier supplies `pivot` — the single node whose children
+     * list differs from its snap's. The validator inspects ONLY pivot's
+     * children, not the whole tree.
      */
-    tryReorder(availableWidth, availableHeight) {
+    tryReorder(pivot, dirty, availableWidth, availableHeight) {
         const built = this.built;
-        const snaps = built.snaps;
-        // The node set must be unchanged — no addition, no removal.
-        const curNodes = new Set();
-        (function visit(n) {
-            curNodes.add(n);
-            for (let i = 0; i < n.getChildCount(); i++)
-                visit(n.getChild(i));
-        })(this.root);
-        if (curNodes.size !== snaps.size)
-            return false;
-        for (const n of curNodes) {
-            if (!snaps.has(n))
-                return false;
-        }
-        // Every node's signature / measure must be unchanged, and exactly
-        // one node's child ORDER may differ — the reordered parent.
-        let reordered = null;
-        for (const [n, snap] of snaps) {
-            if (snap.sig !== nodeSig(n) || snap.measure !== n.getMeasureFunc())
-                return false;
-            if (!childrenUnchanged(snap, n)) {
-                if (reordered !== null)
-                    return false; // two changed parents — not one reorder
-                reordered = n;
-            }
-        }
-        if (reordered === null)
-            return false;
-        // `reordered`'s children must be a permutation of the snapped
-        // set (same count, same members) — otherwise it is an add/remove.
-        const before = snaps.get(reordered).children;
-        if (before.length !== reordered.getChildCount())
-            return false;
+        const snap = built.snaps.get(pivot);
+        // Pivot's children must be a permutation of the snapped set
+        // (same count, same members). Otherwise it is an add/remove —
+        // tryGraftAppend / tryDetachRemove would have caught it.
+        const before = snap.children;
+        if (before.length !== pivot.getChildCount())
+            return null;
         const beforeSet = new Set(before);
-        for (let i = 0; i < reordered.getChildCount(); i++) {
-            if (!beforeSet.has(reordered.getChild(i)))
-                return false;
+        for (let i = 0; i < pivot.getChildCount(); i++) {
+            if (!beforeSet.has(pivot.getChild(i)))
+                return null;
         }
         // A reorder inside a `display: 'none'` subtree touches no laid-out
         // node — the hidden region has no fields. Rebuild instead.
-        if (!built.fields.has(reordered))
-            return false;
-        const fragment = buildReorderFragment(built.output, this.root, reordered, built.available);
+        if (!built.fields.has(pivot))
+            return null;
+        const fragment = buildReorderFragment(built.output, this.root, pivot, built.available);
         // Order: integrate the newly-read inputs, rebind the rewritten
         // rules (their new deps are now all present), then detach the
         // inputs no rebound rule reads any more.
         built.runtime.graft(fragment.additions, fragment.newRoots);
-        for (const [field, rule] of fragment.rebinds)
-            built.runtime.rebindRule(field, rule);
+        for (const [f, rule] of fragment.rebinds)
+            built.runtime.rebindRule(f, rule);
         if (fragment.removed.length > 0)
             built.runtime.detach(fragment.removed);
         built.output = fragment.next;
-        built.inputs = collectInputs(fragment.next.grammar, built.runtime);
-        built.snaps = captureSnaps(this.root);
-        const ix = indexFields(fragment.next);
-        built.fields = ix.fields;
-        built.owner = ix.owner;
-        // Pick up any value mutations in the same batch, then recompute.
-        this.applyAvailable(availableWidth, availableHeight);
-        for (const field of built.inputs) {
-            if (built.output.grammar.get(field).compute(NEVER_READ) !== built.runtime.evaluate(field)) {
-                built.runtime.markDirty(field);
+        // Incremental bookkeeping (Part C):
+        //
+        // `built.snaps` — pivot's children list changed; everything else
+        // stayed put. Update just pivot's snap.
+        built.snaps.set(pivot, freshSnap(pivot));
+        // `built.fields` / `built.owner` — the same nodes own the same
+        // four layout fields they did before; no entry adds or drops.
+        // (Field identity is stable across grammar rebuilds.)
+        //
+        // `built.inputs` — a reorder can newly-track or newly-untrack
+        // sibling main-end margins (`additions` / `removed`). Update
+        // incrementally.
+        if (fragment.removed.length > 0) {
+            for (const f of fragment.removed)
+                built.inputs.delete(f);
+        }
+        for (const [f, rule] of fragment.additions) {
+            if (rule.deps.length === 0 && built.runtime.isTracked(f)) {
+                built.inputs.add(f);
             }
         }
-        built.runtime.recompute();
-        return true;
+        // Pick up any value mutations in the same batch, then recompute.
+        // Iterate ONLY the dirty nodes' inputs — every value mutation
+        // marks its node dirty.
+        this.applyAvailable(availableWidth, availableHeight);
+        this.markDriftedInputs(dirty);
+        const changed = built.runtime.recompute();
+        return { reordered: pivot, changed };
     }
     /**
      * Value relayout: re-`markDirty` only the input Fields of the dirty
      * nodes (plus the root `available:*` inputs) whose value drifted,
      * then `recompute()`. Returns the maximal subtree roots whose
-     * layout moved — for `finishIncremental` to write back.
+     * layout moved — for `finishMoved` to write back.
      */
     relayoutValues(dirty, availableWidth, availableHeight) {
-        const built = this.built;
         this.applyAvailable(availableWidth, availableHeight);
+        this.markDriftedInputs(dirty);
+        return this.movedSubtreeRoots(this.built.runtime.recompute());
+    }
+    /**
+     * Re-`markDirty` only the input Fields of the dirty nodes (plus the
+     * root `available:*` inputs) whose live value drifted from the
+     * runtime's stored value. Shared by every relayout path — the value
+     * relayout and all three structural fast-paths.
+     *
+     * Iterates O(dirty inputs), not O(built.inputs) — every value
+     * mutation marks its owning node dirty, so non-dirty nodes can't
+     * have drifted inputs.
+     */
+    markDriftedInputs(dirty) {
+        const built = this.built;
         const fields = [];
         if (built.output.availableInputs.width !== undefined) {
             fields.push(built.output.availableInputs.width);
@@ -604,27 +725,48 @@ export class SpinelessLayout {
         for (const n of dirty)
             inputFieldsOf(built.output.styleInputs.get(n), fields);
         const { runtime, output } = built;
-        for (const field of fields) {
+        for (const f of fields) {
             // `styleInputs` can hold an input Field no rule reads (e.g. a
             // flex-start container's main-END padding) — untracked, and a
             // change to it cannot move any layout field. Skip it.
-            if (!runtime.isTracked(field))
+            if (!runtime.isTracked(f))
                 continue;
-            const live = output.grammar.get(field).compute(NEVER_READ);
-            if (live !== runtime.evaluate(field))
-                runtime.markDirty(field);
+            const live = output.grammar.get(f).compute(NEVER_READ);
+            if (live !== runtime.evaluate(f))
+                runtime.markDirty(f);
+        }
+    }
+    /** Push new `available` values into the holder the grammar closes over. */
+    applyAvailable(availableWidth, availableHeight) {
+        const a = this.built.available;
+        if (availableWidth !== undefined)
+            a.width = availableWidth;
+        if (availableHeight !== undefined)
+            a.height = availableHeight;
+    }
+    /** Write-back + round + scroll the whole tree (after a build / graft). */
+    finishWhole() {
+        const { runtime, output } = this.built;
+        for (const f of output.allFields) {
+            writeNode(f.node, runtime, { width: f.width, height: f.height, left: f.left, top: f.top });
         }
-        // The changed layout Fields name the nodes whose box moved.
-        const changed = runtime.recompute();
+        roundLayout(this.root);
+        recordScrollSizes(this.root);
+        clearDirtyDeep(this.root);
+    }
+    /**
+     * Reduce a set of changed Fields to the maximal moved-subtree roots.
+     * Used by the structural fast-paths to determine which subtrees need
+     * write-back after an incremental recompute.
+     */
+    movedSubtreeRoots(changed) {
+        const built = this.built;
         const moved = new Set();
         for (const f of changed) {
             const n = built.owner.get(f);
             if (n !== undefined)
                 moved.add(n);
         }
-        // Keep only the maximal moved subtree roots — a moved node with
-        // no moved ancestor. Re-rounding such a root covers its whole
-        // (shifted) subtree.
         const roots = [];
         for (const n of moved) {
             let maximal = true;
@@ -639,31 +781,17 @@ export class SpinelessLayout {
         }
         return roots;
     }
-    /** Push new `available` values into the holder the grammar closes over. */
-    applyAvailable(availableWidth, availableHeight) {
-        const a = this.built.available;
-        if (availableWidth !== undefined)
-            a.width = availableWidth;
-        if (availableHeight !== undefined)
-            a.height = availableHeight;
-    }
-    /** Write-back + round + scroll the whole tree (after a build / graft). */
-    finishWhole() {
-        const { runtime, output } = this.built;
-        for (const f of output.allFields) {
-            writeNode(f.node, runtime, { width: f.width, height: f.height, left: f.left, top: f.top });
-        }
-        roundLayout(this.root);
-        recordScrollSizes(this.root);
-        clearDirtyDeep(this.root);
-    }
     /**
      * Write-back + round + scroll, scoped to the subtrees that moved.
      * A moved subtree's parent did not move, so its rounding is stable
      * and the subtree can be re-rounded in isolation; only that
      * parent's own scroll extent then needs a recompute.
+     *
+     * `extraScrollParents` are additional nodes whose scroll extents
+     * must be recomputed — used by structural fast-paths to include
+     * the surviving parent of a removed or reordered subtree.
      */
-    finishIncremental(roots) {
+    finishMoved(roots, extraScrollParents) {
         const { runtime, fields } = this.built;
         for (const root of roots) {
             // Write the float layout for the whole moved subtree, so the
@@ -694,6 +822,8 @@ export class SpinelessLayout {
             if (p !== null)
                 scrollParents.add(p);
         }
+        for (const p of extraScrollParents)
+            scrollParents.add(p);
         for (const p of scrollParents)
             recomputeScroll(p);
     }
@@ -752,4 +882,12 @@ function recomputeScroll(node) {
     node._layout.scrollWidth = Math.max(node._layout.width, contentRight);
     node._layout.scrollHeight = Math.max(node._layout.height, contentBottom);
 }
+/** True iff `candidate` is `root` or a descendant of `root`. */
+function isInSubtree(candidate, root) {
+    for (let n = candidate; n !== null; n = n.getParent()) {
+        if (n === root)
+            return true;
+    }
+    return false;
+}
 //# sourceMappingURL=layout.js.map