@pilates/core 1.0.0 → 1.1.0

package/dist/algorithm/spineless/layout.js

@@ -0,0 +1,755 @@
+/**
+ * `SpinelessLayout` — drives the Spineless incremental layout engine
+ * as a `calculateLayout`-equivalent (phase 8).
+ *
+ * The grammar (`buildFlexGrammar`) + runtime (`SpinelessRuntime`)
+ * compute each node's `{width, height, left, top}` in floating-point
+ * space; this driver writes those into `node._layout`, then runs
+ * integer-cell rounding and a scroll-extent pass — mirroring the
+ * tail of the imperative `calculateLayoutImpl`.
+ *
+ * The driver persists the grammar + runtime between `layout()` calls
+ * and keeps every step incremental:
+ *
+ *   - DETECTION (v22) — the `Node` dirty flags scope change detection
+ *     to the mutated region.
+ *   - VALUE relayout — `recompute()` reports the fields it changed;
+ *     write-back, rounding and scroll-extents (v23) touch only the
+ *     subtrees whose layout actually moved.
+ *   - GRAFT relayout (v21) — a single child append patches the
+ *     runtime via `buildAppendFragment` + `graft`.
+ *   - full REBUILD — any other structural change.
+ *
+ * @internal
+ */
+import { roundLayout, roundLayoutFrom } from '../round.js';
+import { buildAppendFragment, buildFlexGrammar, buildRemoveFragment, buildReorderFragment, } from './flex-grammar.js';
+import { SpinelessRuntime } from './runtime.js';
+/** An input field's `compute` never calls `read` — guard against it. */
+const NEVER_READ = () => {
+    throw new Error('[spineless-layout] an input field compute must not 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);
+    }
+    return inputs;
+}
+/** The leaf input Fields a single node owns (its style inputs). */
+function inputFieldsOf(entry, out) {
+    if (entry === undefined)
+        return;
+    for (const k of [
+        'width',
+        'height',
+        'flexBasis',
+        'flexGrow',
+        'flexShrink',
+        'gapRow',
+        'gapColumn',
+        'minWidth',
+        'minHeight',
+        'maxWidth',
+        'maxHeight',
+    ]) {
+        const f = entry[k];
+        if (f !== undefined)
+            out.push(f);
+    }
+    for (const k of ['padding', 'margin']) {
+        const arr = entry[k];
+        if (arr === undefined)
+            continue;
+        for (const f of arr)
+            if (f !== undefined)
+                out.push(f);
+    }
+}
+/** The structural signature of one node — see `NodeSnap`. */
+function nodeSig(node) {
+    const s = node.style;
+    return [
+        s.flexDirection,
+        s.flexWrap,
+        s.justifyContent,
+        s.alignItems,
+        s.alignContent,
+        s.alignSelf,
+        s.positionType,
+        s.display,
+        typeof s.width,
+        typeof s.height,
+        typeof s.flexBasis,
+        // Only the zero / positive BOUNDARY of a flex weight is
+        // structural (it flips `parentNeedsFlexDistribution`); a
+        // positive → positive tweak stays an incremental value change.
+        s.flexGrow > 0 ? 'g' : '_',
+        s.flexShrink > 0 ? 's' : '_',
+        // `aspectRatio` is captured by value at build time, so any
+        // change to it needs a rebuild.
+        s.aspectRatio === undefined ? 'n' : String(s.aspectRatio),
+        // Absolute children capture their `position` edges by value.
+        s.position
+            .map((p) => (p === undefined ? '_' : String(p)))
+            .join(','),
+    ].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);
+    return snaps;
+}
+/** True iff `node`'s current child list still matches `snap.children`. */
+function childrenUnchanged(snap, node) {
+    if (node.getChildCount() !== snap.children.length)
+        return false;
+    for (let i = 0; i < snap.children.length; i++) {
+        if (node.getChild(i) !== snap.children[i])
+            return false;
+    }
+    return true;
+}
+/**
+ * Collect every dirty node — descending only into subtrees the dirty
+ * flags say contain a change, so the walk is O(dirty region).
+ */
+function collectDirty(node, out) {
+    const dirty = node.isDirty();
+    if (dirty)
+        out.push(node);
+    if (dirty || node._hasDirtyDescendant) {
+        for (let i = 0; i < node.getChildCount(); i++)
+            collectDirty(node.getChild(i), out);
+    }
+}
+/** Clear the dirty flags over the same region `collectDirty` walks. */
+function clearDirtyRegion(node) {
+    if (!node.isDirty() && !node._hasDirtyDescendant)
+        return;
+    node.clearDirty();
+    for (let i = 0; i < node.getChildCount(); i++)
+        clearDirtyRegion(node.getChild(i));
+}
+function clearDirtyDeep(node) {
+    node.clearDirty();
+    for (let i = 0; i < node.getChildCount(); i++)
+        clearDirtyDeep(node.getChild(i));
+}
+/** Build the `fields` / `owner` indexes from a `FlexGrammarOutput`. */
+function indexFields(output) {
+    const fields = new Map();
+    const owner = new Map();
+    for (const f of output.allFields) {
+        fields.set(f.node, { width: f.width, height: f.height, left: f.left, top: f.top });
+        owner.set(f.width, f.node);
+        owner.set(f.height, f.node);
+        owner.set(f.left, f.node);
+        owner.set(f.top, f.node);
+    }
+    return { fields, owner };
+}
+/**
+ * A layout driver bound to one root `Node`. Call `layout()` to
+ * produce a layout byte-equivalent to imperative `calculateLayout`;
+ * repeat calls reuse the runtime, relaying incrementally.
+ *
+ * @internal
+ */
+export class SpinelessLayout {
+    root;
+    built = null;
+    /** Build / relayout counters — for tests and diagnostics. */
+    stats = {
+        fullBuilds: 0,
+        incrementalRelayouts: 0,
+        graftRelayouts: 0,
+        detachRelayouts: 0,
+        reorderRelayouts: 0,
+    };
+    /** What the most recent `layout()` call did (phase 9). */
+    _lastTrace = null;
+    constructor(root) {
+        this.root = root;
+    }
+    /** The `LayoutTrace` of the most recent `layout()` call, or `null`
+     *  if `layout()` has not run yet. */
+    get lastTrace() {
+        return this._lastTrace;
+    }
+    /**
+     * Lay the tree out. `availableWidth` / `availableHeight` size an
+     * `'auto'` root, matching `calculateLayout`'s availability args.
+     */
+    layout(availableWidth, availableHeight) {
+        // `available` PRESENCE (defined vs not) is structural — it
+        // selects the root size rule shape (`rootAxisIsBareZero`).
+        const samePresence = this.built !== null &&
+            (this.built.available.width !== undefined) === (availableWidth !== undefined) &&
+            (this.built.available.height !== undefined) === (availableHeight !== undefined);
+        if (!samePresence) {
+            this.fullBuild(availableWidth, availableHeight);
+            this.stats.fullBuilds++;
+            this.finishWhole();
+            return;
+        }
+        // Classify the dirty region: any structural change forces the
+        // graft / rebuild paths; otherwise it is a pure value relayout.
+        const dirty = [];
+        collectDirty(this.root, dirty);
+        const snaps = this.built.snaps;
+        let structural = 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;
+                break;
+            }
+        }
+        if (!structural) {
+            const moved = this.relayoutValues(dirty, availableWidth, availableHeight);
+            this.stats.incrementalRelayouts++;
+            const rs = this.built.runtime.stats;
+            this._lastTrace = {
+                path: 'incremental',
+                dirtyNodes: dirty.length,
+                fieldsRecomputed: rs.recomputeVisited,
+                fieldsChanged: rs.recomputeChanged,
+                movedSubtrees: moved.length,
+            };
+            this.finishIncremental(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++;
+        }
+        this.finishWhole();
+    }
+    /** Discard any persisted state and build the grammar afresh. */
+    fullBuild(availableWidth, availableHeight) {
+        const available = {};
+        if (availableWidth !== undefined)
+            available.width = availableWidth;
+        if (availableHeight !== undefined)
+            available.height = availableHeight;
+        const output = buildFlexGrammar(this.root, available);
+        const rootFields = [];
+        for (const f of output.allFields) {
+            rootFields.push(f.width, f.height, f.left, f.top);
+        }
+        const runtime = new SpinelessRuntime(output.grammar, rootFields);
+        runtime.init();
+        this.built = {
+            available,
+            output,
+            runtime,
+            inputs: collectInputs(output.grammar, runtime),
+            snaps: captureSnaps(this.root),
+            ...indexFields(output),
+        };
+        // A build computes every Field once during `init` (counted by
+        // `runtime.stats.initFields`) — it runs no `recompute()`, so the
+        // recompute-derived trace counts are all zero.
+        this._lastTrace = {
+            path: 'build',
+            dirtyNodes: 0,
+            fieldsRecomputed: 0,
+            fieldsChanged: 0,
+            movedSubtrees: 0,
+        };
+    }
+    /**
+     * 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.
+     */
+    tryGraftAppend(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;
+            }
+        }
+        if (child === null)
+            return false;
+        const parent = child.getParent();
+        if (parent === null)
+            return false;
+        // 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 (fragment === null)
+            return false;
+        built.runtime.graft(fragment.additions, fragment.newRoots);
+        for (const [field, rule] of fragment.rebinds)
+            built.runtime.rebindRule(field, 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);
+            }
+        }
+        built.runtime.recompute();
+        return true;
+    }
+    /**
+     * 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.
+     *
+     * `buildRemoveFragment` must see the removed `child` still attached
+     * (its regime check reads the parent's live child list and it walks
+     * the subtree for the fields to detach), but by the time `layout()`
+     * 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.
+     */
+    tryDetachRemove(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;
+        // 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++;
+        }
+        // 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);
+        if (fragment === null)
+            return false;
+        // 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);
+        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);
+            }
+        }
+        built.runtime.recompute();
+        return true;
+    }
+    /**
+     * 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.
+     */
+    tryReorder(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 beforeSet = new Set(before);
+        for (let i = 0; i < reordered.getChildCount(); i++) {
+            if (!beforeSet.has(reordered.getChild(i)))
+                return false;
+        }
+        // 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);
+        // 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);
+        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);
+            }
+        }
+        built.runtime.recompute();
+        return true;
+    }
+    /**
+     * 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.
+     */
+    relayoutValues(dirty, availableWidth, availableHeight) {
+        const built = this.built;
+        this.applyAvailable(availableWidth, availableHeight);
+        const fields = [];
+        if (built.output.availableInputs.width !== undefined) {
+            fields.push(built.output.availableInputs.width);
+        }
+        if (built.output.availableInputs.height !== undefined) {
+            fields.push(built.output.availableInputs.height);
+        }
+        for (const n of dirty)
+            inputFieldsOf(built.output.styleInputs.get(n), fields);
+        const { runtime, output } = built;
+        for (const field 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))
+                continue;
+            const live = output.grammar.get(field).compute(NEVER_READ);
+            if (live !== runtime.evaluate(field))
+                runtime.markDirty(field);
+        }
+        // The changed layout Fields name the nodes whose box moved.
+        const changed = runtime.recompute();
+        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;
+            for (let p = n.getParent(); p !== null; p = p.getParent()) {
+                if (moved.has(p)) {
+                    maximal = false;
+                    break;
+                }
+            }
+            if (maximal)
+                roots.push(n);
+        }
+        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.
+     */
+    finishIncremental(roots) {
+        const { runtime, fields } = this.built;
+        for (const root of roots) {
+            // Write the float layout for the whole moved subtree, so the
+            // re-round below has float values throughout.
+            const stack = [root];
+            while (stack.length > 0) {
+                const n = stack.pop();
+                // A `display: 'none'` node has no grammar fields — the
+                // emitter skips it (v29). Skip it (and its subtree) here too,
+                // mirroring `finishWhole`, which writes only `allFields`.
+                const f = fields.get(n);
+                if (f === undefined)
+                    continue;
+                writeNode(n, runtime, f);
+                for (let i = 0; i < n.getChildCount(); i++)
+                    stack.push(n.getChild(i));
+            }
+            const pos = ancestorPositions(root);
+            roundLayoutFrom(root, pos.floatX, pos.floatY, pos.roundedX, pos.roundedY);
+            recordScrollSizes(root);
+        }
+        // A moved root's parent did not move, so `recordScrollSizes`
+        // above never touched it — but one of its children's box did
+        // change, so its own scroll extent needs a recompute.
+        const scrollParents = new Set();
+        for (const root of roots) {
+            const p = root.getParent();
+            if (p !== null)
+                scrollParents.add(p);
+        }
+        for (const p of scrollParents)
+            recomputeScroll(p);
+    }
+}
+/** Write one node's evaluated float layout into `_layout`. */
+function writeNode(node, runtime, f) {
+    const left = runtime.evaluate(f.left);
+    const top = runtime.evaluate(f.top);
+    node._layout.left = left;
+    node._layout.top = top;
+    node._layout.width = runtime.evaluate(f.width);
+    node._layout.height = runtime.evaluate(f.height);
+    node._floatLeft = left;
+    node._floatTop = top;
+}
+/**
+ * The float and rounded absolute position of `node`'s parent — the
+ * origin `roundLayoutFrom` needs to re-round the `node` subtree. The
+ * ancestors did not move, so their `_floatLeft/Top` (float) and
+ * `_layout.left/top` (rounded) are still current.
+ */
+function ancestorPositions(node) {
+    let floatX = 0;
+    let floatY = 0;
+    let roundedX = 0;
+    let roundedY = 0;
+    for (let a = node.getParent(); a !== null; a = a.getParent()) {
+        floatX += a._floatLeft;
+        floatY += a._floatTop;
+        roundedX += a._layout.left;
+        roundedY += a._layout.top;
+    }
+    return { floatX, floatY, roundedX, roundedY };
+}
+/**
+ * Post-order walk recording each node's content bounding box on
+ * `_layout.scrollWidth` / `scrollHeight`. Mirrors the scroll-extent
+ * half of `calculateLayoutImpl`'s `computeScrollSizes` — without the
+ * imperative layout-cache writes, which belong to the imperative
+ * path only.
+ */
+function recordScrollSizes(node) {
+    for (let i = 0; i < node.getChildCount(); i++)
+        recordScrollSizes(node.getChild(i));
+    recomputeScroll(node);
+}
+/** Recompute one node's scroll extent from its direct children's boxes. */
+function recomputeScroll(node) {
+    let contentRight = 0;
+    let contentBottom = 0;
+    for (let i = 0; i < node.getChildCount(); i++) {
+        const cl = node.getChild(i)._layout;
+        contentRight = Math.max(contentRight, cl.left + cl.width);
+        contentBottom = Math.max(contentBottom, cl.top + cl.height);
+    }
+    node._layout.scrollWidth = Math.max(node._layout.width, contentRight);
+    node._layout.scrollHeight = Math.max(node._layout.height, contentBottom);
+}
+//# sourceMappingURL=layout.js.map