bireactive 0.3.3 → 0.3.5

package/dist/core/cell.js

@@ -1,10 +1,11 @@
 // cell.ts — symmetric bidirectional reactive engine.
 //
 // Forward propagation is alien-signals verbatim. Backward is the same lazy
-// push-pull run on the transpose of the lens graph, carried by one `LensLink`
-// structure (the backward dual of forward's `Link`): `parentEdges` down,
-// `childEdges` up, created eagerly at lens construction. One traversal each
-// direction:
+// push-pull on the transpose of the lens graph, carried by `LensLink` (the dual
+// of `Link`): `parentEdges` down, `childEdges` up. A view write marks the
+// back-path `BF.Pending` and wakes each source's cone; nothing runs until a read
+// pulls. Reads pull only at clean entry points (getter top, source
+// `_update`/`_writeSource`, effect `_run`), never mid-compute.
 //
 //   role            forward (source → view)      backward (view → source)
 //   down edge       subs (who reads me)          parentEdges (my parents)
@@ -15,16 +16,9 @@
 //   "dirty" flag    F.Dirty (source staged)      BF.Dirty (view holds target)
 //   "pending" flag  F.Pending (on the cone)      BF.Pending (on the back-path)
 //
-// Forward flags live on `flags`, backward on a separate `bflags` word, so the
-// two never share a bit. A view write marks the back-path `BF.Pending` and wakes
-// each source's forward cone; nothing runs until a read pulls (source-centric: a
-// source resolves ALL its writers together and commits once). Reads pull only at
-// clean entry points (getter top, source `_update`/`_writeSource`, effect
-// `_run`), never mid-compute. Fan-in is the one non-dual piece: a `merge`
-// accumulates N contributors and folds once, post-order, inside `resolveCone`.
-//
-// Mode table — `getter`/`_bwd` fix forward/writable; the backward shape is read off
-// `_bwd` field presence (`merge` / `stateful` / `parentEdges` / `scatter`):
+// Forward flags live on `flags`, backward on a separate `bflags` word. Fan-in is
+// the one non-dual piece: a `merge` folds N contributors once, post-order, in
+// `resolveCone`. A cell's mode is read off `getter`/`_bwd` field presence:
 //   source      getter undefined                       (truth in currentValue)
 //   derived    getter, no _bwd                         (read-only derived)
 //   lens 1→1    getter + _bwd{ put }                    (scalar put)
@@ -74,10 +68,6 @@ let backCycle = 0;
  *  `writeBack` — so one shared stack suffices (no per-call allocation). */
 const wbNode = [];
 const wbTarget = [];
-/** Stateful lenses passed through in a `writeBack`, re-stamped post-order once
- *  their sources are written (versions bumped) so the next forward read sees an
- *  unchanged sum and skips `step` — own-write provenance. Pooled; non-reentrant. */
-const wbStateful = [];
 /** `resolveCone`'s pooled post-order frame stack: the node and its next-child
  *  cursor. Non-reentrant (no nested `resolveCone`), so shared pools suffice. */
 const rcNode = [];
@@ -141,18 +131,15 @@ function isWritable(c) {
 function isReadOnlyDerived(c) {
     return !isSource(c) && !isWritable(c);
 }
-/** Forward primal a source-reading `bwd` linearizes at, without a cascading
- *  recompute: live/last-settled value for a source or realized derived, else
- *  realize once via `.value` (PutGet holds for any source state). */
+/** Value a source-reading `put` linearizes at, with no cascading recompute:
+ *  the live/last-settled value, realizing once via `.value` if never computed. */
 function backPrimal(c) {
     if (c.getter === undefined || c.flags & F.Dirty)
         return c.value;
     return c.currentValue;
 }
-/** Create a lens-edge `child →[index] parent`, appending it to `child`'s
- *  `parentEdges` (down) eagerly at construction, in tuple order (so
- *  `parentEdges` is index-ordered). The up-list (`parent.childEdges`) is spliced
- *  lazily on first back-mark (`linkChild`), so child order is arm-order. */
+/** Create a lens-edge `child →[index] parent`, appended to `child.parentEdges`
+ *  in tuple order. */
 function linkLens(child, parent, index) {
     const e = {
         index,
@@ -169,9 +156,7 @@ function linkLens(child, parent, index) {
         child.parentEdges = e;
     child.parentEdgesTail = e;
 }
-/** Splice a lens-edge into its parent's `childEdges` (the up-traversal list),
- *  once, on first back-mark — so a parent's child order is arm-order and
- *  co-writer resolution is last-write-wins. Idempotent via `linked`. */
+/** Splice a lens-edge into its parent's `childEdges` up-list, once. Idempotent via `linked`. */
 function linkChild(e) {
     if (e.linked)
         return;
@@ -186,11 +171,8 @@ function linkChild(e) {
         parent.childEdges = e;
     parent.childEdgesTail = e;
 }
-/** Remove a lens-edge from its parent's `childEdges` up-list in O(1), and mark it
- *  re-linkable — the backward dual of `unlink` dropping a subscriber from `subs`.
- *  Called when a view is unwatched, to release the parent→child retaining edge (a
- *  later arm re-`linkChild`s). The child's own down-list (`parentEdges`) stays:
- *  it's intrinsic to the view and dies with it. */
+/** Remove a lens-edge from its parent's `childEdges` up-list in O(1) and mark it
+ *  re-linkable. Called on unwatch to release the parent→child retaining edge. */
 function unlinkChild(e) {
     if (COUNTS)
         counts.unlinkChild++;
@@ -208,10 +190,9 @@ function unlinkChild(e) {
     e.nextChild = undefined;
 }
 /** Precompute `BF.WriteBlocked` once, after a writable's `parentEdges` are linked.
- *  Mirrors `markDown`'s descent exactly: a sole read-only-derived parent dead-ends
- *  (block); a split routes around a read-only parent; otherwise the block is
- *  inherited from any non-read-only parent already flagged. Topology is immutable
- *  and parents are built first, so each node's bit is its parents' bits + one scan. */
+ *  Mirrors `markDown`'s descent: a sole read-only-derived parent dead-ends (block);
+ *  a split routes around a read-only parent; otherwise inherit the block from any
+ *  non-read-only parent already flagged. */
 function setWriteBlocked(cell) {
     const pe = cell.parentEdges;
     if (pe === undefined)
@@ -479,50 +460,26 @@ class MergeNode {
         this.foldFn = fold;
     }
 }
-// BwdSpec — the backward sidecar, off a single `_bwd` pointer so a source/computed
-// stays lean. Only a writable derived cell (lens / multi-out / merge / stateful /
-// pin) carries one; writable iff `_bwd !== undefined`. The backward shape is read
-// off field presence rather than a tag: `merge` set ⇒ fan-in fold; `stateful` set ⇒
-// complement-carrying; no `parentEdges` ⇒ pin sink; `scatter` ⇒ tuple `put`. The
-// one bit that isn't recoverable from topology is scalar-vs-tuple `put` (a 1-parent
-// split still takes a tuple), hence `scatter`.
+// BwdSpec — the backward sidecar, off a single `_bwd` pointer (writable iff
+// `_bwd !== undefined`). The backward shape is read off field presence, not a tag:
+// `merge` ⇒ fan-in fold; `stateful` ⇒ complement-carrying; no `parentEdges` ⇒ pin
+// sink; `scatter` ⇒ tuple `put` (the one bit not recoverable from topology, since a
+// 1-parent split still takes a tuple).
 class BwdSpec {
-    /** Lens `put` (dual of `getter`): `put(target)` for 1→1 / multi-out (a
-     *  source-reading lens reads its parents at walk time), `put(target, sources, c)`
-     *  for stateful. `undefined` for a merge (folds) or pin (absorbs). */
+    /** Lens `put` (dual of `getter`): `put(target)` for 1→1 / multi-out,
+     *  `put(target, sources, c)` for stateful. `undefined` for a merge or pin. */
     // biome-ignore lint/suspicious/noExplicitAny: put fn is opaque shape
     put = undefined;
     /** Fold payload; present ⇒ a fan-in merge. */
     merge = undefined;
-    /** Complement state; present ⇒ a complement-carrying (stateful) lens. */
+    /** The mutable complement object a stateful optic's `get`/`put` thread (and may
+     *  mutate in place); present ⇒ a complement-carrying (stateful) lens. Seeded once
+     *  per bind from `optic.complement`, never reassigned. */
     stateful = undefined;
     /** `put` yields a per-parent tuple (split / stateful) vs a scalar (1→1). The
      *  only discriminant not derivable from topology (a 1-parent split is a tuple). */
     scatter = false;
 }
-/** Runtime state of a symmetric-lens complement, kept off `BwdSpec` so plain
- *  lenses don't carry its slots. See the stateful-lens header for the theory
- *  (symmetric/edit lenses) and the version-stamp provenance. */
-class StatefulCore {
-    /** Engine-owned memory the view discards. */
-    complement;
-    /** Advance the complement: `step(sources, complement)`. Run only when the
-     *  sources actually moved (the engine gates it; see the stateful header). */
-    // biome-ignore lint/suspicious/noExplicitAny: opaque step shape
-    step;
-    /** Sum of the parents' `version`s as of the last sync. Sources moved iff the
-     *  live sum differs — the lazy own-vs-external provenance that replaces a value
-     *  witness. A read syncs it after stepping; a back-write re-stamps it post-order
-     *  (own writes don't re-step, so `bwd` must leave the complement consistent).
-     *  Seeded to `-1` (sums are ≥ 0) so the first use always folds the sources in. */
-    stamp = -1;
-    constructor(complement, 
-    // biome-ignore lint/suspicious/noExplicitAny: opaque step shape
-    step) {
-        this.complement = complement;
-        this.step = step;
-    }
-}
 // ─────────────────────────────────────────────────────────────────────────
 // Public API — sentinels, read/write shapes, and value-coercion helpers.
 // ─────────────────────────────────────────────────────────────────────────
@@ -602,10 +559,6 @@ export class Cell {
     /** @internal Visit epoch for `backResolve`'s collect phase (dedups diamonds
      *  without a Set; compared against the global `backCycle`). */
     bEpoch;
-    /** @internal Monotone committed-change counter. A stateful lens sums its
-     *  parents' versions to detect "did my sources move since I last synced?" —
-     *  the lazy provenance that replaces a value witness (see the stateful header). */
-    version;
     /** Optional debug label (`cell(0, { name })`); used by errors and graph dumps. */
     name;
     // Every slot assigned once, in declaration order, for a stable V8 hidden class.
@@ -628,7 +581,6 @@ export class Cell {
         this.childEdgesTail = undefined;
         this.bflags = BF.None;
         this.bEpoch = 0;
-        this.version = 0;
         this.name = undefined;
         if (opts !== undefined) {
             if (opts.equals !== undefined)
@@ -649,15 +601,13 @@ export class Cell {
         const prev = this.pendingValue;
         this.pendingValue = next;
         if (!this._equals(prev, next)) {
-            this.version++; // stamp the change for stateful-lens provenance (sum-of-versions)
             this.flags = F.Mutable | F.Dirty;
             if (writeHook !== undefined)
                 writeHook(this);
             const subs = this.subs;
             if (subs !== undefined) {
                 // Convert the cone's arm-time `Pending` into `Dirty` so a second observer
-                // (not just the first reader) sees the change. If this lands mid-pull, the
-                // freshly-`Dirty` nodes are honored by `checkDirty`'s unwind.
+                // (not just the first reader) sees the change; honored mid-pull by `checkDirty`.
                 propagate(subs, runDepth > 0, activeExcluded);
                 autoFlush();
             }
@@ -678,10 +628,7 @@ export class Cell {
                 const old = this.currentValue;
                 const next = (this.currentValue = this.getter());
                 threw = false;
-                const changed = !this._equals(old, next);
-                if (changed)
-                    this.version++; // derived commit: stamp for stateful provenance
-                return changed;
+                return !this._equals(old, next);
             }
             finally {
                 activeSub = prev;
@@ -702,11 +649,9 @@ export class Cell {
     _notify() { }
     /** @internal */
     _unwatched() {
-        // Backward dual of `unlink` clearing us from each parent's `subs`: release
-        // the parent→child retaining edge (the `childEdges` up-list) so a disposed
-        // view stops being pinned by a long-lived source. Our own down-list
-        // (`parentEdges`) stays — a later arm re-links via `markDown`. Skip a still
-        // back-marked view (a pending write needs its edge); rare and bounded.
+        // Release each parent→child retaining edge (the `childEdges` up-list) so a
+        // disposed view isn't pinned by a long-lived source; a later arm re-links via
+        // `markDown`. Skip a still back-marked view — its pending write needs the edge.
         if (!(this.bflags & BACK_MARKED)) {
             for (let e = this.parentEdges; e !== undefined; e = e.nextParent) {
                 if (e.linked)
@@ -731,29 +676,18 @@ export class Cell {
             activeSub = prev;
         }
     }
-    // Construction helpers build via `new this()` so a subclass static
-    // (`Vec.lens(...)`) yields a `Vec` with its constructor-set equality.
-    /** Endomorphic lens. A 2-arg `bwd(view, current)` consults the current
-     *  source; a 1-arg `bwd(view)` reconstructs it from the view alone. */
-    lens(fwd, bwd) {
-        return buildLens(this.constructor, [this, fwd, bwd]);
+    // biome-ignore lint/suspicious/noExplicitAny: dispatch over fwd/bwd vs optic chain
+    lens(...args) {
+        if (typeof args[0] === "function") {
+            return buildLens(this.constructor, [this, ...args]);
+        }
+        return buildLens(CELL_CTOR, [this, ...args]);
     }
     /** Read-only same-type view: the RO dual of the endo `.lens`. For a cross-type view use the typed static
      *  `Target.derive(src, fn)`. */
     derive(fn) {
         return buildDerived(this.constructor, () => fn(this.value));
     }
-    // biome-ignore lint/suspicious/noExplicitAny: heterogeneous optic chain
-    through(...optics) {
-        // Fold via each optic's own `through` (no import of optic.ts → no cycle).
-        const o = optics.length === 1 ? optics[0] : optics.reduce((a, b) => a.through(b));
-        // Preserve put arity: a source-reading optic binds 2-arg; an iso binds 1-arg
-        // (reconstruct, no source read), matching `lens`'s `bwd.length` dispatch.
-        const bwd = o.readsSource
-            ? (target, cur) => o.put(target, cur)
-            : (target) => o.put(target, undefined);
-        return lens(this, o.get, bwd);
-    }
     /** Backward fan-in: forwards its parent's value unchanged; on write, folds N
      *  contributors into one value. `fold` defaults to last-writer-wins. */
     merge(fold) {
@@ -836,8 +770,7 @@ function buildDerived(Cls, getter) {
     return cell;
 }
 // Shared N-input read getter: refill a construction-owned buffer from the parents
-// each read (no per-read alloc), then apply `fwd`. Identical hot closure whether
-// the node is a read-only derive-N or a writable split lens.
+// each read (no per-read alloc), then apply `fwd`.
 function arrayGetter(parents, fwd) {
     const n = parents.length;
     const vals = new Array(n);
@@ -847,89 +780,119 @@ function arrayGetter(parents, fwd) {
         return fwd(vals);
     };
 }
-// One writable-lens constructor for both shapes. The `Array.isArray` branch is paid
-// once at construction and installs the matching specialized hot closures — scalar
-// scalar `getter`/`put` for 1→1, the buffer-loop getter + tuple `put` (`scatter`)
-// for N→M — so neither hot path changes. A 2-arg call is the
-// complement-carrying form and routes to `buildStateful`. `bwd` is always present
-// (a read-only N view is a `derive`, built via `buildDerive`).
-// biome-ignore lint/suspicious/noExplicitAny: dispatch over the untyped call forms
-function buildLens(Cls, args) {
-    const parent0 = args[0];
-    if (args.length === 2) {
-        return Array.isArray(parent0)
-            ? buildStateful(Cls, parent0, args[1])
-            : buildStateful1(Cls, parent0, args[1]);
-    }
-    let parent = parent0;
-    let fwd = args[1];
-    let bwd = args[2];
-    // Object-keyed parents → rewrite to the positional array form (key order
-    // fixed once; omitted backward keys become SKIP). The tuple fast path below
-    // is untouched.
-    if (parent0 !== null &&
-        typeof parent0 === "object" &&
-        !Array.isArray(parent0) &&
-        !(parent0 instanceof Cell)) {
-        const keys = Object.keys(parent0);
-        const rec = parent0;
-        const fwdObj = fwd;
-        const bwdObj = bwd;
-        const toObj = (vals) => {
-            const o = {};
-            for (let i = 0; i < keys.length; i++)
-                o[keys[i]] = vals[i];
-            return o;
-        };
-        parent = keys.map(k => rec[k]);
-        fwd = (vals) => fwdObj(toObj(vals));
-        bwd = ((t, vals) => {
-            const o = bwdObj(t, toObj(vals));
-            return keys.map(k => (k in o ? o[k] : SKIP));
-        });
-    }
-    const readsSource = bwd.length >= 2;
+// Bind a pure (complement-free) optic to one source. Source-reading vs iso is the
+// `put` arity. The 1→1 getter/put stays scalar.
+function bindPureScalar(Cls, p, optic) {
+    const get = optic.get;
+    const put = optic.put;
+    const readsSource = put.length >= 2;
     const cell = new Cls();
     cell.flags = F.Mutable | F.Dirty;
     const b = (cell._bwd = new BwdSpec());
+    cell.getter = (() => get(p.value));
+    // Source-reading lenses linearize at the parent's primal (`backPrimal`), so the
+    // engine always calls the 1-arg form and never recomputes the parent's cone.
+    b.put = readsSource ? (t) => put(t, backPrimal(p)) : put;
+    linkLens(cell, p, 0);
+    setWriteBlocked(cell);
+    return cell;
+}
+function bindPureTuple(Cls, parents, optic) {
+    const get = optic.get;
+    const put = optic.put;
+    const readsSource = put.length >= 2;
+    const n = parents.length;
+    const cell = new Cls();
+    cell.flags = F.Mutable | F.Dirty;
+    const b = (cell._bwd = new BwdSpec());
+    cell.getter = arrayGetter(parents, get);
+    b.scatter = true;
+    for (let i = 0; i < n; i++)
+        linkLens(cell, parents[i], i);
+    if (readsSource) {
+        // Own reused buffer (not the getter's) to avoid aliasing; `put` consumes it
+        // synchronously and must not retain it.
+        const argbuf = new Array(n);
+        const putN = put;
+        b.put = (target) => {
+            for (let i = 0; i < n; i++)
+                argbuf[i] = backPrimal(parents[i]);
+            return putN(target, argbuf);
+        };
+    }
+    else {
+        const put0 = put;
+        b.put = (target) => put0(target);
+    }
+    setWriteBlocked(cell);
+    return cell;
+}
+// Bind one optic to a source (cell or array). The four shapes (scalar/tuple ×
+// pure/stateful) fall out of `Array.isArray(parent)` and the `complement` discriminant.
+function bindOne(Cls, parent, optic) {
     if (Array.isArray(parent)) {
         const parents = parent;
-        const n = parents.length;
-        cell.getter = arrayGetter(parents, fwd);
-        b.scatter = true;
-        for (let i = 0; i < n; i++)
-            linkLens(cell, parents[i], i);
-        if (readsSource) {
-            // Own reused buffer (not the getter's) to avoid aliasing; `bwd` consumes it
-            // synchronously and must not retain it.
-            const argbuf = new Array(n);
-            const bwdN = bwd;
-            b.put = (target) => {
-                for (let i = 0; i < n; i++)
-                    argbuf[i] = backPrimal(parents[i]);
-                return bwdN(target, argbuf);
+        return optic.complement !== undefined
+            ? buildStateful(Cls, parents, optic)
+            : bindPureTuple(Cls, parents, optic);
+    }
+    const p = parent;
+    return optic.complement !== undefined
+        ? buildStateful1(Cls, p, optic)
+        : bindPureScalar(Cls, p, optic);
+}
+// One writable-lens constructor over all call forms. `(parent, fwd, bwd)` is sugar
+// for an inline pure optic; `(parent, ...optics)` folds an optic chain by repeated
+// binding (each optic bound to the prior result; only the last stage takes `Cls`).
+// Composition is just re-binding, so `cell.ts` needs no optic.ts import.
+// biome-ignore lint/suspicious/noExplicitAny: dispatch over the untyped call forms
+function buildLens(Cls, args) {
+    const parent0 = args[0];
+    const cls = Cls;
+    if (typeof args[1] === "function") {
+        // `(parent, fwd, bwd)` → an inline pure optic, then bind.
+        let parent = parent0;
+        let get = args[1];
+        let put = args[2];
+        // Object-keyed parents → rewrite to the positional array form (key order fixed
+        // once; omitted backward keys become SKIP).
+        if (parent0 !== null &&
+            typeof parent0 === "object" &&
+            !Array.isArray(parent0) &&
+            !(parent0 instanceof Cell)) {
+            const keys = Object.keys(parent0);
+            const rec = parent0;
+            const getObj = get;
+            const putObj = put;
+            const toObj = (vals) => {
+                const o = {};
+                for (let i = 0; i < keys.length; i++)
+                    o[keys[i]] = vals[i];
+                return o;
             };
+            parent = keys.map(k => rec[k]);
+            get = ((vals) => getObj(toObj(vals)));
+            put = ((t, vals) => {
+                const o = putObj(t, toObj(vals));
+                return keys.map(k => (k in o ? o[k] : SKIP));
+            });
         }
-        else {
-            const bwd0 = bwd;
-            b.put = (target) => bwd0(target);
-        }
+        return bindOne(cls, parent, { get, put });
     }
-    else {
-        const p = parent;
-        cell.getter = (() => fwd(p.value));
-        // Source-reading lenses linearize at the parent's primal (`backPrimal`), so the
-        // engine always calls the 1-arg form and never recomputes the parent's cone.
-        b.put = readsSource ? (t) => bwd(t, backPrimal(p)) : bwd;
-        linkLens(cell, p, 0);
+    // Optic value(s): fold the chain by repeated binding.
+    let acc = parent0;
+    const last = args.length - 1;
+    for (let i = 1; i <= last; i++) {
+        acc = bindOne(i === last ? cls : CELL_CTOR, acc, args[i]);
     }
-    setWriteBlocked(cell);
-    return cell;
+    return acc;
+}
+// Seed the complement object from the current sources (fresh per bind).
+function seedComplement(optic, seed) {
+    return optic.complement(seed);
 }
 // biome-ignore lint/suspicious/noExplicitAny: variance escape
-function buildStateful(Cls, parents, 
-// biome-ignore lint/suspicious/noExplicitAny: opaque spec
-spec) {
+function buildStateful(Cls, parents, optic) {
     const n = parents.length;
     const vals = new Array(n);
     const cell = new Cls();
@@ -938,74 +901,40 @@ spec) {
     const seed = new Array(n);
     for (let i = 0; i < n; i++)
         seed[i] = parents[i].peek();
-    // Default `step` is the memoryless refresh (`init`); the engine runs it only on
-    // an outside change, so the `external ? init(s) : c` idiom needs no user `step`.
-    const init = spec.init;
-    const step = (spec.step ?? init);
-    const sc = (b.stateful = new StatefulCore(spec.init(seed), step));
-    // Sentinel: version sums are ≥ 0, so the first read (or back-write) always
-    // steps once, folding the initial sources into the seed complement. The
-    // `init`/`step` split is seed-then-fold: `init` need not see the sources.
-    sc.stamp = -1;
-    const fwd = spec.fwd;
-    b.put = spec.bwd;
+    const c = (b.stateful = seedComplement(optic, seed));
+    const get = optic.get;
+    b.put = optic.put;
     b.scatter = true;
     for (let i = 0; i < n; i++)
         linkLens(cell, parents[i], i);
+    // Forward-only refresh: `get` reads the sources and (idempotently) updates the
+    // complement; the cache runs it once per source-version change.
     cell.getter = (() => {
-        let ver = 0;
-        for (let i = 0; i < n; i++) {
+        for (let i = 0; i < n; i++)
             vals[i] = parents[i].value;
-            ver += parents[i].version;
-        }
-        // Step only when sources moved since the last sync (lazy own-vs-external).
-        if (ver !== sc.stamp) {
-            if (COUNTS)
-                counts.step++;
-            sc.complement = sc.step(vals, sc.complement);
-            sc.stamp = ver;
-        }
-        return fwd(vals, sc.complement);
+        return get(vals, c);
     });
     setWriteBlocked(cell);
     return cell;
 }
 // Single-source stateful fast-path: one parent, so no `vals` buffer and a scalar
-// `step`/`fwd`/`bwd` — the version stamp is just the parent's `version`. Same
-// provenance and laziness as the N-source `buildStateful`, minus the array work.
+// `get`/`put` — minus the array work of the N-source `buildStateful`.
 // biome-ignore lint/suspicious/noExplicitAny: variance escape
-function buildStateful1(Cls, parent, 
-// biome-ignore lint/suspicious/noExplicitAny: opaque spec
-spec) {
+function buildStateful1(Cls, parent, optic) {
     const cell = new Cls();
     cell.flags = F.Mutable | F.Dirty;
     const b = (cell._bwd = new BwdSpec());
-    const init = spec.init;
-    const step = (spec.step ?? init);
-    const sc = (b.stateful = new StatefulCore(init(parent.peek()), step));
-    sc.stamp = -1; // sentinel: first use folds the source in (see `buildStateful`)
-    const fwd = spec.fwd;
-    b.put = spec.bwd;
+    const c = (b.stateful = seedComplement(optic, parent.peek()));
+    const get = optic.get;
+    b.put = optic.put;
     // `scatter` stays false: writeBack routes this through the scalar stateful branch.
     linkLens(cell, parent, 0);
-    cell.getter = (() => {
-        const x = parent.value;
-        const ver = parent.version;
-        if (ver !== sc.stamp) {
-            if (COUNTS)
-                counts.step++;
-            sc.complement = sc.step(x, sc.complement);
-            sc.stamp = ver;
-        }
-        return fwd(x, sc.complement);
-    });
+    cell.getter = (() => get(parent.value, c));
     setWriteBlocked(cell);
     return cell;
 }
 // One read-only-derive constructor: a bare closure (`derive(fn)`), a single tracked
-// read (`derive(p, fn)`), or an N-parent read (`derive(ps, fn)`) — each lands in
-// `buildDerived` with the matching getter. (Writable `lens(...)` is `buildLens`;
-// statics pass the typed subclass, free functions plain `Cell`, so neither drifts.)
+// read (`derive(p, fn)`), or an N-parent read (`derive(ps, fn)`).
 // biome-ignore lint/suspicious/noExplicitAny: dispatch over the untyped call forms
 function buildDerive(Cls, args) {
     if (args.length === 1)
@@ -1016,8 +945,7 @@ function buildDerive(Cls, args) {
         return buildDerived(Cls, arrayGetter(parent, fn));
     return buildDerived(Cls, () => fn(parent.value));
 }
-// Installed on the prototype (not a class accessor): V8 JITs it better and keeps
-// the field-only class shape for a stable hidden class.
+// Prototype accessor (not a class accessor): V8 JITs it better, keeps a stable hidden class.
 Object.defineProperty(Cell.prototype, "value", {
     get() {
         // Reading is the PULL: a back-marked cell resolves here, before its own
@@ -1067,8 +995,8 @@ Object.defineProperty(Cell.prototype, "value", {
             throw new TypeError("Cannot write to a computed");
         }
         // GetPut for a multi-parent split: absorb a write equal to the current view
-        // (its `put` could redistribute sources past per-source equality). Stateful
-        // excluded (`scatter` but `stateful` set) — peeking would step its complement.
+        // (its `put` could redistribute sources). Stateful excluded — peeking would run
+        // `get` and mutate its complement.
         if (b.scatter && b.stateful === undefined && this._equals(next, this.peek())) {
             return;
         }
@@ -1154,19 +1082,15 @@ function markDown(start) {
         }
     }
 }
-/** RESOLVE (pull), dual of `checkDirty`: resolve one node's whole back-cone.
- *  Ascend `childEdges` (only `BACK_MARKED` children) to the armed views,
- *  `writeBack`ing each. Source-centric — a source reflects all its writers, so a
- *  call on it resolves every co-writer together and commits once.
+/** RESOLVE (pull), dual of `checkDirty`: resolve one node's whole back-cone by
+ *  ascending `childEdges` to the armed views and `writeBack`ing each. Source-centric
+ *  — a call on a source resolves every co-writer together and commits once.
  *
- *  Iterative post-order over the back-cone, via an explicit frame stack of
- *  {node, next-child cursor}. On entering a
- *  node (pre): clear a merge's contributions, then `writeBack` if it holds an armed
- *  target. After its children drain (post): clear `BF.Pending`, then fold a merge.
- *  Children are walked in forward `childEdges` order (so a co-writer's last write
- *  wins) and a per-call `bEpoch` dedups diamonds — the merge fold lands at its true
- *  post-order position, interleaved with sibling writes, not deferred.
- *  Idempotent, so phase-2 of `backResolve` can call it unconditionally. */
+ *  Iterative post-order via an explicit {node, next-child cursor} frame stack:
+ *  pre-order clears a merge's buffer and drives an armed target (`enterCone`);
+ *  post-order clears `BF.Pending` and folds a merge at its true position. Children
+ *  walk in `childEdges` order (co-writer last-write-wins); `bEpoch` dedups diamonds.
+ *  Idempotent, so `backResolve`'s phase 2 can call it unconditionally. */
 function resolveCone(root) {
     const epoch = ++backCycle;
     root.bEpoch = epoch;
@@ -1300,7 +1224,6 @@ function writeBack(node, target) {
     wbNode[0] = node;
     wbTarget[0] = target;
     let top = 1;
-    let sTop = 0;
     while (top > 0) {
         if (COUNTS)
             counts.writeBackVisit++;
@@ -1308,13 +1231,10 @@ function writeBack(node, target) {
         const tgt = wbTarget[top];
         if (isSource(cur)) {
             cur._writeSource(tgt); // staged now, visible to later siblings
-            // Clear this source's `BF.Pending`, then re-assert iff a lens-child is STILL
-            // armed (an overlapping co-writer) — else that write is lost, and leaving it
-            // set unconditionally would strand `BF.Pending` on every fan-in source.
-            // Scan from the TAIL: `resolveCone` drives children head→tail, so the last
-            // still-armed co-writer sits near the tail — found in O(1) until the final
-            // one, turning a fan-in's re-assert from O(N²) into O(N). (Order is
-            // irrelevant; this is a find-any.)
+            // Clear `BF.Pending`, then re-assert iff a lens-child is still armed (an
+            // overlapping co-writer); else leaving it set would strand `BF.Pending` on
+            // every fan-in source. Scan from the tail (where `resolveCone` leaves the last
+            // still-armed co-writer), turning a fan-in re-assert from O(N²) into O(N).
             cur.bflags &= ~BF.Pending;
             for (let e = cur.childEdgesTail; e !== undefined; e = e.prevChild) {
                 if (COUNTS)
@@ -1343,18 +1263,11 @@ function writeBack(node, target) {
             // Single-source stateful fast-path (scalar `bwd`); one index-0 parent edge.
             const p = pe.parent;
             const x = p.value;
-            const ver = p.version;
-            if (ver !== sc.stamp) {
-                if (COUNTS)
-                    counts.step++;
-                sc.complement = sc.step(x, sc.complement);
-            }
             if (COUNTS)
                 counts.put++;
-            const res = b.put(tgt, x, sc.complement);
-            sc.complement = res.complement;
-            wbStateful[sTop++] = cur;
-            const u = res.update;
+            // `put` sees the last-read complement (+ fresh source) and may mutate it;
+            // it returns just the scalar update (or SKIP).
+            const u = b.put(tgt, x, sc);
             if (u !== SKIP) {
                 wbNode[top] = p;
                 wbTarget[top] = u;
@@ -1380,30 +1293,13 @@ function writeBack(node, target) {
             let out;
             if (sc !== undefined) {
                 const vals = new Array(n);
-                let ver = 0;
-                for (let i = 0; i < n; i++) {
+                for (let i = 0; i < n; i++)
                     vals[i] = parents[i].value;
-                    ver += parents[i].version;
-                }
-                // Refresh the complement only if a source moved since the last sync — e.g.
-                // a prior sibling co-writer bumped a shared source. A pure own re-write
-                // (sum unchanged) skips it: `bwd` already gets the settled complement.
-                if (ver !== sc.stamp) {
-                    if (COUNTS)
-                        counts.step++;
-                    sc.complement = sc.step(vals, sc.complement);
-                }
                 if (COUNTS)
                     counts.put++;
-                const res = b.put(tgt, vals, sc.complement);
-                const upd = res.updates;
-                // Commit `bwd`'s complement directly; it must be consistent with `updates`
-                // (no reliance on a post-write `step`). The stamp is re-set post-order (after
-                // the sources are written and their versions bumped) so the next forward read
-                // sees an unchanged sum and skips `step` — own-write provenance.
-                sc.complement = res.complement;
-                wbStateful[sTop++] = cur;
-                out = upd;
+                // `put` sees the last-read complement (+ fresh sources) and may mutate it;
+                // it reconstructs any current-source facts it needs from `vals`.
+                out = b.put(tgt, vals, sc);
             }
             else {
                 if (COUNTS)
@@ -1434,24 +1330,24 @@ function writeBack(node, target) {
             }
             continue;
         }
-        // 1→1 lens (single index-0 parent-edge).
+        // 1→1 lens (single index-0 parent-edge). A `SKIP` rejects the write: the
+        // source is left, so invalidate this view and propagate (it recomputes to old).
         if (COUNTS)
             counts.put++;
-        wbNode[top] = pe.parent;
-        wbTarget[top] = b.put(tgt);
-        top++;
-    }
-    // Post-order re-stamp: now the sources are written (versions bumped), record
-    // each on-path stateful lens's parent-version sum, so its next forward read
-    // sees an unchanged sum and skips `step`. Integers only — no `fwd`, no commit.
-    for (let i = 0; i < sTop; i++) {
-        const sc = wbStateful[i]._bwd.stateful;
-        let ver = 0;
-        for (let e = wbStateful[i].parentEdges; e !== undefined; e = e.nextParent) {
-            ver += e.parent.version;
+        {
+            const u = b.put(tgt);
+            if (u !== SKIP) {
+                wbNode[top] = pe.parent;
+                wbTarget[top] = u;
+                top++;
+            }
+            else {
+                cur.flags |= F.Dirty;
+                const subs = cur.subs;
+                if (subs !== undefined)
+                    propagate(subs, runDepth > 0, activeExcluded);
+            }
         }
-        sc.stamp = ver;
-        wbStateful[i] = undefined;
     }
 }
 /** Fold a merge's contributions once (policy; default last-writer-wins) and write
@@ -1627,10 +1523,8 @@ function flush() {
         return;
     flushing = true;
     // Error locality: one effect throwing must not strand its siblings. Drain the
-    // whole queue, catching each body; surface the first error after the queue is
-    // empty (later errors are dropped — the engine stays consistent, the user still
-    // sees a failure). A throwing body isn't re-queued (its `F.Watching` is already
-    // cleared); it re-arms on the next wake.
+    // whole queue, catching each body, and surface the first error after it empties
+    // (later errors dropped). A throwing body isn't re-queued; it re-arms on next wake.
     let err;
     let threw = false;
     try {