@pilates/core 1.0.1 → 1.1.0

package/dist/algorithm/spineless/order-maintenance.js.map

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

package/dist/algorithm/spineless/priority-queue.bench.d.ts

@@ -0,0 +1,17 @@
+/**
+ * Microbenchmark for the OM-keyed priority queue.
+ *
+ * Targets (Phase 5 viability):
+ * - `push`: < 2µs/op at N=10k (called once per dirty field per layout)
+ * - `popMin`: < 2µs/op at N=10k (called once per recompute step)
+ *
+ * Each layout pass under Spineless may process up to ~5k field-recomputes
+ * on a 1k-node TUI tree. Total PQ overhead must stay well under the
+ * 50-100µs target for incremental layout to beat imperative.
+ *
+ * Run with: `tsx packages/core/src/algorithm/spineless/priority-queue.bench.ts`
+ *
+ * @internal
+ */
+export {};
+//# sourceMappingURL=priority-queue.bench.d.ts.map

package/dist/algorithm/spineless/priority-queue.bench.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"priority-queue.bench.d.ts","sourceRoot":"","sources":["../../../src/algorithm/spineless/priority-queue.bench.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;GAcG"}

package/dist/algorithm/spineless/priority-queue.bench.js

@@ -0,0 +1,57 @@
+/**
+ * Microbenchmark for the OM-keyed priority queue.
+ *
+ * Targets (Phase 5 viability):
+ * - `push`: < 2µs/op at N=10k (called once per dirty field per layout)
+ * - `popMin`: < 2µs/op at N=10k (called once per recompute step)
+ *
+ * Each layout pass under Spineless may process up to ~5k field-recomputes
+ * on a 1k-node TUI tree. Total PQ overhead must stay well under the
+ * 50-100µs target for incremental layout to beat imperative.
+ *
+ * Run with: `tsx packages/core/src/algorithm/spineless/priority-queue.bench.ts`
+ *
+ * @internal
+ */
+import { BenderOrderMaintenance } from './order-maintenance.js';
+import { OmPriorityQueue } from './priority-queue.js';
+function median(xs) {
+    const sorted = [...xs].sort((a, b) => a - b);
+    return sorted[Math.floor(sorted.length / 2)];
+}
+function bench(label, sizes, opsPerTrial, trials) {
+    console.log(`\n## ${label}`);
+    for (const N of sizes) {
+        const trialMsPush = [];
+        const trialMsPop = [];
+        for (let t = 0; t < trials; t++) {
+            const om = new BenderOrderMaintenance();
+            const nodes = [om.init()];
+            for (let i = 1; i < N; i++)
+                nodes.push(om.insertAfter(nodes[i - 1]));
+            const pq = new OmPriorityQueue(om);
+            // Push phase
+            let s = performance.now();
+            for (let k = 0; k < opsPerTrial; k++) {
+                // Use a deterministic but spread-out order so the heap actually re-orders.
+                const i = (k * 2654435761) % N;
+                pq.push(k, nodes[i]);
+            }
+            let e = performance.now();
+            trialMsPush.push(e - s);
+            // Pop phase (extract everything)
+            s = performance.now();
+            while (!pq.isEmpty())
+                pq.popMin();
+            e = performance.now();
+            trialMsPop.push(e - s);
+        }
+        const usPush = (median(trialMsPush) * 1000) / opsPerTrial;
+        const usPop = (median(trialMsPop) * 1000) / opsPerTrial;
+        console.log(`  N=${N.toString().padStart(6)}  push=${usPush.toFixed(3).padStart(7)} µs  popMin=${usPop.toFixed(3).padStart(7)} µs`);
+    }
+}
+console.log('OmPriorityQueue microbench (Bender OM, single-threaded JS)');
+console.log('Targets: push < 2µs, popMin < 2µs at N=10k');
+bench('push + popMin', [100, 1000, 10000], 10_000, 5);
+//# sourceMappingURL=priority-queue.bench.js.map

package/dist/algorithm/spineless/priority-queue.bench.js.map

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

package/dist/algorithm/spineless/priority-queue.d.ts

@@ -0,0 +1,73 @@
+/**
+ * Order-Maintenance-keyed priority queue.
+ *
+ * The hot data structure of the Spineless Traversal runtime (Kirisame,
+ * Wang, Panchekha — PLDI 2025). Each item is keyed by an {@link OMNode}
+ * representing its position in the layout-field traversal order; the
+ * queue extracts items in OM-order, so the runtime always processes
+ * the earliest-dirty field next.
+ *
+ * Implementation: binary min-heap over `{ value, omNode }` records.
+ * Ordering uses `om.compare(a.omNode, b.omNode)`. Standard O(log N)
+ * push/popMin, O(1) peek/size.
+ *
+ * Membership tracking: an internal `Set` allows O(1) `has(value)`
+ * queries so the Spineless runtime can avoid enqueueing the same
+ * field twice. Important: this assumes `value` instances are stable
+ * (used as Map keys via reference equality), which fits the Spineless
+ * "one OMNode per (Node, field-name) pair, allocated once" model.
+ *
+ * ## Correctness under OM relabel
+ *
+ * The OM data structure may relabel internal tags on insert
+ * (`BenderOrderMaintenance`'s windowed redistribute). The heap
+ * invariant is "parent ≤ all descendants by OM compare". A relabel
+ * preserves the RELATIVE order of all live OM nodes, so
+ * `sign(compare(a, b))` is unchanged — the heap invariant holds.
+ *
+ * @internal
+ */
+import type { OMNode, OrderMaintenance } from './order-maintenance.js';
+/**
+ * @internal
+ */
+export declare class OmPriorityQueue<T> {
+    private readonly om;
+    private readonly heapValue;
+    private readonly heapOmNode;
+    private readonly members;
+    constructor(om: OrderMaintenance);
+    get size(): number;
+    isEmpty(): boolean;
+    has(value: T): boolean;
+    /**
+     * Push a value at the given OM position. Caller is responsible for
+     * checking `has(value)` first if dedup matters (some workflows
+     * intentionally re-enqueue after deletion).
+     *
+     * Returns `true` if added, `false` if `value` was already present
+     * (no-op — the queue is unchanged, original OM position retained).
+     */
+    push(value: T, omNode: OMNode): boolean;
+    /**
+     * Return (without removing) the value at OM-minimum. Returns
+     * `undefined` if the queue is empty.
+     */
+    peek(): T | undefined;
+    /**
+     * Remove and return the OM-minimum value. Returns `undefined` if
+     * the queue is empty.
+     */
+    popMin(): T | undefined;
+    /**
+     * Sift the element at index `start` up the heap until heap property
+     * is restored. O(log N).
+     */
+    private siftUp;
+    /**
+     * Sift the element at index `start` down the heap until heap property
+     * is restored. O(log N).
+     */
+    private siftDown;
+}
+//# sourceMappingURL=priority-queue.d.ts.map

package/dist/algorithm/spineless/priority-queue.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"priority-queue.d.ts","sourceRoot":"","sources":["../../../src/algorithm/spineless/priority-queue.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA4BG;AAEH,OAAO,KAAK,EAAE,MAAM,EAAE,gBAAgB,EAAE,MAAM,wBAAwB,CAAC;AAEvE;;GAEG;AACH,qBAAa,eAAe,CAAC,CAAC;IAC5B,OAAO,CAAC,QAAQ,CAAC,EAAE,CAAmB;IAMtC,OAAO,CAAC,QAAQ,CAAC,SAAS,CAAW;IACrC,OAAO,CAAC,QAAQ,CAAC,UAAU,CAAgB;IAE3C,OAAO,CAAC,QAAQ,CAAC,OAAO,CAAqB;gBAEjC,EAAE,EAAE,gBAAgB;IAIhC,IAAI,IAAI,IAAI,MAAM,CAEjB;IAED,OAAO,IAAI,OAAO;IAIlB,GAAG,CAAC,KAAK,EAAE,CAAC,GAAG,OAAO;IAItB;;;;;;;OAOG;IACH,IAAI,CAAC,KAAK,EAAE,CAAC,EAAE,MAAM,EAAE,MAAM,GAAG,OAAO;IASvC;;;OAGG;IACH,IAAI,IAAI,CAAC,GAAG,SAAS;IAIrB;;;OAGG;IACH,MAAM,IAAI,CAAC,GAAG,SAAS;IAgBvB;;;OAGG;IACH,OAAO,CAAC,MAAM;IAgBd;;;OAGG;IACH,OAAO,CAAC,QAAQ;CAsBjB"}

package/dist/algorithm/spineless/priority-queue.js

@@ -0,0 +1,149 @@
+/**
+ * Order-Maintenance-keyed priority queue.
+ *
+ * The hot data structure of the Spineless Traversal runtime (Kirisame,
+ * Wang, Panchekha — PLDI 2025). Each item is keyed by an {@link OMNode}
+ * representing its position in the layout-field traversal order; the
+ * queue extracts items in OM-order, so the runtime always processes
+ * the earliest-dirty field next.
+ *
+ * Implementation: binary min-heap over `{ value, omNode }` records.
+ * Ordering uses `om.compare(a.omNode, b.omNode)`. Standard O(log N)
+ * push/popMin, O(1) peek/size.
+ *
+ * Membership tracking: an internal `Set` allows O(1) `has(value)`
+ * queries so the Spineless runtime can avoid enqueueing the same
+ * field twice. Important: this assumes `value` instances are stable
+ * (used as Map keys via reference equality), which fits the Spineless
+ * "one OMNode per (Node, field-name) pair, allocated once" model.
+ *
+ * ## Correctness under OM relabel
+ *
+ * The OM data structure may relabel internal tags on insert
+ * (`BenderOrderMaintenance`'s windowed redistribute). The heap
+ * invariant is "parent ≤ all descendants by OM compare". A relabel
+ * preserves the RELATIVE order of all live OM nodes, so
+ * `sign(compare(a, b))` is unchanged — the heap invariant holds.
+ *
+ * @internal
+ */
+/**
+ * @internal
+ */
+export class OmPriorityQueue {
+    om;
+    // Parallel arrays for the heap. heapValue[i] is the user-supplied
+    // value; heapOmNode[i] is its OM position. Using parallel arrays
+    // rather than {value, omNode} pair objects avoids per-push
+    // allocation, which matters at Spineless-runtime scale (10k+
+    // pushes per layout pass at the largest TUI tree size).
+    heapValue = [];
+    heapOmNode = [];
+    // Membership set keyed by reference. Allows O(1) `has` checks.
+    members = new Set();
+    constructor(om) {
+        this.om = om;
+    }
+    get size() {
+        return this.heapValue.length;
+    }
+    isEmpty() {
+        return this.heapValue.length === 0;
+    }
+    has(value) {
+        return this.members.has(value);
+    }
+    /**
+     * Push a value at the given OM position. Caller is responsible for
+     * checking `has(value)` first if dedup matters (some workflows
+     * intentionally re-enqueue after deletion).
+     *
+     * Returns `true` if added, `false` if `value` was already present
+     * (no-op — the queue is unchanged, original OM position retained).
+     */
+    push(value, omNode) {
+        if (this.members.has(value))
+            return false;
+        this.heapValue.push(value);
+        this.heapOmNode.push(omNode);
+        this.members.add(value);
+        this.siftUp(this.heapValue.length - 1);
+        return true;
+    }
+    /**
+     * Return (without removing) the value at OM-minimum. Returns
+     * `undefined` if the queue is empty.
+     */
+    peek() {
+        return this.heapValue[0];
+    }
+    /**
+     * Remove and return the OM-minimum value. Returns `undefined` if
+     * the queue is empty.
+     */
+    popMin() {
+        const n = this.heapValue.length;
+        if (n === 0)
+            return undefined;
+        const top = this.heapValue[0];
+        const last = n - 1;
+        if (last > 0) {
+            this.heapValue[0] = this.heapValue[last];
+            this.heapOmNode[0] = this.heapOmNode[last];
+        }
+        this.heapValue.length = last;
+        this.heapOmNode.length = last;
+        this.members.delete(top);
+        if (last > 0)
+            this.siftDown(0);
+        return top;
+    }
+    /**
+     * Sift the element at index `start` up the heap until heap property
+     * is restored. O(log N).
+     */
+    siftUp(start) {
+        let i = start;
+        const value = this.heapValue[i];
+        const omNode = this.heapOmNode[i];
+        while (i > 0) {
+            const parent = (i - 1) >> 1;
+            const parentOm = this.heapOmNode[parent];
+            if (this.om.compare(omNode, parentOm) >= 0)
+                break;
+            this.heapValue[i] = this.heapValue[parent];
+            this.heapOmNode[i] = parentOm;
+            i = parent;
+        }
+        this.heapValue[i] = value;
+        this.heapOmNode[i] = omNode;
+    }
+    /**
+     * Sift the element at index `start` down the heap until heap property
+     * is restored. O(log N).
+     */
+    siftDown(start) {
+        let i = start;
+        const n = this.heapValue.length;
+        const value = this.heapValue[i];
+        const omNode = this.heapOmNode[i];
+        const halfN = n >> 1;
+        while (i < halfN) {
+            let bestChild = (i << 1) | 1; // 2i + 1, left child
+            const right = bestChild + 1;
+            if (right < n) {
+                if (this.om.compare(this.heapOmNode[right], this.heapOmNode[bestChild]) < 0) {
+                    bestChild = right;
+                }
+            }
+            if (this.om.compare(this.heapOmNode[bestChild], omNode) >= 0)
+                break;
+            this.heapValue[i] = this.heapValue[bestChild];
+            this.heapOmNode[i] = this.heapOmNode[bestChild];
+            i = bestChild;
+        }
+        this.heapValue[i] = value;
+        this.heapOmNode[i] = omNode;
+    }
+}
+//# sourceMappingURL=priority-queue.js.map

package/dist/algorithm/spineless/priority-queue.js.map

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

package/dist/algorithm/spineless/runtime.d.ts

@@ -0,0 +1,239 @@
+/**
+ * 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 type { Field, FieldRule, Grammar } from './grammar.js';
+import { type OrderMaintenance } from './order-maintenance.js';
+/**
+ * @internal
+ */
+export declare class SpinelessRuntime {
+    private readonly grammar;
+    private readonly rootFields;
+    private readonly om;
+    private readonly pq;
+    /** field -> cached value */
+    private readonly values;
+    /** field -> its OM timestamp (allocated in topo order at init) */
+    private readonly omNodes;
+    /** field -> fields that read this field (reverse of `rule.deps`) */
+    private readonly dependents;
+    /** The OM node at the topological tail — where `graft` appends. */
+    private lastOm;
+    private initDone;
+    /**
+     * 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.
+     */
+    readonly stats: {
+        /** Fields integrated so far — the `init` pass plus every `graft`. */
+        initFields: number;
+        /** Fields popped from the PQ by the most recent `recompute()`. */
+        recomputeVisited: number;
+        /** Of those, Fields whose value actually changed. */
+        recomputeChanged: number;
+        /** Cumulative Fields visited across every `recompute()` since init. */
+        totalVisited: number;
+    };
+    constructor(grammar: Grammar, rootFields: ReadonlyArray<Field<unknown>>, om?: OrderMaintenance);
+    /**
+     * 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(): void;
+    /**
+     * 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: Grammar, newRoots: ReadonlyArray<Field<unknown>>): void;
+    /**
+     * 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: Iterable<Field<unknown>>): void;
+    /**
+     * 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: Field<unknown>, newRule: FieldRule<unknown>): void;
+    /**
+     * 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.
+     */
+    private integrate;
+    /**
+     * 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<T>(field: Field<T>): T;
+    /**
+     * 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: Field<unknown>): boolean;
+    /**
+     * 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(): void;
+    /**
+     * 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: Field<unknown>): void;
+    /**
+     * 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(): Array<Field<unknown>>;
+    private runCompute;
+}
+//# sourceMappingURL=runtime.d.ts.map

package/dist/algorithm/spineless/runtime.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"runtime.d.ts","sourceRoot":"","sources":["../../../src/algorithm/spineless/runtime.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAqFG;AAEH,OAAO,KAAK,EAAE,KAAK,EAAE,SAAS,EAAE,OAAO,EAAU,MAAM,cAAc,CAAC;AACtE,OAAO,EAAuC,KAAK,gBAAgB,EAAE,MAAM,wBAAwB,CAAC;AAGpG;;GAEG;AACH,qBAAa,gBAAgB;IAC3B,OAAO,CAAC,QAAQ,CAAC,OAAO,CAAU;IAClC,OAAO,CAAC,QAAQ,CAAC,UAAU,CAAgC;IAC3D,OAAO,CAAC,QAAQ,CAAC,EAAE,CAAmB;IACtC,OAAO,CAAC,QAAQ,CAAC,EAAE,CAAkC;IAErD,4BAA4B;IAC5B,OAAO,CAAC,QAAQ,CAAC,MAAM,CAA2C;IAClE,kEAAkE;IAClE,OAAO,CAAC,QAAQ,CAAC,OAAO,CAA0C;IAClE,oEAAoE;IACpE,OAAO,CAAC,QAAQ,CAAC,UAAU,CAAoD;IAE/E,mEAAmE;IACnE,OAAO,CAAC,MAAM,CAAuB;IAErC,OAAO,CAAC,QAAQ,CAAS;IAEzB;;;;OAIG;IACH,QAAQ,CAAC,KAAK;QACZ,qEAAqE;;QAErE,kEAAkE;;QAElE,qDAAqD;;QAErD,uEAAuE;;MAEvE;gBAGA,OAAO,EAAE,OAAO,EAChB,UAAU,EAAE,aAAa,CAAC,KAAK,CAAC,OAAO,CAAC,CAAC,EACzC,EAAE,GAAE,gBAA+C;IAQrD;;;;OAIG;IACH,IAAI,IAAI,IAAI;IAKZ;;;;;;;;;;;;;;;OAeG;IACH,KAAK,CAAC,SAAS,EAAE,OAAO,EAAE,QAAQ,EAAE,aAAa,CAAC,KAAK,CAAC,OAAO,CAAC,CAAC,GAAG,IAAI;IAexE;;;;;;;;;;;;;;;;;;;;;;OAsBG;IACH,MAAM,CAAC,MAAM,EAAE,QAAQ,CAAC,KAAK,CAAC,OAAO,CAAC,CAAC,GAAG,IAAI;IAsE9C;;;;;;;;;;;;;;;OAeG;IACH,UAAU,CAAC,KAAK,EAAE,KAAK,CAAC,OAAO,CAAC,EAAE,OAAO,EAAE,SAAS,CAAC,OAAO,CAAC,GAAG,IAAI;IA0CpE;;;;;;;OAOG;IACH,OAAO,CAAC,SAAS;IAgDjB;;;;OAIG;IACH,QAAQ,CAAC,CAAC,EAAE,KAAK,EAAE,KAAK,CAAC,CAAC,CAAC,GAAG,CAAC;IAS/B;;;;;OAKG;IACH,SAAS,CAAC,KAAK,EAAE,KAAK,CAAC,OAAO,CAAC,GAAG,OAAO;IAIzC;;;;;;;;OAQG;IACH,YAAY,IAAI,IAAI;IASpB;;;;;;;OAOG;IACH,SAAS,CAAC,KAAK,EAAE,KAAK,CAAC,OAAO,CAAC,GAAG,IAAI;IAatC;;;;;;;;OAQG;IACH,SAAS,IAAI,KAAK,CAAC,KAAK,CAAC,OAAO,CAAC,CAAC;IA8BlC,OAAO,CAAC,UAAU;CAYnB"}