@pilates/core 1.0.1 → 1.1.0

package/dist/algorithm/spineless/runtime.js

@@ -0,0 +1,458 @@
+/**
+ * Spineless Traversal runtime — incremental driver for an attribute
+ * grammar (Kirisame, Wang, Panchekha — PLDI 2025).
+ *
+ * Combines the three foundational primitives:
+ *   - `BenderOrderMaintenance` (OM) — assigns a stable, totally-
+ *     ordered timestamp to every field at first computation. Topo
+ *     order at init time => OM order forever, even after relabel.
+ *   - `OmPriorityQueue<Field>` — keyed on the field's OM node.
+ *     Popping the minimum returns the next field to recompute in
+ *     topological order, without any explicit DAG walks.
+ *   - `Grammar` — declarative `field -> rule(deps, compute)` map.
+ *     The runtime queries it on every recompute.
+ *
+ * ## Phases
+ *
+ * **Init** (`init()`): one full pass over the grammar from the
+ * supplied root fields. DFS in topological order; for each field,
+ * allocate an OM node (`om.insertAfter(prev)`), record the
+ * reverse-deps edges so dependents can be scheduled later, then run
+ * the field's compute and cache the value. After init, every
+ * reachable field has a (timestamp, value, dependents-list) triple
+ * in the runtime's storage.
+ *
+ * **Recompute** (`markDirty(field)` + `recompute()`): callers mark
+ * the fields whose inputs changed. Each dirty field is enqueued
+ * (`pq.push(field, omNode)`). `recompute()` loops: pop the
+ * OM-minimum field, re-run its rule. If the new value differs from
+ * the cached one, persist it and push every dependent. Process
+ * stops when the queue is empty.
+ *
+ * **Termination** rests on the dependency graph being acyclic: each
+ * field's value is a function of finitely many others, so the
+ * worklist reaches the DAG's unique fixpoint in finitely many
+ * steps. When the OM order is a true topological order — as it is
+ * after `init` and pure-additive `graft` — every field recomputes
+ * exactly once (a dependent always pops after its deps), giving the
+ * O(affected) Spineless bound. After a `rebindRule` an existing
+ * field may gain a dependency on a later-OM field; recompute stays
+ * correct and terminating, but such a field may recompute a bounded
+ * number of extra times. OM order is thus a performance property,
+ * not a correctness one.
+ *
+ * **Value preservation under no-op recompute:** if a field's rule
+ * produces the same value as before, its dependents are NOT
+ * scheduled. This is the key "skip work" property of Spineless.
+ *
+ * **Graft** (`graft(additions, newRoots)`): incremental structural
+ * growth (phase 5c). New fields whose topological position is at the
+ * tail — they may read existing fields, but no existing field reads
+ * them and no existing rule changes — are spliced in without a
+ * rebuild: each gets an OM node appended after the current tail, its
+ * reverse-dependency edges recorded, and its value computed once.
+ * This is exactly the shape of appending a child to a parent in the
+ * "simple" regime.
+ *
+ * **Detach** (`detach(fields)`): the inverse of `graft` — drops a
+ * removed subtree's fields, freeing their OM nodes and pruning the
+ * reverse-dependency edges into surviving fields. Valid when the
+ * removed set is closed under "is read by" (nothing outside reads
+ * in), which holds for removing a last child in the simple regime.
+ * Surviving leaf-input fields the removed set was the sole reader of
+ * are dropped too — the caller passes only the subtree's own fields.
+ *
+ * **Rebind** (`rebindRule(field, newRule)`): replace an existing
+ * field's rule — used when a structural change rewrites a surviving
+ * field (e.g. appending into a flex-distributing parent grows every
+ * sibling's flex-distribution dependency set). The reverse-
+ * dependency edges are updated to the new dep set and the field is
+ * marked dirty. New deps may have a later OM than the field — see
+ * the termination note above.
+ *
+ * ## What this runtime does NOT cover
+ *
+ * - Regime-changing structural mutation. `graft` only adds pure
+ *   topological-tail fields; appending into a flex-distributing /
+ *   justified / wrapping parent also rewrites existing siblings'
+ *   rules, and removal / direction flips re-key subtrees — later
+ *   phase-5c slices.
+ * - Differential mode against the imperative algorithm. The
+ *   correctness oracle for the runtime is the `TopoInterpreter`
+ *   running over the same grammar — once both agree, the grammar's
+ *   existing differential coverage carries through.
+ *
+ * @internal
+ */
+import { BenderOrderMaintenance } from './order-maintenance.js';
+import { OmPriorityQueue } from './priority-queue.js';
+/**
+ * @internal
+ */
+export class SpinelessRuntime {
+    grammar;
+    rootFields;
+    om;
+    pq;
+    /** field -> cached value */
+    values = new Map();
+    /** field -> its OM timestamp (allocated in topo order at init) */
+    omNodes = new Map();
+    /** field -> fields that read this field (reverse of `rule.deps`) */
+    dependents = new Map();
+    /** The OM node at the topological tail — where `graft` appends. */
+    lastOm = null;
+    initDone = false;
+    /**
+     * Recompute counters — for observability (phase 9). Plain integer
+     * fields, bumped on the existing `integrate` / `recompute` loops,
+     * so they cost nothing measurable and need no enable flag.
+     */
+    stats = {
+        /** Fields integrated so far — the `init` pass plus every `graft`. */
+        initFields: 0,
+        /** Fields popped from the PQ by the most recent `recompute()`. */
+        recomputeVisited: 0,
+        /** Of those, Fields whose value actually changed. */
+        recomputeChanged: 0,
+        /** Cumulative Fields visited across every `recompute()` since init. */
+        totalVisited: 0,
+    };
+    constructor(grammar, rootFields, om = new BenderOrderMaintenance()) {
+        this.grammar = grammar;
+        this.rootFields = rootFields;
+        this.om = om;
+        this.pq = new OmPriorityQueue(om);
+    }
+    /**
+     * Walk the grammar in topological order, allocate an OM node per
+     * field, cache initial values, and record reverse-dependents. Must
+     * be called once before any `evaluate` / `markDirty` / `recompute`.
+     */
+    init() {
+        this.integrate(this.rootFields);
+        this.initDone = true;
+    }
+    /**
+     * Integrate new fields into an already-`init`ed runtime without a
+     * rebuild (phase 5c). `additions` holds the rules for the new
+     * fields only — it throws if any field is already present, since
+     * redefining an existing field is a rule *change*, not a graft.
+     * `newRoots` are the new fields to start the topological DFS from
+     * (their existing-field dependencies are reached as boundaries).
+     *
+     * Correct **iff** the new fields are pure topological-tail
+     * additions: no existing field reads a new field, and no existing
+     * rule needed to change. The caller guarantees this — it holds by
+     * construction when appending a last child to a parent in the
+     * simple regime (no flex distribution, default `justify`, no
+     * wrap). The new fields are computed with correct inputs during
+     * the graft, so no `markDirty` / `recompute` is needed afterward.
+     */
+    graft(additions, newRoots) {
+        if (!this.initDone) {
+            throw new Error('[spineless-runtime] graft called before init()');
+        }
+        for (const [f, rule] of additions) {
+            if (this.omNodes.has(f)) {
+                throw new Error(`[spineless-runtime] graft: field "${f.name}" already exists — graft integrates NEW fields only`);
+            }
+            this.grammar.set(f, rule);
+        }
+        this.integrate(newRoots);
+    }
+    /**
+     * Remove fields from an already-`init`ed runtime without a rebuild
+     * (phase 5c) — the inverse of `graft`. `fields` is the exact set
+     * to drop (a removed subtree's fields). For each: its OM node is
+     * freed, its cached value and reverse-dependency list dropped, its
+     * rule deleted from the grammar, and it is pruned from the
+     * reverse-dependency list of every field it read.
+     *
+     * Throws if any removed field still has a dependent *outside* the
+     * removed set — detaching it would dangle that edge. The caller
+     * guarantees a clean cut: it holds by construction when removing a
+     * last child from a parent in the simple regime (nothing outside
+     * that subtree reads into it). No `recompute` is needed afterward —
+     * removing a topological-tail subtree changes no surviving field.
+     *
+     * After the cut, any surviving leaf-input field the removed set was
+     * the sole reader of is **orphaned** — nothing reads it and the
+     * grammar cannot re-read it without a fresh build. Such orphans are
+     * dropped too (a leaf has no dependencies, so this cannot cascade).
+     * That makes the caller's removed set just the subtree's own
+     * fields — orphan input fields, e.g. the previous last child's
+     * now-unread main-end margin, need not be enumerated.
+     */
+    detach(fields) {
+        if (!this.initDone) {
+            throw new Error('[spineless-runtime] detach called before init()');
+        }
+        const removing = new Set(fields);
+        // Precondition: the removed set must be closed under "is read by"
+        // — no surviving field may depend on a removed one.
+        for (const f of removing) {
+            const revs = this.dependents.get(f);
+            if (revs === undefined)
+                continue;
+            for (const d of revs) {
+                if (!removing.has(d)) {
+                    throw new Error(`[spineless-runtime] detach: field "${f.name}" still has dependent "${d.name}" outside the removed set`);
+                }
+            }
+        }
+        // Surviving fields the removed set read — candidates for orphan
+        // cleanup once their reverse-dependency lists are pruned.
+        const survivingDeps = new Set();
+        const drop = (f) => {
+            const omNode = this.omNodes.get(f);
+            if (omNode !== undefined)
+                this.om.delete(omNode);
+            this.omNodes.delete(f);
+            this.values.delete(f);
+            this.dependents.delete(f);
+            this.grammar.delete(f);
+        };
+        for (const f of removing) {
+            // Prune `f` from the reverse-dependency list of each field it
+            // read (a surviving dep must forget this removed dependent).
+            const rule = this.grammar.get(f);
+            if (rule !== undefined) {
+                for (const dep of rule.deps) {
+                    const revs = this.dependents.get(dep);
+                    if (revs !== undefined) {
+                        const i = revs.indexOf(f);
+                        if (i !== -1)
+                            revs.splice(i, 1);
+                    }
+                    if (!removing.has(dep))
+                        survivingDeps.add(dep);
+                }
+            }
+            drop(f);
+        }
+        // Orphan cleanup: a surviving dep with no dependents left, whose
+        // own rule is a leaf (no dependencies), is now dead weight.
+        for (const dep of survivingDeps) {
+            const revs = this.dependents.get(dep);
+            if (revs !== undefined && revs.length > 0)
+                continue;
+            const rule = this.grammar.get(dep);
+            if (rule === undefined || rule.deps.length > 0)
+                continue;
+            drop(dep);
+        }
+        // The OM tail may have been among the removed fields; recompute
+        // it so a later `graft` still appends after every surviving node.
+        this.lastOm = null;
+        for (const omNode of this.omNodes.values()) {
+            if (this.lastOm === null || this.om.compare(omNode, this.lastOm) > 0) {
+                this.lastOm = omNode;
+            }
+        }
+    }
+    /**
+     * Replace the rule of an already-integrated field (phase 5c) — for
+     * a structural change that rewrites a *surviving* field rather than
+     * adding or removing one. Appending a child into a flex-distributing
+     * parent, for instance, grows every existing sibling's
+     * flex-distribution dependency set.
+     *
+     * The reverse-dependency edges are repaired to match the new dep
+     * set (the field is dropped from the lists of deps it no longer
+     * reads and added to the lists of deps it now reads), the new rule
+     * is installed, and the field is marked dirty so the next
+     * `recompute()` re-runs it. Every new dependency must already be
+     * integrated. The field keeps its OM node; if a new dependency has
+     * a later OM, recompute stays correct (see the termination note on
+     * the class) at the cost of a bounded number of extra recomputes.
+     */
+    rebindRule(field, newRule) {
+        if (!this.initDone) {
+            throw new Error('[spineless-runtime] rebindRule called before init()');
+        }
+        if (!this.omNodes.has(field)) {
+            throw new Error(`[spineless-runtime] rebindRule: field "${field.name}" is not in this runtime`);
+        }
+        const oldRule = this.grammar.get(field);
+        const oldDeps = new Set(oldRule?.deps ?? []);
+        const newDeps = new Set(newRule.deps);
+        // Deps no longer read: drop `field` from their dependents list.
+        for (const d of oldDeps) {
+            if (newDeps.has(d))
+                continue;
+            const revs = this.dependents.get(d);
+            if (revs !== undefined) {
+                const i = revs.indexOf(field);
+                if (i !== -1)
+                    revs.splice(i, 1);
+            }
+        }
+        // Newly read deps: register the reverse edge.
+        for (const d of newDeps) {
+            if (oldDeps.has(d))
+                continue;
+            if (!this.omNodes.has(d)) {
+                throw new Error(`[spineless-runtime] rebindRule: new dependency "${d.name}" of "${field.name}" is not integrated`);
+            }
+            let revs = this.dependents.get(d);
+            if (revs === undefined) {
+                revs = [];
+                this.dependents.set(d, revs);
+            }
+            revs.push(field);
+        }
+        this.grammar.set(field, newRule);
+        this.markDirty(field);
+    }
+    /**
+     * Topological DFS shared by `init` and `graft`. For every
+     * not-yet-integrated field reachable from `roots`: recurse into
+     * deps, record reverse-dependency edges, allocate an OM node after
+     * the current tail, run the rule, and cache the value. Fields that
+     * already have an OM node are boundaries — visited, edge recorded,
+     * not re-walked.
+     */
+    integrate(roots) {
+        const visiting = new Set();
+        const visit = (f) => {
+            // A field has an OM node exactly once it is integrated, so
+            // `omNodes` doubles as the "already done" marker — which makes
+            // existing fields natural boundaries during a graft.
+            if (this.omNodes.has(f))
+                return;
+            if (visiting.has(f)) {
+                throw new Error(`[spineless-runtime] cycle detected: field "${f.name}" depends on itself transitively`);
+            }
+            visiting.add(f);
+            const rule = this.grammar.get(f);
+            if (rule === undefined) {
+                throw new Error(`[spineless-runtime] no rule for field "${f.name}". Register it in the grammar or remove the dep edge.`);
+            }
+            for (const dep of rule.deps) {
+                visit(dep);
+                let revs = this.dependents.get(dep);
+                if (revs === undefined) {
+                    revs = [];
+                    this.dependents.set(dep, revs);
+                }
+                revs.push(f);
+            }
+            // Allocate the OM node at the topological tail. The OM is empty
+            // before the very first field, then chains insertAfter.
+            const omNode = this.lastOm === null ? this.om.init() : this.om.insertAfter(this.lastOm);
+            this.lastOm = omNode;
+            this.omNodes.set(f, omNode);
+            this.stats.initFields++;
+            // Compute and cache.
+            this.values.set(f, this.runCompute(f, rule));
+            visiting.delete(f);
+        };
+        for (const root of roots)
+            visit(root);
+    }
+    /**
+     * Read the current cached value of a field. Throws if the field
+     * wasn't reachable from any root during `init` (so no cache entry
+     * exists).
+     */
+    evaluate(field) {
+        if (!this.values.has(field)) {
+            throw new Error(`[spineless-runtime] field "${field.name}" was not computed in init() — it isn't reachable from any root`);
+        }
+        return this.values.get(field);
+    }
+    /**
+     * Whether `field` is currently tracked by the runtime — integrated
+     * and not since detached. A caller holding a possibly-stale field
+     * reference (e.g. an input field orphaned by a `detach`) can check
+     * this before `markDirty`.
+     */
+    isTracked(field) {
+        return this.omNodes.has(field);
+    }
+    /**
+     * Mark every field tracked by this runtime as dirty. Useful as an
+     * escape hatch when callers don't have fine-grained style-mutation
+     * wiring yet: mutate styles, call `markAllDirty()`, then
+     * `recompute()`. Each field re-runs its rule once, but the "skip
+     * dependents when value unchanged" property still applies — so
+     * cost is one compute per field plus propagation only along
+     * actually-changed values, rather than a full re-init.
+     */
+    markAllDirty() {
+        if (!this.initDone) {
+            throw new Error('[spineless-runtime] markAllDirty called before init()');
+        }
+        for (const [field, omNode] of this.omNodes) {
+            this.pq.push(field, omNode);
+        }
+    }
+    /**
+     * Mark a field as dirty. Its rule will be re-run on the next
+     * `recompute()`. If the new value differs from the cached one,
+     * dependents are scheduled in turn.
+     *
+     * Duplicate calls are a no-op (the priority queue dedupes via its
+     * internal membership set).
+     */
+    markDirty(field) {
+        if (!this.initDone) {
+            throw new Error('[spineless-runtime] markDirty called before init()');
+        }
+        const om = this.omNodes.get(field);
+        if (om === undefined) {
+            throw new Error(`[spineless-runtime] field "${field.name}" is not in this runtime — call markDirty only on fields reachable from a root at init`);
+        }
+        this.pq.push(field, om);
+    }
+    /**
+     * Process all dirty fields. Pops in OM (= topological) order; runs
+     * each field's rule. If the result differs from the cached value,
+     * persists it and pushes every dependent so it gets re-run later in
+     * this same pass.
+     *
+     * Returns every field whose value actually changed — the caller
+     * uses it to scope an incremental write-back to the moved nodes.
+     */
+    recompute() {
+        if (!this.initDone) {
+            throw new Error('[spineless-runtime] recompute called before init()');
+        }
+        const changed = [];
+        this.stats.recomputeVisited = 0;
+        this.stats.recomputeChanged = 0;
+        while (!this.pq.isEmpty()) {
+            const f = this.pq.popMin();
+            this.stats.recomputeVisited++;
+            this.stats.totalVisited++;
+            const rule = this.grammar.get(f);
+            const prev = this.values.get(f);
+            const next = this.runCompute(f, rule);
+            if (!Object.is(prev, next)) {
+                this.values.set(f, next);
+                this.stats.recomputeChanged++;
+                changed.push(f);
+                const deps = this.dependents.get(f);
+                if (deps !== undefined) {
+                    for (const d of deps) {
+                        const om = this.omNodes.get(d);
+                        this.pq.push(d, om);
+                    }
+                }
+            }
+        }
+        return changed;
+    }
+    runCompute(field, rule) {
+        const declaredDeps = new Set(rule.deps);
+        const read = (dep) => {
+            if (!declaredDeps.has(dep)) {
+                throw new Error(`[spineless-runtime] rule for "${field.name}" reads "${dep.name}" but did not declare it as a dependency`);
+            }
+            return this.values.get(dep);
+        };
+        return rule.compute(read);
+    }
+}
+//# sourceMappingURL=runtime.js.map

package/dist/algorithm/spineless/runtime.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"runtime.js","sourceRoot":"","sources":["../../../src/algorithm/spineless/runtime.ts"],"names":[],"mappings":"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"}

package/dist/algorithm/spineless/style-dirty.d.ts

@@ -0,0 +1,65 @@
+/**
+ * `markStyleDirty` — convenience for driving a precise incremental
+ * relayout after a style mutation.
+ *
+ * Every numeric style prop the flex grammar reads is modelled as a
+ * leaf input `Field` (see `buildFlexGrammar` / `StyleInputs`). After
+ * a `Node` setter call, the runtime needs the matching input Field
+ * marked dirty before `recompute()`. Looking that Field up through
+ * the `styleInputs` map by hand is repetitive and easy to get wrong;
+ * `createStyleDirtier` binds a runtime + its `styleInputs` into a
+ * single `(node, prop[, edge])` call that mirrors the `Node`
+ * setters:
+ *
+ * ```ts
+ * const { grammar, rootFields, styleInputs } = buildFlexGrammar(root);
+ * const rt = new SpinelessRuntime(grammar, [...rootFields...]);
+ * rt.init();
+ * const markStyleDirty = createStyleDirtier(rt, styleInputs);
+ *
+ * node.setWidth(50);
+ * markStyleDirty(node, 'width');
+ * rt.recompute();
+ * ```
+ *
+ * Value mutations only — a structural mutation (flex-direction,
+ * flex-wrap on/off, the justify / align category, `positionType`, a
+ * flex weight / `flexBasis` crossing the zero / numeric boundary)
+ * reshapes the dependency graph and still needs a fresh
+ * `buildFlexGrammar()`.
+ *
+ * @internal
+ */
+import type { Node } from '../../node.js';
+import type { StyleInputs } from './flex-grammar.js';
+import type { SpinelessRuntime } from './runtime.js';
+/** Style props addressed by a single input Field. */
+export type ScalarStyleProp = 'width' | 'height' | 'flexBasis' | 'flexGrow' | 'flexShrink' | 'gapRow' | 'gapColumn' | 'minWidth' | 'minHeight' | 'maxWidth' | 'maxHeight';
+/** Style props addressed per `[top, right, bottom, left]` edge. */
+export type EdgeStyleProp = 'padding' | 'margin';
+/**
+ * A bound `(node, prop[, edge])` callback that marks the input
+ * Field(s) for a mutated style prop dirty on its runtime.
+ *
+ * @internal
+ */
+export interface StyleDirtier {
+    (node: Node, prop: ScalarStyleProp): void;
+    (node: Node, prop: EdgeStyleProp, edge: number): void;
+}
+/**
+ * Bind a `SpinelessRuntime` and the `styleInputs` map from the
+ * `buildFlexGrammar` output that produced its grammar into a
+ * `StyleDirtier`.
+ *
+ * The returned callback throws if `node` is not part of the
+ * grammar's `styleInputs` (a node from a different / stale build),
+ * or if an edge prop is called without an edge index. It is a no-op
+ * when the grammar emits no input Field for the `(node, prop)` —
+ * which happens precisely when that prop can't affect layout (e.g.
+ * `padding` on a childless leaf), so marking nothing is correct.
+ *
+ * @internal
+ */
+export declare function createStyleDirtier(runtime: SpinelessRuntime, styleInputs: ReadonlyMap<Node, StyleInputs>): StyleDirtier;
+//# sourceMappingURL=style-dirty.d.ts.map

package/dist/algorithm/spineless/style-dirty.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"style-dirty.d.ts","sourceRoot":"","sources":["../../../src/algorithm/spineless/style-dirty.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA+BG;AAEH,OAAO,KAAK,EAAE,IAAI,EAAE,MAAM,eAAe,CAAC;AAC1C,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,mBAAmB,CAAC;AAErD,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,cAAc,CAAC;AAErD,qDAAqD;AACrD,MAAM,MAAM,eAAe,GACvB,OAAO,GACP,QAAQ,GACR,WAAW,GACX,UAAU,GACV,YAAY,GACZ,QAAQ,GACR,WAAW,GACX,UAAU,GACV,WAAW,GACX,UAAU,GACV,WAAW,CAAC;AAEhB,mEAAmE;AACnE,MAAM,MAAM,aAAa,GAAG,SAAS,GAAG,QAAQ,CAAC;AAEjD;;;;;GAKG;AACH,MAAM,WAAW,YAAY;IAC3B,CAAC,IAAI,EAAE,IAAI,EAAE,IAAI,EAAE,eAAe,GAAG,IAAI,CAAC;IAC1C,CAAC,IAAI,EAAE,IAAI,EAAE,IAAI,EAAE,aAAa,EAAE,IAAI,EAAE,MAAM,GAAG,IAAI,CAAC;CACvD;AAED;;;;;;;;;;;;;GAaG;AACH,wBAAgB,kBAAkB,CAChC,OAAO,EAAE,gBAAgB,EACzB,WAAW,EAAE,WAAW,CAAC,IAAI,EAAE,WAAW,CAAC,GAC1C,YAAY,CA8Bd"}

package/dist/algorithm/spineless/style-dirty.js

@@ -0,0 +1,75 @@
+/**
+ * `markStyleDirty` — convenience for driving a precise incremental
+ * relayout after a style mutation.
+ *
+ * Every numeric style prop the flex grammar reads is modelled as a
+ * leaf input `Field` (see `buildFlexGrammar` / `StyleInputs`). After
+ * a `Node` setter call, the runtime needs the matching input Field
+ * marked dirty before `recompute()`. Looking that Field up through
+ * the `styleInputs` map by hand is repetitive and easy to get wrong;
+ * `createStyleDirtier` binds a runtime + its `styleInputs` into a
+ * single `(node, prop[, edge])` call that mirrors the `Node`
+ * setters:
+ *
+ * ```ts
+ * const { grammar, rootFields, styleInputs } = buildFlexGrammar(root);
+ * const rt = new SpinelessRuntime(grammar, [...rootFields...]);
+ * rt.init();
+ * const markStyleDirty = createStyleDirtier(rt, styleInputs);
+ *
+ * node.setWidth(50);
+ * markStyleDirty(node, 'width');
+ * rt.recompute();
+ * ```
+ *
+ * Value mutations only — a structural mutation (flex-direction,
+ * flex-wrap on/off, the justify / align category, `positionType`, a
+ * flex weight / `flexBasis` crossing the zero / numeric boundary)
+ * reshapes the dependency graph and still needs a fresh
+ * `buildFlexGrammar()`.
+ *
+ * @internal
+ */
+/**
+ * Bind a `SpinelessRuntime` and the `styleInputs` map from the
+ * `buildFlexGrammar` output that produced its grammar into a
+ * `StyleDirtier`.
+ *
+ * The returned callback throws if `node` is not part of the
+ * grammar's `styleInputs` (a node from a different / stale build),
+ * or if an edge prop is called without an edge index. It is a no-op
+ * when the grammar emits no input Field for the `(node, prop)` —
+ * which happens precisely when that prop can't affect layout (e.g.
+ * `padding` on a childless leaf), so marking nothing is correct.
+ *
+ * @internal
+ */
+export function createStyleDirtier(runtime, styleInputs) {
+    return (node, prop, edge) => {
+        const entry = styleInputs.get(node);
+        if (entry === undefined) {
+            throw new Error('[spineless] markStyleDirty: node has no style inputs in this grammar — pass a node from the same buildFlexGrammar() tree');
+        }
+        let f;
+        if (prop === 'padding' || prop === 'margin') {
+            if (edge === undefined) {
+                throw new Error(`[spineless] markStyleDirty: '${prop}' requires an edge index`);
+            }
+            f = entry[prop]?.[edge];
+        }
+        else {
+            f = entry[prop];
+        }
+        // Marking nothing is the correct, precise behaviour when the
+        // mutation cannot move any layout field. That is the case both
+        // when no input Field exists for the prop, and when one exists
+        // but has been orphaned by a `detach` — e.g. the previous last
+        // child's main-end margin after its follower was removed. An
+        // orphaned input is no longer tracked by the runtime; a stale
+        // reference to it may linger in a `styleInputs` map.
+        if (f !== undefined && runtime.isTracked(f)) {
+            runtime.markDirty(f);
+        }
+    };
+}
+//# sourceMappingURL=style-dirty.js.map

package/dist/algorithm/spineless/style-dirty.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"style-dirty.js","sourceRoot":"","sources":["../../../src/algorithm/spineless/style-dirty.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA+BG;AAmCH;;;;;;;;;;;;;GAaG;AACH,MAAM,UAAU,kBAAkB,CAChC,OAAyB,EACzB,WAA2C;IAE3C,OAAO,CAAC,IAAU,EAAE,IAAqC,EAAE,IAAa,EAAQ,EAAE;QAChF,MAAM,KAAK,GAAG,WAAW,CAAC,GAAG,CAAC,IAAI,CAAC,CAAC;QACpC,IAAI,KAAK,KAAK,SAAS,EAAE,CAAC;YACxB,MAAM,IAAI,KAAK,CACb,0HAA0H,CAC3H,CAAC;QACJ,CAAC;QAED,IAAI,CAA4B,CAAC;QACjC,IAAI,IAAI,KAAK,SAAS,IAAI,IAAI,KAAK,QAAQ,EAAE,CAAC;YAC5C,IAAI,IAAI,KAAK,SAAS,EAAE,CAAC;gBACvB,MAAM,IAAI,KAAK,CAAC,gCAAgC,IAAI,0BAA0B,CAAC,CAAC;YAClF,CAAC;YACD,CAAC,GAAG,KAAK,CAAC,IAAI,CAAC,EAAE,CAAC,IAAI,CAAC,CAAC;QAC1B,CAAC;aAAM,CAAC;YACN,CAAC,GAAG,KAAK,CAAC,IAAI,CAAC,CAAC;QAClB,CAAC;QAED,6DAA6D;QAC7D,+DAA+D;QAC/D,+DAA+D;QAC/D,+DAA+D;QAC/D,6DAA6D;QAC7D,8DAA8D;QAC9D,qDAAqD;QACrD,IAAI,CAAC,KAAK,SAAS,IAAI,OAAO,CAAC,SAAS,CAAC,CAAmB,CAAC,EAAE,CAAC;YAC9D,OAAO,CAAC,SAAS,CAAC,CAAmB,CAAC,CAAC;QACzC,CAAC;IACH,CAAC,CAAC;AACJ,CAAC"}

package/dist/index.d.ts

@@ -1,9 +1,11 @@
-export declare const VERSION = "1.0.1";
+export declare const VERSION = "1.1.0";
 export { Node } from './node.js';
 export { Edge } from './edge.js';
 export type { Align, Display, FlexDirection, FlexWrap, Justify, Length, Overflow, PositionType, Style, } from './style.js';
 export { MeasureMode } from './measure-func.js';
 export type { MeasureFunc, MeasureSize } from './measure-func.js';
 export type { ComputedLayout } from './layout.js';
+export { setLayoutProfiler, type LayoutProfiler, type LayoutTrace } from './algorithm/index.js';
+export { inspectLayout } from './inspect.js';
 export { cellWidth, graphemes, stringWidth, stripAnsi, type Grapheme } from './measure/index.js';
 //# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,eAAO,MAAM,OAAO,UAAU,CAAC;AAG/B,OAAO,EAAE,IAAI,EAAE,MAAM,WAAW,CAAC;AAGjC,OAAO,EAAE,IAAI,EAAE,MAAM,WAAW,CAAC;AACjC,YAAY,EACV,KAAK,EACL,OAAO,EACP,aAAa,EACb,QAAQ,EACR,OAAO,EACP,MAAM,EACN,QAAQ,EACR,YAAY,EACZ,KAAK,GACN,MAAM,YAAY,CAAC;AAGpB,OAAO,EAAE,WAAW,EAAE,MAAM,mBAAmB,CAAC;AAChD,YAAY,EAAE,WAAW,EAAE,WAAW,EAAE,MAAM,mBAAmB,CAAC;AAGlE,YAAY,EAAE,cAAc,EAAE,MAAM,aAAa,CAAC;AAIlD,OAAO,EAAE,SAAS,EAAE,SAAS,EAAE,WAAW,EAAE,SAAS,EAAE,KAAK,QAAQ,EAAE,MAAM,oBAAoB,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,eAAO,MAAM,OAAO,UAAU,CAAC;AAG/B,OAAO,EAAE,IAAI,EAAE,MAAM,WAAW,CAAC;AAGjC,OAAO,EAAE,IAAI,EAAE,MAAM,WAAW,CAAC;AACjC,YAAY,EACV,KAAK,EACL,OAAO,EACP,aAAa,EACb,QAAQ,EACR,OAAO,EACP,MAAM,EACN,QAAQ,EACR,YAAY,EACZ,KAAK,GACN,MAAM,YAAY,CAAC;AAGpB,OAAO,EAAE,WAAW,EAAE,MAAM,mBAAmB,CAAC;AAChD,YAAY,EAAE,WAAW,EAAE,WAAW,EAAE,MAAM,mBAAmB,CAAC;AAGlE,YAAY,EAAE,cAAc,EAAE,MAAM,aAAa,CAAC;AAIlD,OAAO,EAAE,iBAAiB,EAAE,KAAK,cAAc,EAAE,KAAK,WAAW,EAAE,MAAM,sBAAsB,CAAC;AAGhG,OAAO,EAAE,aAAa,EAAE,MAAM,cAAc,CAAC;AAI7C,OAAO,EAAE,SAAS,EAAE,SAAS,EAAE,WAAW,EAAE,SAAS,EAAE,KAAK,QAAQ,EAAE,MAAM,oBAAoB,CAAC"}

package/dist/index.js

@@ -1,10 +1,15 @@
-export const VERSION = '1.0.1';
+export const VERSION = '1.1.0';
 // Tree
 export { Node } from './node.js';
 // Style values
 export { Edge } from './edge.js';
 // Measure callback
 export { MeasureMode } from './measure-func.js';
+// Layout profiling — observe what the incremental engine did per
+// `calculateLayout` call (phase 9).
+export { setLayoutProfiler } from './algorithm/index.js';
+// Layout inspection — a console dump of a computed-layout subtree.
+export { inspectLayout } from './inspect.js';
 // Text measurement (re-exported from the measure module so consumers can
 // build measure functions on top of our width tables).
 export { cellWidth, graphemes, stringWidth, stripAnsi } from './measure/index.js';