@pilates/core 1.0.1 → 2.0.0

package/dist/algorithm/spineless/runtime.js

@@ -0,0 +1,609 @@
+/**
+ * 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 { fieldIdCount } from './field-id-pool.js';
+import { BenderOrderMaintenance } from './order-maintenance.js';
+import { OmPriorityQueue } from './priority-queue.js';
+/**
+ * A `ReadFn` for zero-dependency rules — they declare no deps, so their
+ * `compute` must never call `read`. If one does, this throws (a grammar
+ * bug), mirroring the undeclared-dependency error in the normal path.
+ */
+const NEVER_READ = (dep) => {
+    throw new Error(`[spineless-runtime] a zero-dependency rule called read("${dep.name}") — it did not declare it as a dependency`);
+};
+/**
+ * Cache of the declared-deps Set for each rule. Keyed by the rule object
+ * (FieldRule is immutable after creation); when a rule is replaced via
+ * `rebindRule`, the new rule object gets a fresh WeakMap miss — no manual
+ * invalidation needed.
+ */
+const depSetCache = new WeakMap();
+/**
+ * @internal
+ */
+export class SpinelessRuntime {
+    rootFields;
+    om;
+    pq;
+    /**
+     * External Grammar map reference — kept so that callers holding the
+     * same map reference (e.g. layout.ts's `output.grammar`) see mutations
+     * made by `graft` / `rebindRule` / `detach`. All internal HOT-PATH
+     * reads use `rulesArr` (O(1) array index) instead.
+     */
+    grammar;
+    /**
+     * Field rules indexed by field.id — the fast-path mirror of `grammar`.
+     * Updated in lockstep with every `grammar.set` / `grammar.delete`.
+     * Plain array; auto-grows on out-of-range assignment (JS semantics).
+     */
+    rulesArr = [];
+    /**
+     * Fast path: numeric field values indexed by field.id.
+     * valuePresent[id] === 1 means the value is stored here as a number.
+     */
+    valuesArr;
+    /**
+     * Presence / storage-kind bitset, indexed by field.id:
+     *   0 = absent (not yet computed or detached)
+     *   1 = computed, value is a number stored in valuesArr[id]
+     *   2 = computed, value is a non-number object stored in valuesMap
+     */
+    valuePresent;
+    /**
+     * Fallback for non-number field values (e.g. Field<MainAxisDistribution>).
+     * Only populated when valuePresent[id] === 2.
+     */
+    valuesMap = new Map();
+    /**
+     * OM nodes indexed by field.id — replaces the former `omNodes: Map<Field, OMNode>`.
+     * Plain array; auto-grows on out-of-range assignment (JS semantics).
+     * undefined slot = field not integrated (or detached).
+     */
+    omNodesArr = [];
+    /**
+     * Authoritative list of all fields ever registered with this runtime
+     * (in integration order). Used for iteration in `markAllDirty` — slots
+     * whose `omNodesArr[field.id]` is `undefined` (detached) are skipped.
+     * Dead entries are never removed; the skip is O(1) per slot.
+     */
+    fieldRoster = [];
+    /**
+     * Reverse-dependency lists indexed by field.id — replaces the former
+     * `dependents: Map<Field, Field[]>`. `dependentsArr[id]` is the array
+     * of fields that read field-id. undefined = no dependents recorded yet
+     * (or field detached). Plain array; auto-grows on assignment.
+     */
+    dependentsArr = [];
+    /** 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);
+        // Mirror the public Grammar map into rulesArr (indexed by field.id)
+        // so the hot path can do O(1) array reads instead of Map lookups.
+        for (const [f, rule] of grammar) {
+            this.rulesArr[f.id] = rule;
+        }
+        // Initialise value arrays to cover all IDs allocated so far.
+        // ensureFieldCapacity() grows them on demand as new fields arrive.
+        const initialCap = Math.max(fieldIdCount(), 1024);
+        this.valuesArr = new Float64Array(initialCap);
+        this.valuePresent = new Uint8Array(initialCap);
+    }
+    /**
+     * Grow `valuesArr` and `valuePresent` so that `id` is a valid index.
+     * Doubles capacity until sufficient, copying forward (LayoutPool pattern).
+     */
+    ensureFieldCapacity(id) {
+        if (id < this.valuesArr.length)
+            return;
+        let cap = this.valuesArr.length;
+        while (id >= cap)
+            cap *= 2;
+        const newArr = new Float64Array(cap);
+        const newPresent = new Uint8Array(cap);
+        newArr.set(this.valuesArr);
+        newPresent.set(this.valuePresent);
+        this.valuesArr = newArr;
+        this.valuePresent = newPresent;
+    }
+    /**
+     * 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.omNodesArr[f.id] !== undefined) {
+                throw new Error(`[spineless-runtime] graft: field "${f.name}" already exists — graft integrates NEW fields only`);
+            }
+            this.rulesArr[f.id] = rule;
+            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.
+     *
+     * @returns The set of every field actually removed — both the
+     * explicit `fields` argument AND any orphan-cleaned surviving deps.
+     * Callers can use this to maintain a `Set<Field>` index in O(|dropped|)
+     * rather than scanning all tracked fields.
+     */
+    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.dependentsArr[f.id];
+            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 dropped = new Set();
+        const removedOmNodes = new Set();
+        const drop = (f) => {
+            dropped.add(f);
+            const omNode = this.omNodesArr[f.id];
+            if (omNode !== undefined) {
+                this.om.delete(omNode);
+                removedOmNodes.add(omNode);
+            }
+            this.omNodesArr[f.id] = undefined;
+            if (f.id < this.valuePresent.length && this.valuePresent[f.id] === 2) {
+                this.valuesMap.delete(f);
+            }
+            this.valuePresent[f.id] = 0;
+            this.dependentsArr[f.id] = undefined;
+            this.rulesArr[f.id] = undefined;
+            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.rulesArr[f.id];
+            if (rule !== undefined) {
+                for (const dep of rule.deps) {
+                    const revs = this.dependentsArr[dep.id];
+                    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.dependentsArr[dep.id];
+            if (revs !== undefined && revs.length > 0)
+                continue;
+            const rule = this.rulesArr[dep.id];
+            if (rule === undefined || rule.deps.length > 0)
+                continue;
+            drop(dep);
+        }
+        // The OM tail may have been among the removed fields. If so, walk
+        // back through predecessors (skipping just-removed nodes) to find
+        // the new tail — O(removed) instead of O(total live nodes).
+        if (this.lastOm !== null && removedOmNodes.has(this.lastOm)) {
+            let candidate = this.lastOm;
+            while (candidate !== null && removedOmNodes.has(candidate)) {
+                candidate = this.om.predecessor(candidate);
+            }
+            this.lastOm = candidate;
+        }
+        return dropped;
+    }
+    /**
+     * 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.omNodesArr[field.id] === undefined) {
+            throw new Error(`[spineless-runtime] rebindRule: field "${field.name}" is not in this runtime`);
+        }
+        const oldRule = this.rulesArr[field.id];
+        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.dependentsArr[d.id];
+            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.omNodesArr[d.id] === undefined) {
+                throw new Error(`[spineless-runtime] rebindRule: new dependency "${d.name}" of "${field.name}" is not integrated`);
+            }
+            let revs = this.dependentsArr[d.id];
+            if (revs === undefined) {
+                revs = [];
+                this.dependentsArr[d.id] = revs;
+            }
+            revs.push(field);
+        }
+        this.rulesArr[field.id] = newRule;
+        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
+            // the omNodesArr slot doubles as the "already done" marker — which
+            // makes existing fields natural boundaries during a graft.
+            if (this.omNodesArr[f.id] !== undefined)
+                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.rulesArr[f.id];
+            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.dependentsArr[dep.id];
+                if (revs === undefined) {
+                    revs = [];
+                    this.dependentsArr[dep.id] = 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.omNodesArr[f.id] = omNode;
+            this.fieldRoster.push(f);
+            this.stats.initFields++;
+            // Compute and cache.
+            this.ensureFieldCapacity(f.id);
+            const initVal = this.runCompute(f, rule);
+            if (typeof initVal === 'number') {
+                this.valuesArr[f.id] = initVal;
+                this.valuePresent[f.id] = 1;
+            }
+            else {
+                this.valuesMap.set(f, initVal);
+                this.valuePresent[f.id] = 2;
+            }
+            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) {
+        const id = field.id;
+        const kind = id < this.valuePresent.length ? this.valuePresent[id] : 0;
+        if (kind === 0) {
+            throw new Error(`[spineless-runtime] field "${field.name}" was not computed in init() — it isn't reachable from any root`);
+        }
+        if (kind === 1)
+            return this.valuesArr[id];
+        return this.valuesMap.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.omNodesArr[field.id] !== undefined;
+    }
+    /**
+     * 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 of this.fieldRoster) {
+            const omNode = this.omNodesArr[field.id];
+            if (omNode === undefined)
+                continue; // detached — skip
+            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.omNodesArr[field.id];
+        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.rulesArr[f.id];
+            const id = f.id;
+            const kind = this.valuePresent[id];
+            const prev = kind === 1 ? this.valuesArr[id] : this.valuesMap.get(f);
+            const next = this.runCompute(f, rule);
+            if (!Object.is(prev, next)) {
+                if (typeof next === 'number') {
+                    this.valuesArr[id] = next;
+                    this.valuePresent[id] = 1;
+                    if (kind === 2)
+                        this.valuesMap.delete(f);
+                }
+                else {
+                    this.valuesMap.set(f, next);
+                    this.valuePresent[id] = 2;
+                }
+                this.stats.recomputeChanged++;
+                changed.push(f);
+                const deps = this.dependentsArr[f.id];
+                if (deps !== undefined) {
+                    for (const d of deps) {
+                        const om = this.omNodesArr[d.id];
+                        this.pq.push(d, om);
+                    }
+                }
+            }
+        }
+        return changed;
+    }
+    runCompute(field, rule) {
+        // Zero-dep fields (leaf inputs, constants) can't read anything —
+        // skip the per-compute Set allocation + validating closure.
+        if (rule.deps.length === 0) {
+            return rule.compute(NEVER_READ);
+        }
+        // Look up the cached declared-deps Set for this rule object.
+        // Build and store on first call; reuse on every subsequent call.
+        // `rebindRule` installs a NEW rule object → WeakMap miss → fresh Set.
+        // No manual invalidation needed.
+        const ruleAsUnknown = rule;
+        let declaredDeps = depSetCache.get(ruleAsUnknown);
+        if (declaredDeps === undefined) {
+            declaredDeps = new Set(rule.deps);
+            depSetCache.set(ruleAsUnknown, declaredDeps);
+        }
+        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`);
+            }
+            const depId = dep.id;
+            const depKind = this.valuePresent[depId];
+            if (depKind === 1)
+                return this.valuesArr[depId];
+            return this.valuesMap.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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"}