bireactive 0.3.0 → 0.3.2

package/dist/core/cell.js

@@ -1,78 +1,94 @@
 // cell.ts — symmetric bidirectional reactive engine.
 //
-// Forward propagation is alien-signals verbatim (link/propagate/
-// checkDirty/shallowPropagate, Dirty/Pending/Recursed flags, lazy pull).
-//
-// Backward is the SAME shape as forward — a lazy push-pull — not a second
-// engine, and it carries NO dynamic side tables: state lives on flags plus two
-// STATIC adjacencies that mirror forward's `deps`/`subs`. The lens graph is
-// stored both ways at construction: `_bwd.parent` is the down edge (a view's
-// declared parents, the dual of `deps`) and `_lensSubs` is its transpose, the
-// up edge (a cell's direct lens-children, the dual of `subs`). Backward is then
-// the forward engine run on this reverse graph — one traversal each direction:
+// 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:
 //
 //   role            forward (source → view)      backward (view → source)
-//   ----            ------------------------      ------------------------
-//   down edge       subs (who reads me)          _bwd.parent (my parents)
-//   up edge         deps (my deps)               _lensSubs (my lens-children)
-//   push (mark)     propagate (down `subs`)      markDown (down `_bwd.parent`)
-//   pull (resolve)  checkDirty (up `deps`)       resolveCone (up `_lensSubs`)
+//   down edge       subs (who reads me)          parentEdges (my parents)
+//   up edge         deps (my deps)               childEdges (my lens-children)
+//   push (mark)     propagate (down `subs`)      markDown (down `parentEdges`)
+//   pull (resolve)  checkDirty (up `deps`)       resolveCone (up `childEdges`)
 //   commit/compute  _update / getter             writeBack
 //   "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 — the two
-// engines never share a bit, so a forward reset can't disturb a back-write.
-//
-// Forward: a source write PUSHES dirtiness down the cone (`Pending`, cheap
-// flagging) and the value is PULLED up on read (`checkDirty` ascends `deps` to
-// the `Dirty` source). Backward is the exact dual. A write to a view PUSHES
-// (`markDown`): stash the `target` on the view itself (`pendingValue` +
-// `BF.Dirty`, the dual of a source's `F.Dirty`), descend the static backward
-// path flagging each node down to its sources `BF.Pending` (the dual of
-// `F.Pending`), and wake each source's forward cone so observers re-fire. No `put`
-// runs, no source moves. The work is PULLED per read, source-CENTRIC: a read
-// that reaches a back-marked cell `backResolve`s — for a source directly, or by
-// DESCENDING a view's marked back-path to its sources first. Each source then
-// `resolveCone`s: ASCEND `_lensSubs` through the `BF.Pending` cone to the armed
-// views (the dual of `checkDirty` ascending `deps`) and `writeBack` each,
-// applying its lens's `put` and staging the source via the SAME forward
-// `_writeSource`. A source reflects ALL its writers (they compose into one
-// committed value), so a source's cone resolves together and commits once.
-// Because resolution follows only the sources the read DEPENDS on, reading one
-// chain leaves unrelated sources armed (GRANULAR — does only the work a read
-// demands); overlapping co-writers on a shared source all compose; an
-// UNOBSERVED write does no backward work; re-writing a view before any read
-// keeps only the last target. Reads pull at clean entry points
-// (getter top, source `_update`/`_writeSource`, effect `_run`) — never
-// mid-compute, so a source-reading `put` never re-enters a half-computed cell.
-// Views are never sticky (a view is always `get(source)`; lossy lenses snap),
-// no-op deltas short-circuit via equality (the GetPut law).
-//
-// The ONE irreducibly non-dual ingredient is fan-in accumulation: where the
-// forward engine broadcasts one source to N readers, the backward engine
-// ACCUMULATES N contributors into one value (the transpose of fan-out). A
-// `merge` folds POST-ORDER inside `resolveCone`: its contributors are resolved
-// first (each cascades a `put` into the node's `MergeNode`), then it folds ONCE
-// by the node's policy (default last-writer-wins) and writes to its parent — the
-// dual of a forward getter reading its deps then computing. Everything else —
-// 1→1 chains, multi-parent splits (1→N / N→M, e.g. mean/diff), complement-
-// carrying stateful lenses — resolves during the walk.
+// 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 — a cell's role is fully determined by which fields are set:
-//   source      getter undefined                 (truth in currentValue)
-//   derived    getter, no _bwd                   (read-only derived)
-//   lens 1→1    getter + _bwd{ put, parent: Cell }
-//   multi-out   getter + _bwd{ put, parent: Cell[] }   (1→N / N→M bwd)
-//   merge       getter + _bwd{ merge }            (N→1 backward fold)
-//   stateful    getter + _bwd{ put, parent, stateful } (complement-carrying)
-// A cell is writable iff `_bwd !== undefined` (the backward sidecar; see
-// `BwdSpec`). `pendingValue` is a source's staged forward write only; a getter
-// cell never uses it.
-// Forward flag bits (alien-signals v2), on `flags`. Backward state lives in a
-// SEPARATE word (`bflags`, `BF` below) so the two engines never share a bit: a
-// forward recompute that resets `flags` can't disturb a pending back-write, and
-// vice versa — the duals are fully decoupled (no preservation hacks).
+// Mode table — `getter`/`_bwd` fix forward/writable; the backward shape is read off
+// `_bwd` field presence (`merge` / `stateful` / `parentEdges` / `scatter`):
+//   source      getter undefined                       (truth in currentValue)
+//   derived    getter, no _bwd                         (read-only derived)
+//   lens 1→1    getter + _bwd{ put }                    (scalar put)
+//   multi-out   getter + _bwd{ put, scatter }           (1→N / N→M tuple put)
+//   merge       getter + _bwd{ merge }                  (N→1 backward fold)
+//   stateful    getter + _bwd{ put, scatter, stateful } (complement-carrying)
+//   pin         getter + _bwd{} no parentEdges          (parentless sink)
+// Writable iff `_bwd !== undefined`. `pendingValue` is a source's staged write
+// (and a view's armed back-target); a derived cell never uses it forward.
+// Counts-first instrumentation: off by default, one branch per site (see _counts).
+import { COUNTS, counts } from "./_counts.js";
+// ─────────────────────────────────────────────────────────────────────────
+// Module state — mutable engine-wide variables and pooled scratch buffers.
+// Every pool is non-reentrant: forward and backward runs never nest, so one
+// shared buffer per role suffices (no per-call allocation).
+// ─────────────────────────────────────────────────────────────────────────
+let cycle = 0;
+let runDepth = 0;
+let batchDepth = 0;
+let notifyIndex = 0;
+let queuedLength = 0;
+let activeSub;
+let flushing = false;
+/** A microtask flush is queued. Effects run asynchronously (end of turn), so a
+ *  burst of writes wakes each at most once; reads stay synchronous. */
+let scheduled = false;
+/** A `Sync` watcher (a `network`) is queued: a wake flushes the whole queue
+ *  synchronously (eager solve), so a read right after the write sees post-solve
+ *  state. Writes that wake plain effects alone defer to the microtask. */
+let syncFlush = false;
+/** The running self-excluding watcher (`Exclude`-mode `Effect`), passed as
+ *  `propagate`'s `excluding` so its own writes don't re-trigger it. */
+let activeExcluded;
+const queued = [];
+/** Re-entrancy guard: during a back-resolve a `put`'s source read commits
+ *  normally but must NOT trigger a nested resolve. */
+let draining = false;
+// Pooled backward-traversal buffers (non-reentrant under `draining`, so reused
+// across calls — no per-call allocation).
+/** `backResolve` phase-1 source worklist (collect, then resolve in phase 2). */
+const backSources = [];
+/** Monotone epoch stamped onto `Cell.bEpoch` during a `backResolve` collect, so
+ *  diamonds visit each node once without a Set (the backward dual of `cycle`). */
+let backCycle = 0;
+/** `writeBack`'s explicit descent stack (depth-first, left-to-right), as two
+ *  parallel pooled columns. Non-reentrant — a `writeBack` triggers no nested
+ *  `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 = [];
+const rcEdge = [];
+const EMPTY_DIRTY = new Set();
+/** Fires on every source value-change. Backward writes reach it via `_writeSource`. */
+let writeHook;
+// ─────────────────────────────────────────────────────────────────────────
+// Internal constants & types — flag bits, mode bits, and the node/edge records.
+// ─────────────────────────────────────────────────────────────────────────
+// Forward flag bits (alien-signals v2), on `flags`.
 const F = {
     None: 0,
     Mutable: 1,
@@ -85,31 +101,34 @@ const F = {
 // Backward flag bits, on a Cell's own `bflags` word (the dual of `flags`).
 const BF = {
     None: 0,
-    /** Backward dual of `F.Dirty`: this VIEW holds an unresolved back-write target
-     *  in `pendingValue` (a getter cell never uses that field forward). The root
-     *  of a pending back-write; `writeBack` consumes the target and clears it. */
+    /** Dual of `F.Dirty`: this view holds an unresolved back-target in `pendingValue`. */
     Dirty: 1,
-    /** Backward dual of `F.Pending`: this node lies on the back-path from a
-     *  `BF.Dirty` view down to its sources. `markDown` sets it on descent; it gates
-     *  `resolveCone`, which ascends `_lensSubs` only through `BF.Pending` nodes (so
-     *  a read resolves only its own back-cone), and `writeBack` clears it on the
-     *  way back down. */
+    /** Dual of `F.Pending`: this node is on the back-path to its sources. */
     Pending: 2,
+    /** Static (set once at construction): a write armed here is structurally
+     *  impossible — its mandatory back-spine dead-ends at a sole read-only-derived
+     *  parent. Checked atop `arm` so the throw lands before any backward mutation. */
+    WriteBlocked: 4,
 };
-// Named mask (legibility): a cell's whole backward state in one test.
 /** Armed root OR on a back-path — i.e. a read must `backResolve` first. */
 const BACK_MARKED = BF.Dirty | BF.Pending;
-/** Multi-out / stateful back-write sentinel: "leave this parent untouched."
- *  A `bwd` returning per-parent updates yields `SKIP` for a parent it declines
- *  to write; every other slot value is written verbatim — INCLUDING `undefined`,
- *  which is a first-class cell value, not a hole. A SHORT array skips the trailing
- *  parents (so writing only the leading few needs no `SKIP` padding); `[]` skips
- *  all. (Single-out 1→1 `put` has no skip notion: it always writes its one parent,
- *  so it stays `undefined`-safe by construction.) */
-export const SKIP = Symbol("bireactive.SKIP");
-// Mode predicates — the single place a cell's role is read off its fields (see
-// the mode table by `BwdSpec`). V8 inlines these; the backward walk reads them
-// instead of duplicating `getter`/`_bwd` field probes.
+// Effect mode bits (on `Effect.mode`), so one watcher class serves both plain
+// effects (`None`) and `network()` (which sets these).
+const EM = {
+    None: 0,
+    /** Explicit topology: body reads don't auto-subscribe (no re-link / purge). */
+    NoTrack: 1,
+    /** Self-exclude the node's own writes (set `activeExcluded` during the body). */
+    Exclude: 2,
+    /** A wake forces a synchronous flush (eager solve), vs the microtask default. */
+    Sync: 4,
+    /** Don't auto-fire on a wake; only an explicit `flush()` advances the body. */
+    Manual: 8,
+};
+// ─────────────────────────────────────────────────────────────────────────
+// Internal helpers — mode predicates, edge wiring, and the write-hook installer.
+// ─────────────────────────────────────────────────────────────────────────
+// Mode predicates — the single place a cell's role is read off its fields.
 /** Source (truth leaf): no forward derivation. */
 function isSource(c) {
     return c.getter === undefined;
@@ -118,68 +137,100 @@ function isSource(c) {
 function isWritable(c) {
     return c._bwd !== undefined;
 }
-/** Read-only derived: a `derive` with no backward path. A split routes around
- *  it; a sole parent has nowhere to land (the back-walk throws). */
+/** Read-only derived: a `derive` with no backward path (back-walk throws on it). */
 function isReadOnlyDerived(c) {
     return !isSource(c) && !isWritable(c);
 }
-/** Forward primal a source-reading `bwd` linearizes at, WITHOUT a cascading
- *  recompute (the lazy dual of reverse-mode AD reusing a stored linearization
- *  point). Source or realized derived → its live/last-settled value (PutGet
- *  holds for any source state, so a stale primal still round-trips); unrealized
- *  derived (`Dirty`) → realize once via `.value`, seeding `currentValue`. */
+/** 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). */
 function backPrimal(c) {
     if (c.getter === undefined || c.flags & F.Dirty)
         return c.value;
     return c.currentValue;
 }
-/** Register `node` on each backward parent's `_lensSubs` (the edge `resolveCone`
- *  ascends), once, lazily on the first back-write — so a lens only ever read
- *  forward never allocates it. Idempotent via `_linkedBack`; persists for life. */
-function linkBack(node) {
-    if (node._linkedBack)
-        return;
-    node._linkedBack = true;
-    const parent = node._bwd.parent; // set for every mode except `pin` (parentless)
-    if (parent === undefined)
+/** 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. */
+function linkLens(child, parent, index) {
+    const e = {
+        index,
+        parent,
+        child,
+        linked: false,
+        nextParent: undefined,
+        prevChild: undefined,
+        nextChild: undefined,
+    };
+    if (child.parentEdgesTail !== undefined)
+        child.parentEdgesTail.nextParent = e;
+    else
+        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`. */
+function linkChild(e) {
+    if (e.linked)
         return;
-    if (Array.isArray(parent))
-        for (let i = 0; i < parent.length; i++)
-            (parent[i]._lensSubs ??= []).push(node);
+    if (COUNTS)
+        counts.linkChild++;
+    e.linked = true;
+    const parent = e.parent;
+    e.prevChild = parent.childEdgesTail;
+    if (parent.childEdgesTail !== undefined)
+        parent.childEdgesTail.nextChild = e;
     else
-        (parent._lensSubs ??= []).push(node);
+        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. */
+function unlinkChild(e) {
+    if (COUNTS)
+        counts.unlinkChild++;
+    const { parent, prevChild, nextChild } = e;
+    if (nextChild !== undefined)
+        nextChild.prevChild = prevChild;
+    else
+        parent.childEdgesTail = prevChild;
+    if (prevChild !== undefined)
+        prevChild.nextChild = nextChild;
+    else
+        parent.childEdges = nextChild;
+    e.linked = false;
+    e.prevChild = undefined;
+    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. */
+function setWriteBlocked(cell) {
+    const pe = cell.parentEdges;
+    if (pe === undefined)
+        return; // parentless sink (pin): absorbs, never dead-ends
+    const sole = pe.nextParent === undefined;
+    for (let e = pe; e !== undefined; e = e.nextParent) {
+        const p = e.parent;
+        if (isReadOnlyDerived(p)) {
+            if (sole) {
+                cell.bflags |= BF.WriteBlocked; // markDown would throw at this dead-end
+                return;
+            }
+        }
+        else if (p.bflags & BF.WriteBlocked) {
+            cell.bflags |= BF.WriteBlocked; // a descended parent dead-ends deeper
+            return;
+        }
+    }
 }
-let cycle = 0;
-let runDepth = 0;
-let batchDepth = 0;
-let notifyIndex = 0;
-let queuedLength = 0;
-let activeSub;
-let flushing = false;
-/** A microtask is queued to flush the effect queue. Effects run ASYNCHRONOUSLY
- *  (end of the current microtask turn), so a burst of synchronous writes wakes
- *  each effect at most once — no `batch()` needed for coalescing. Reads stay
- *  synchronous and pull-based (a `.value` reflects writes immediately); only
- *  EFFECT side-effects defer. `settle()` forces a synchronous flush. */
-let scheduled = false;
-/** A `network` (constraint solver / explicit reactive sub-DAG) is in the queue.
- *  Networks are EAGER — a write that wakes one flushes the whole queue
- *  synchronously, so a read right after the write sees post-solve state (and any
- *  effect woken alongside runs after the network, in queue order). Only writes
- *  that wake effects ALONE defer to the microtask. */
-let networkQueued = false;
-/** Network running its body, if any. Source writes self-exclude it so a
- *  network reading+writing a cell doesn't re-trigger itself. */
-let activeNetwork;
-const queued = [];
-/** Re-entrancy guard: while a back-resolve runs, a `put`'s source read commits
- *  normally (in-order composition) but must NOT trigger a nested resolve. */
-let draining = false;
-const EMPTY_DIRTY = new Set();
-// Fires on every SOURCE value-change (the one place truth mutates).
-// Backward writes reach it via `_writeSource`, attributing lens edits to
-// the source they resolve to.
-let writeHook;
 /** Install a hook fired on every source value-change; returns a restore fn. */
 export function setCellWriteHook(fn) {
     const prev = writeHook;
@@ -188,6 +239,9 @@ export function setCellWriteHook(fn) {
         writeHook = prev;
     };
 }
+// ─────────────────────────────────────────────────────────────────────────
+// Forward graph engine (internal) — alien-signals verbatim.
+// ─────────────────────────────────────────────────────────────────────────
 // alien-signals algorithm (verbatim): link / unlink / propagate / checkDirty.
 function link(dep, sub, version) {
     const prevDep = sub.depsTail;
@@ -202,6 +256,8 @@ function link(dep, sub, version) {
     const prevSub = dep.subsTail;
     if (prevSub !== undefined && prevSub.version === version && prevSub.sub === sub)
         return;
+    if (COUNTS)
+        counts.link++;
     const isFirstSub = dep.subs === undefined;
     const newLink = (sub.depsTail =
         dep.subsTail =
@@ -232,6 +288,8 @@ function link(dep, sub, version) {
     }
 }
 function unlink(l, sub = l.sub) {
+    if (COUNTS)
+        counts.unlink++;
     const { dep, prevDep, nextDep, nextSub, prevSub } = l;
     if (nextDep !== undefined)
         nextDep.prevDep = prevDep;
@@ -252,13 +310,14 @@ function unlink(l, sub = l.sub) {
     return nextDep;
 }
 function propagate(start, innerWrite, excluding) {
+    if (COUNTS)
+        counts.propagate++;
     let l = start;
     let next = start.nextSub;
     let stack;
     top: do {
         const sub = l.sub;
-        // `excluding` skips one subscriber (used by `network()` so a body
-        // writing a cell it subscribes to doesn't re-trigger itself).
+        // `excluding` skips one subscriber (a `network` not re-triggering itself).
         if (sub !== excluding) {
             let flags = sub.flags;
             if (!(flags & (F.RecursedCheck | F.Recursed | F.Dirty | F.Pending))) {
@@ -309,6 +368,8 @@ function propagate(start, innerWrite, excluding) {
     } while (true);
 }
 function checkDirty(startLink, startSub) {
+    if (COUNTS)
+        counts.checkDirty++;
     let l = startLink, sub = startSub;
     let stack;
     let checkDepth = 0, dirty = false;
@@ -318,11 +379,10 @@ function checkDirty(startLink, startSub) {
         if (sub.flags & F.Dirty)
             dirty = true;
         else if ((flags & (F.Mutable | F.Dirty)) === (F.Mutable | F.Dirty) ||
-            // A back-`Pending` SOURCE (leaf: no getter) looks unchanged until its
-            // back-write resolves; `_update` resolves it (pulls its registered views,
-            // runs the `put`s), then reports whether it moved — like a forward-`Dirty`
-            // source. Intermediate views are also back-`Pending`, but they have a
-            // getter and fall through to the `Pending` recurse below.
+            // A back-`Pending` source looks unchanged until `_update` resolves it
+            // (pulls its views, runs the `put`s, stages it) and reports if it moved —
+            // like a `Dirty` source. That resolve can re-mark nodes on this pull's
+            // stack; the unwind below honors any such `F.Dirty`.
             (flags & F.Mutable &&
                 dep.bflags & BF.Pending &&
                 isSource(dep))) {
@@ -350,12 +410,9 @@ function checkDirty(startLink, startSub) {
         while (checkDepth--) {
             l = stack.value;
             stack = stack.prev;
-            // `dirty` tracks change down THIS branch, but a node may have been marked
-            // `F.Dirty` independently — `shallowPropagate` fires when a lazy back-write
-            // commits its source mid-`checkDirty` (a hazard a forward-only engine never
-            // sees, since sources commit before the pull). Honor that bit too, else we'd
-            // clear its `F.Pending` below without recomputing — stranding a `Dirty` node
-            // whose observers never re-run.
+            // `dirty` tracks change down this branch, but a node may have been marked
+            // `F.Dirty` independently (a stateful stash `writeBack` mid-pull) — honor
+            // that too, else we'd clear its `F.Pending` without recomputing.
             if (dirty || sub.flags & F.Dirty) {
                 const subs = sub.subs;
                 if (sub._update()) {
@@ -416,62 +473,49 @@ function disposeAllDepsInReverse(sub) {
 }
 class MergeNode {
     foldFn;
-    /** Contributions gathered as this merge's cone resolves; folded and cleared
-     *  in `foldMerge` (the merge-owned buffer, mutated in place). The parent it
-     *  writes to is just `b.parent` (a merge's `b.parent` IS its fold target), so
-     *  this node carries only the policy + buffer — no duplicate edge. */
+    /** Contributions gathered as the cone resolves; folded and cleared in `foldMerge`. */
     contributions = [];
     constructor(fold) {
         this.foldFn = fold;
     }
 }
-// BwdSpec — the backward sidecar.
-//
-// Every cell carries the forward fields (links, getter, value cache).
-// Only a WRITABLE derived cell — 1→1 lens, multi-output lens, merge,
-// stateful lens, or `pin` — needs a backward target and the closures to
-// drive it. Those fields live here, off a single `_bwd` pointer, rather
-// than inline on `Cell`, so a source/computed stays lean: the forward hot
-// path never touches them, and a plain node drops ~64 B. A cell is
-// writable iff `_bwd !== undefined`.
-//
-// Two mode payloads hang off named fields rather than one union, so each
-// stays distinctly typed: `merge` (the N→1 fold node) and `stateful` (the
-// complement machinery of a complement-carrying lens). Both are rare, so
-// a plain 1→1 / multi-out lens leaves them `undefined` and pays only
-// `parent` + `put`.
+// 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`.
 class BwdSpec {
-    /** Backward target(s): one `Cell` (1→1 / merge) or `Cell[]` (multi-out). */
-    parent = undefined;
-    /** Lens `put` — backward derivation (dual of `getter`). A 1→1 / multi-out
-     *  lens is called as `put(target)` (a source-reading lens reads the current
-     *  parent(s) at walk time, untracked); multi-out returns a per-parent update
-     *  array. Stateful is the spec's `bwd`, called `put(target, sources, c)`. */
+    /** 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). */
     // biome-ignore lint/suspicious/noExplicitAny: put fn is opaque shape
     put = undefined;
-    /** Backward aggregation node; presence IS the merge-mode discriminant. */
+    /** Fold payload; present ⇒ a fan-in merge. */
     merge = undefined;
-    /** Complement machinery; presence IS the stateful-mode discriminant. */
+    /** Complement state; present ⇒ a complement-carrying (stateful) lens. */
     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 stateful (complement-carrying) lens — the rare
- *  backward mode, kept off `BwdSpec` so plain lenses don't carry its slots.
- *  `put` (the spec's `bwd`) and `parent` stay on `BwdSpec`; this holds the
- *  complement and the closures that project from / advance it. */
+/** 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, external)`. (The
-     *  forward projection `fwd` is captured directly in the getter closure — it
-     *  is only ever read there — so it costs no slot here.) */
+    /** 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;
-    /** Sources this lens last committed back (the own-vs-external test compares
-     *  live sources against these); `undefined` until the first back-write. A
-     *  back-write reads the live sources into a fresh array, builds the committed
-     *  candidate in place, and keeps it as `last` for the next own-vs-external
-     *  comparison. */
-    last = undefined;
+    /** 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) {
@@ -479,6 +523,13 @@ class StatefulCore {
         this.step = step;
     }
 }
+// ─────────────────────────────────────────────────────────────────────────
+// Public API — sentinels, read/write shapes, and value-coercion helpers.
+// ─────────────────────────────────────────────────────────────────────────
+/** Multi-out / stateful back-write sentinel: "leave this parent untouched."
+ *  Every non-`SKIP` slot is written verbatim, `undefined` included; a short array
+ *  skips the trailing parents. (1→1 `put` always writes its one parent.) */
+export const SKIP = Symbol("bireactive.SKIP");
 /** Snapshot a `Val<T>` to plain `T` (one-shot, no tracking). */
 export function readNow(v) {
     if (v instanceof Cell)
@@ -508,6 +559,9 @@ export const isCell = (v) => v instanceof Cell;
 export const isLens = (v) => v instanceof Cell && v.getter !== undefined && v._bwd !== undefined;
 /** Read-only mode: derived with no backward path. */
 export const isReadonly = (v) => v instanceof Cell && v.getter !== undefined && v._bwd === undefined;
+// ─────────────────────────────────────────────────────────────────────────
+// Public API — the Cell class (the one user-facing reactive primitive).
+// ─────────────────────────────────────────────────────────────────────────
 export class Cell {
     /** @internal */
     flags;
@@ -533,14 +587,28 @@ export class Cell {
     pendingValue;
     /** @internal Backward sidecar; `undefined` iff read-only. Writability is `_bwd !== undefined`. */
     _bwd;
-    /** @internal Backward dual of `subs`: direct lens-children for back-write cone traversal. */
-    _lensSubs;
+    /** @internal Lens-edges to my back-targets (down); dual of `deps`. `markDown`/
+     *  `backResolve` descend this toward sources. Index-ordered. */
+    parentEdges;
+    /** @internal */
+    parentEdgesTail;
+    /** @internal Lens-edges to my lens-children (up); dual of `subs`. `resolveCone`
+     *  ascends this toward the armed views. */
+    childEdges;
+    /** @internal */
+    childEdgesTail;
     /** @internal Backward flag word (`BF`), dual of forward `flags`. */
     bflags;
-    /** @internal Guards against `linkBack` re-registering a duplicate in `_lensSubs`. */
-    _linkedBack;
-    // Every slot is assigned exactly once below, in declaration order, for a stable
-    // V8 hidden class across all variants (source / computed / lens / merge).
+    /** @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.
     constructor(initial, opts) {
         this.flags = F.Mutable;
         this.subs = undefined;
@@ -554,9 +622,14 @@ export class Cell {
         this.currentValue = initial;
         this.pendingValue = initial;
         this._bwd = undefined;
-        this._lensSubs = undefined;
+        this.parentEdges = undefined;
+        this.parentEdgesTail = undefined;
+        this.childEdges = undefined;
+        this.childEdgesTail = undefined;
         this.bflags = BF.None;
-        this._linkedBack = false;
+        this.bEpoch = 0;
+        this.version = 0;
+        this.name = undefined;
         if (opts !== undefined) {
             if (opts.equals !== undefined)
                 this._equals = opts.equals;
@@ -564,23 +637,28 @@ export class Cell {
                 this._watched = opts.watched;
             if (opts.unwatched !== undefined)
                 this._unwatchedHook = opts.unwatched;
+            if (opts.name !== undefined)
+                this.name = opts.name;
         }
     }
     /** @internal Single write-commit point; self-excludes the active network. */
     _writeSource(next) {
-        // A forward write to a source with an unresolved back-write demand resolves
-        // it FIRST, so the later forward write wins (LWW).
+        // Resolve any pending back-write first, so the later forward write wins (LWW).
         if (this.bflags & BF.Pending && !draining)
             backResolve(this);
         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) {
-                propagate(subs, runDepth > 0, activeNetwork);
+                // 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.
+                propagate(subs, runDepth > 0, activeExcluded);
                 autoFlush();
             }
         }
@@ -588,6 +666,8 @@ export class Cell {
     /** @internal */
     _update() {
         if (this.getter !== undefined) {
+            if (COUNTS)
+                counts.recompute++;
             this.depsTail = undefined;
             this.flags = F.Mutable | F.RecursedCheck;
             const prev = activeSub;
@@ -598,7 +678,10 @@ export class Cell {
                 const old = this.currentValue;
                 const next = (this.currentValue = this.getter());
                 threw = false;
-                return !this._equals(old, next);
+                const changed = !this._equals(old, next);
+                if (changed)
+                    this.version++; // derived commit: stamp for stateful provenance
+                return changed;
             }
             finally {
                 activeSub = prev;
@@ -606,10 +689,8 @@ export class Cell {
                 purgeDeps(this);
             }
         }
-        // A back-`Pending` source first resolves its armed back-write (`backResolve`
-        // pulls the views registered on it, runs the `put`s, stages it via
-        // `_writeSource`) — so its `pendingValue` reflects the back-write before we
-        // commit it.
+        // A back-`Pending` source resolves its armed back-write first, so
+        // `pendingValue` reflects it before we commit.
         if (this.bflags & BF.Pending && !draining)
             backResolve(this);
         this.flags = F.Mutable;
@@ -621,6 +702,17 @@ 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.
+        if (!(this.bflags & BACK_MARKED)) {
+            for (let e = this.parentEdges; e !== undefined; e = e.nextParent) {
+                if (e.linked)
+                    unlinkChild(e);
+            }
+        }
         if (this.getter !== undefined && this.depsTail !== undefined) {
             this.flags = F.Mutable | F.Dirty;
             disposeAllDepsInReverse(this);
@@ -641,22 +733,29 @@ export class Cell {
     }
     // Construction helpers build via `new this()` so a subclass static
     // (`Vec.lens(...)`) yields a `Vec` with its constructor-set equality.
-    // Every lens has a structural backward target (`_bwd.parent`), which is
-    // what makes the backward pass well-defined.
     /** 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 buildLens1(this.constructor, this, fwd, bwd, bwd.length >= 2);
+        return buildLens(this.constructor, [this, fwd, bwd]);
     }
     /** 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));
     }
-    /** Backward fan-in node. Forward, the identity view of its parent;
-     *  backward, the convergence point where N contributors (upstream lenses
-     *  and direct writes) fold into one value for the parent. `fold` is handed
-     *  every live push at once; omitted, it is last-writer-wins. */
+    // 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) {
         if (this.getter !== undefined && this._bwd === undefined) {
             throw new TypeError("merge: receiver is read-only");
@@ -666,27 +765,26 @@ export class Cell {
         cell.flags = F.Mutable | F.Dirty;
         cell.getter = () => parent.value;
         const b = (cell._bwd = new BwdSpec());
-        b.parent = parent;
         b.merge = new MergeNode(fold);
+        linkLens(cell, parent, 0);
+        setWriteBlocked(cell);
         return cell;
     }
     // biome-ignore lint/suspicious/noExplicitAny: dispatch
     static derive(...args) {
-        return dispatchDerive(this, args);
+        return buildDerive(this, args);
     }
     // biome-ignore lint/suspicious/noExplicitAny: dispatch
     static lens(...args) {
-        return dispatchLens(this, args);
+        return buildLens(this, args);
     }
     /** Type predicate against this class: `Vec.is(x)` narrows `x` to `Vec`.
      *  Inherited static; works for any subclass via polymorphic `this`. */
-    // biome-ignore lint/suspicious/noExplicitAny: variance escape
     static is(v) {
         return v instanceof this;
     }
     /** Coerce `Val<Inner<Cls>>` → `Cls`: instance → identity, RO cell →
      *  tracked `derive`, literal → fresh seed. */
-    // biome-ignore lint/suspicious/noExplicitAny: variance escape
     static coerce(v) {
         if (v instanceof this)
             return v;
@@ -698,20 +796,17 @@ export class Cell {
     }
     /** Writable-shaped constant: always reads `v`, absorbs writes
      *  (parentless sink lens), for APIs demanding bidirectionality. */
-    // biome-ignore lint/suspicious/noExplicitAny: variance escape
     static pin(v) {
         const cell = new this();
         cell.flags = F.Mutable | F.Dirty;
         cell.getter = () => v;
-        // Parentless `_bwd`: `writeBack` absorbs at `parent === undefined` before any
-        // `put`, so the sink needs no closure — writability is just `_bwd !== undefined`.
+        // Parentless `_bwd`: `writeBack` absorbs it (no parent edges, no closure).
         cell._bwd = new BwdSpec();
         return cell;
     }
 }
 /** Typed field lens onto `parent.value[key]`. RO parent → RO derive;
  *  writable parent → bidirectional lens with spread-replace `put`. */
-// biome-ignore lint/suspicious/noExplicitAny: variance escape
 export function fieldOf(
 // biome-ignore lint/suspicious/noExplicitAny: parent is contravariant on put
 parent, key, Cls) {
@@ -721,7 +816,17 @@ parent, key, Cls) {
     if (ro) {
         return buildDerived(ctor, () => get(parent.value));
     }
-    return buildLens1(ctor, parent, get, (v, s) => ({ ...s, [key]: v }), true);
+    // Spread-replace put, array-aware: cloning an array with object spread would
+    // demote it to a plain record, so copy via `slice` and set the index.
+    const put = (v, s) => {
+        if (Array.isArray(s)) {
+            const next = s.slice();
+            next[key] = v;
+            return next;
+        }
+        return { ...s, [key]: v };
+    };
+    return buildLens(ctor, [parent, get, put]);
 }
 // biome-ignore lint/suspicious/noExplicitAny: variance escape
 function buildDerived(Cls, getter) {
@@ -730,50 +835,95 @@ function buildDerived(Cls, getter) {
     cell.flags = F.Mutable | F.Dirty;
     return cell;
 }
-// biome-ignore lint/suspicious/noExplicitAny: variance escape
-function buildLens1(Cls, parent, fwd, bwd, readsSource) {
-    const cell = new Cls();
-    cell.flags = F.Mutable | F.Dirty;
-    cell.getter = (() => fwd(parent.value));
-    const b = (cell._bwd = new BwdSpec());
-    // Source-reading lenses linearize at the parent's primal (`backPrimal`: the
-    // last-settled value for a derived, the staged truth for a source) so the
-    // engine always calls the 1-arg form (no arity branch) and never recomputes a
-    // derived parent's cone just to read it back.
-    b.put = readsSource ? (t) => bwd(t, backPrimal(parent)) : bwd;
-    b.parent = parent;
-    return cell;
-}
-// biome-ignore lint/suspicious/noExplicitAny: variance escape
-function buildLensN(Cls, parents, fwd, bwd, readsSource) {
+// 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.
+function arrayGetter(parents, fwd) {
     const n = parents.length;
     const vals = new Array(n);
-    const cell = new Cls();
-    cell.flags = F.Mutable | F.Dirty;
-    cell.getter = (() => {
+    return () => {
         for (let i = 0; i < n; i++)
             vals[i] = parents[i].value;
         return fwd(vals);
-    });
-    if (bwd === undefined)
-        return cell; // read-only derive-N
-    const b = (cell._bwd = new BwdSpec());
-    b.parent = parents;
-    if (readsSource) {
-        // Own reused buffer, NOT the getter's `vals`: the walk reads each parent's
-        // primal (`backPrimal`), so a separate array avoids aliasing the getter's.
-        // `bwd` consumes it synchronously and must not retain it (same as `fwd`);
-        // re-entry through the same lens is impossible (the lens graph is a DAG).
-        const args = new Array(n);
-        b.put = (target) => {
-            for (let i = 0; i < n; i++)
-                args[i] = backPrimal(parents[i]);
-            return bwd(target, args);
+    };
+}
+// 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;
+    const cell = new Cls();
+    cell.flags = F.Mutable | F.Dirty;
+    const b = (cell._bwd = new BwdSpec());
+    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);
+            };
+        }
+        else {
+            const bwd0 = bwd;
+            b.put = (target) => bwd0(target);
+        }
     }
     else {
-        b.put = (target) => bwd(target);
+        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);
     }
+    setWriteBlocked(cell);
     return cell;
 }
 // biome-ignore lint/suspicious/noExplicitAny: variance escape
@@ -788,36 +938,41 @@ spec) {
     const seed = new Array(n);
     for (let i = 0; i < n; i++)
         seed[i] = parents[i].peek();
-    const sc = (b.stateful = new StatefulCore(spec.init(seed), spec.step));
+    // 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;
-    b.parent = parents;
+    b.scatter = true;
+    for (let i = 0; i < n; i++)
+        linkLens(cell, parents[i], i);
     cell.getter = (() => {
-        for (let i = 0; i < n; i++)
+        let ver = 0;
+        for (let i = 0; i < n; i++) {
             vals[i] = parents[i].value;
-        // External unless the live sources still equal this lens's own last
-        // back-write.
-        let external = true;
-        const lb = sc.last;
-        if (lb !== undefined) {
-            external = false;
-            for (let i = 0; i < n; i++) {
-                if (vals[i] !== lb[i]) {
-                    external = true;
-                    break;
-                }
-            }
+            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;
         }
-        sc.complement = sc.step(vals, sc.complement, external);
         return fwd(vals, sc.complement);
     });
+    setWriteBlocked(cell);
     return cell;
 }
-// Single-source stateful lens: the `buildLens1` of the complement path.
-// Drops the per-read copy/external loops to direct index-0 access; the
-// spec stays array-shaped (`init: ([s]) => …`), so a reused length-1
-// `vals` still feeds the closures and `b.parent` stays an array for the
-// shared split backward path.
+// 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.
 // biome-ignore lint/suspicious/noExplicitAny: variance escape
 function buildStateful1(Cls, parent, 
 // biome-ignore lint/suspicious/noExplicitAny: opaque spec
@@ -825,61 +980,54 @@ spec) {
     const cell = new Cls();
     cell.flags = F.Mutable | F.Dirty;
     const b = (cell._bwd = new BwdSpec());
-    const sc = (b.stateful = new StatefulCore(spec.init([parent.peek()]), spec.step));
+    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;
-    b.parent = [parent];
-    const vals = [undefined];
+    // `scatter` stays false: writeBack routes this through the scalar stateful branch.
+    linkLens(cell, parent, 0);
     cell.getter = (() => {
-        const v = (vals[0] = parent.value);
-        const lb = sc.last;
-        const external = lb === undefined || lb[0] !== v;
-        sc.complement = sc.step(vals, sc.complement, external);
-        return fwd(vals, sc.complement);
+        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);
     });
+    setWriteBlocked(cell);
     return cell;
 }
-// Shared runtime dispatch for `derive`/`lens`, parameterized by the cell
-// constructor: the polymorphic-`this` statics pass the typed subclass
-// (`Vec.derive` → Vec), the free functions pass the plain `Cell`. One body
-// each so the static and free forms can't drift (typed overloads live at
-// the call sites; only these `any` runtime bodies are shared).
-// biome-ignore lint/suspicious/noExplicitAny: dispatch
-function dispatchDerive(ctor, args) {
+// 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.)
+// biome-ignore lint/suspicious/noExplicitAny: dispatch over the untyped call forms
+function buildDerive(Cls, args) {
     if (args.length === 1)
-        return buildDerived(ctor, args[0]);
-    const [parent, fn] = args;
+        return buildDerived(Cls, args[0]);
+    const parent = args[0];
+    const fn = args[1];
     if (Array.isArray(parent))
-        return buildLensN(ctor, parent, fn, undefined, false);
-    return buildDerived(ctor, () => fn(parent.value));
+        return buildDerived(Cls, arrayGetter(parent, fn));
+    return buildDerived(Cls, () => fn(parent.value));
 }
-// biome-ignore lint/suspicious/noExplicitAny: dispatch
-function dispatchLens(ctor, args) {
-    const [parent, a, b] = args;
-    if (args.length === 2) {
-        const ps = Array.isArray(parent) ? parent : [parent];
-        return ps.length === 1 ? buildStateful1(ctor, ps[0], a) : buildStateful(ctor, ps, a);
-    }
-    const readsSource = b.length >= 2;
-    if (Array.isArray(parent))
-        return buildLensN(ctor, parent, a, b, readsSource);
-    return buildLens1(ctor, parent, a, b, readsSource);
-}
-// Installed on the prototype (not a class accessor): V8 JITs a prototype getter
-// better, and it keeps the field-only class shape for a stable hidden class.
+// Installed on the prototype (not a class accessor): V8 JITs it better and keeps
+// the field-only class shape for a stable hidden class.
 Object.defineProperty(Cell.prototype, "value", {
     get() {
-        // Reading is the PULL. A back-marked cell resolves at this clean entry,
-        // BEFORE its own compute, so a source-reading `put` never re-enters a
-        // half-computed cell. `backResolve` descends `_bwd` to the sources and pulls
-        // the writers registered there, touching only this cell's back-cone
-        // (granular — sibling chains untouched).
+        // Reading is the PULL: a back-marked cell resolves here, before its own
+        // compute, so a source-reading `put` never re-enters a half-computed cell.
         if (this.bflags & BACK_MARKED && !draining)
             backResolve(this);
         const flags = this.flags;
         if (this.getter !== undefined) {
             if (flags & F.RecursedCheck) {
-                throw new RangeError(`Cyclic computed: ${this.constructor.name ?? "?"} read its own value`);
+                throw new RangeError(`Cyclic computed: ${this.name ?? this.constructor.name ?? "?"} read its own value`);
             }
             if (flags & F.Dirty ||
                 (flags & F.Pending &&
@@ -918,11 +1066,10 @@ Object.defineProperty(Cell.prototype, "value", {
         if (b === undefined) {
             throw new TypeError("Cannot write to a computed");
         }
-        // GetPut for a multi-parent split: its `put` may move sources even when the
-        // view is unchanged (a lossy redistribution that `_writeSource`'s per-source
-        // equality can't catch), so absorb a write that maps to the current view
-        // here. (Stateful excluded — peeking would step its complement.)
-        if (Array.isArray(b.parent) && b.stateful === undefined && this._equals(next, this.peek())) {
+        // 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.
+        if (b.scatter && b.stateful === undefined && this._equals(next, this.peek())) {
             return;
         }
         arm(this, next);
@@ -930,32 +1077,43 @@ Object.defineProperty(Cell.prototype, "value", {
     enumerable: false,
     configurable: false,
 });
-/** Backward push: arm a back-write of `target` on view `node` (the dual of a
- *  source `set`). A re-write of a still-armed view (an unobserved drag) keeps
- *  only the last target — the path down to the sources is already marked, so
- *  skip the walk and coalesce. The trailing `schedule` wakes the effects the
- *  push woke (on the microtask turn); each effect's read pulls its own cone. */
+// ─────────────────────────────────────────────────────────────────────────
+// Backward graph engine (internal) — arm / markDown / resolveCone / writeBack.
+// ─────────────────────────────────────────────────────────────────────────
+/** Backward push: arm a back-write of `target` on view `node` (dual of a source
+ *  `set`). A re-write of a still-armed view keeps only the last target (the path
+ *  is already marked); `autoFlush` wakes the effects the push woke. */
 function arm(node, target) {
+    // Structural reject first: a write whose back-spine dead-ends throws before
+    // touching any backward state (atomic — nothing armed, nothing marked).
+    if (node.bflags & BF.WriteBlocked) {
+        if (COUNTS)
+            counts.armBlocked++;
+        throw new TypeError("Cannot write through to a computed");
+    }
+    if (COUNTS)
+        counts.arm++;
     if (!(node.bflags & BF.Dirty)) {
-        markDown(node); // flag path + wake cones, FIRST (a throw arms nothing)
+        markDown(node); // flag path + wake cones FIRST (a throw arms nothing)
         node.bflags |= BF.Dirty;
     }
-    node.pendingValue = target; // the view holds its own demand (getters ignore this field)
+    node.pendingValue = target;
     autoFlush();
 }
-/** MARK (push), dual of forward `propagate`: descend `start`'s static backward
- *  path down `_bwd.parent` to its sources, flag each node `BF.Pending`, register
- *  the reverse edge (`linkBack`), and wake every source's forward cone. Runs no
- *  `put` — an over-approximation `resolveCone` later resolves precisely.
+/** MARK (push), dual of `propagate`: descend `start`'s static back-path down
+ *  `parentEdges` to its sources, flag each `BF.Pending`, and wake every source's
+ *  forward cone. Runs no `put`.
  *
- *  `BF.Pending` is its own dedup: an already-marked node has its whole (static)
- *  subtree marked, so descent stops there (diamonds cost one visit). A merge
- *  relays to its parent; a sole read-only-derived parent has nowhere to land →
- *  throw. The 1→1 spine allocates nothing (`stack` is built only on a branch). */
+ *  `BF.Pending` self-dedups: an already-marked node has its subtree marked, so
+ *  descent stops (diamonds cost one visit). A read-only-derived parent is skipped
+ *  (a split routes around it; a sole one is pre-rejected by `arm`'s
+ *  `BF.WriteBlocked` check). The 1→1 spine allocates nothing. */
 function markDown(start) {
     let node = start;
     let stack;
     for (;;) {
+        if (COUNTS)
+            counts.markDownVisit++;
         let next;
         if (isSource(node)) {
             // Leaf (dual of a `Dirty` source): wake its cone ONCE.
@@ -963,40 +1121,26 @@ function markDown(start) {
                 node.bflags |= BF.Pending;
                 const subs = node.subs;
                 if (subs !== undefined)
-                    propagate(subs, runDepth > 0, activeNetwork);
+                    propagate(subs, runDepth > 0, activeExcluded);
             }
         }
         else if (node === start || !(node.bflags & BF.Pending)) {
-            // On the back-path (dual of a `Pending` intermediate). An already-marked
-            // intermediate (≠ start) has its subtree marked — stop (diamond dedup).
+            // On the back-path. An already-marked intermediate (≠ start) has its
+            // subtree marked — stop (diamond dedup).
             if (node !== start)
                 node.bflags |= BF.Pending;
-            linkBack(node); // register the reverse edge lazily, on first back-write
-            // `b.parent` is the back-target for EVERY mode (a merge's fold target is
-            // just its single, always-writable parent), so one descent covers all.
-            const parent = node._bwd.parent;
-            if (parent !== undefined) {
-                if (Array.isArray(parent)) {
-                    const multi = parent.length > 1;
-                    for (let i = 0; i < parent.length; i++) {
-                        const p = parent[i];
-                        if (isReadOnlyDerived(p)) {
-                            // A split routes around it; a sole parent can't.
-                            if (!multi)
-                                throw new TypeError("Cannot write through to a computed");
-                        }
-                        else if (next === undefined)
-                            next = p;
-                        else
-                            (stack ??= []).push(p);
-                    }
-                }
-                else if (isReadOnlyDerived(parent)) {
-                    throw new TypeError("Cannot write through to a computed");
-                }
-                else {
-                    next = parent;
-                }
+            for (let e = node.parentEdges; e !== undefined; e = e.nextParent) {
+                linkChild(e); // register this view on the parent's up-list (arm-order)
+                const p = e.parent;
+                // Read-only parent: a split routes around it (its `put` SKIPs it). A sole
+                // read-only parent can't be routed — but that's `BF.WriteBlocked`, already
+                // rejected in `arm`, so the descent never reaches such a node here.
+                if (isReadOnlyDerived(p))
+                    continue;
+                if (next === undefined)
+                    next = p;
+                else
+                    (stack ??= []).push(p);
             }
         }
         if (next !== undefined) {
@@ -1010,115 +1154,133 @@ function markDown(start) {
         }
     }
 }
-/** RESOLVE (pull), dual of forward `checkDirty`: resolve ONE node's whole
- *  back-cone. Ascend the static reverse adjacency `_lensSubs` (only `BACK_MARKED`
- *  children) to the armed views above, `writeBack`ing each. Source-CENTRIC — a
- *  source must reflect ALL its writers (they compose into one committed value),
- *  so a call on the source resolves every co-writer together and commits once.
- *  `BF.Dirty` is the dedup.
+/** 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.
  *
- *  Recursive so a MERGE folds POST-ORDER (the one non-dual ingredient): resolve
- *  its contributors first (each cascades a `put` into `contributions`), then fold
- *  once on the way back up and write the parent, as a getter reads deps then
- *  computes. */
-function resolveCone(node) {
+ *  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. */
+function resolveCone(root) {
+    const epoch = ++backCycle;
+    root.bEpoch = epoch;
+    enterCone(root);
+    rcNode[0] = root;
+    rcEdge[0] = root.childEdges;
+    let fp = 1;
+    while (fp > 0) {
+        let e = rcEdge[fp - 1];
+        let descended = false;
+        while (e !== undefined) {
+            const c = e.child;
+            e = e.nextChild;
+            if (c.bflags & BACK_MARKED && c.bEpoch !== epoch) {
+                c.bEpoch = epoch;
+                rcEdge[fp - 1] = e; // resume here when we pop back to this frame
+                enterCone(c);
+                rcNode[fp] = c;
+                rcEdge[fp] = c.childEdges;
+                fp++;
+                descended = true;
+                break;
+            }
+        }
+        if (descended)
+            continue;
+        // Children exhausted → post-order work for this frame's node.
+        const node = rcNode[--fp];
+        node.bflags &= ~BF.Pending;
+        const b = node._bwd;
+        // A merge has exactly one parent-edge; fold its gathered contributions to it.
+        if (b !== undefined && b.merge !== undefined)
+            foldMerge(node.parentEdges.parent, b.merge);
+    }
+}
+/** `resolveCone` pre-order work: reset a merge's buffer, drive an armed target. */
+function enterCone(node) {
+    if (COUNTS)
+        counts.resolveConeVisit++;
     const b = node._bwd;
-    const merge = b !== undefined ? b.merge : undefined;
-    if (merge !== undefined)
-        merge.contributions.length = 0; // self-heal contributions left by a prior throw
-    // Drive this node's own armed target first (composes before child writes —
-    // preserves last-writer-wins order among co-writers of a shared parent).
+    if (b !== undefined && b.merge !== undefined)
+        b.merge.contributions.length = 0;
     if (node.bflags & BF.Dirty) {
         node.bflags &= ~BF.Dirty;
         writeBack(node, node.pendingValue);
     }
-    const children = node._lensSubs;
-    if (children !== undefined) {
-        for (let i = 0; i < children.length; i++) {
-            const c = children[i];
-            if (c.bflags & BACK_MARKED)
-                resolveCone(c);
-        }
-    }
-    node.bflags &= ~BF.Pending; // resolved (idempotent with `writeBack`'s clear)
-    if (merge !== undefined)
-        foldMerge(b.parent, merge); // contributors in → fold once
 }
-/** PULL entry for a back-marked `start`. Source-centric: a source read resolves
- *  its own cone; a VIEW read first DESCENDS its marked back-path (`_bwd.parent`
- *  through `BF.Pending`) to the sources, then resolves each source's whole cone
- *  (so co-writers compose and the source commits once). The `draining` guard
- *  stops a `put`'s source read from re-entering. */
+/** PULL entry for a back-marked `start`. A source resolves its own cone; a view
+ *  first descends its marked back-path to the sources, then resolves each. The
+ *  `draining` guard stops a `put`'s source read from re-entering.
+ *
+ *  Two-phase: phase 1 collects the distinct sources (clearing nothing), phase 2
+ *  `resolveCone`s each. Capturing the full source set before any `writeBack` runs
+ *  means a sibling commit can't drop a co-writer's source from the worklist. A
+ *  per-call `bEpoch` stamp dedups the descent (diamonds visit each node once). */
 function backResolve(start) {
     draining = true;
     ++batchDepth;
     const prev = activeSub;
     activeSub = undefined;
+    const sourcesBase = backSources.length;
+    const epoch = ++backCycle;
     try {
         if (isSource(start)) {
             resolveCone(start);
+            return;
         }
-        else {
-            // Descend the marked back-path to every source, resolving each source's
-            // cone. A view with no source to land on (a `pin` sink) resolves itself.
-            let node = start;
-            let stack;
-            let reached = false;
-            for (;;) {
-                let next;
-                const b = node._bwd;
-                const parent = b !== undefined ? b.parent : undefined; // merge's parent IS b.parent
-                if (parent !== undefined) {
-                    if (Array.isArray(parent)) {
-                        for (let i = 0; i < parent.length; i++) {
-                            const p = parent[i];
-                            if (isSource(p)) {
-                                reached = true;
-                                if (p.bflags & BF.Pending)
-                                    resolveCone(p);
-                            }
-                            else if (p.bflags & BF.Pending) {
-                                if (next === undefined)
-                                    next = p;
-                                else
-                                    (stack ??= []).push(p);
-                            }
-                        }
-                    }
-                    else if (isSource(parent)) {
-                        reached = true;
-                        if (parent.bflags & BF.Pending)
-                            resolveCone(parent);
-                    }
-                    else if (parent.bflags & BF.Pending) {
-                        next = parent;
-                    }
+        // Phase 1 (collect): descend the `BF.Pending` cone, gathering distinct
+        // sources. `reached` = a source was found (else `start` is a `pin` sink).
+        let node = start;
+        let stack;
+        let reached = false;
+        for (;;) {
+            let next;
+            for (let e = node.parentEdges; e !== undefined; e = e.nextParent) {
+                const p = e.parent;
+                if (!(p.bflags & BF.Pending) || p.bEpoch === epoch)
+                    continue;
+                p.bEpoch = epoch;
+                if (isSource(p)) {
+                    reached = true;
+                    backSources.push(p);
                 }
-                if (next !== undefined)
-                    node = next;
-                else if (stack !== undefined && stack.length > 0)
-                    node = stack.pop();
+                else if (next === undefined)
+                    next = p;
                 else
-                    break;
-            }
-            if (!reached && start.bflags & BF.Dirty) {
-                start.bflags &= ~BF.Dirty;
-                writeBack(start, start.pendingValue);
+                    (stack ??= []).push(p);
             }
+            if (next !== undefined)
+                node = next;
+            else if (stack !== undefined && stack.length > 0)
+                node = stack.pop();
+            else
+                break;
+        }
+        // Phase 2 (resolve): each collected source's whole cone, once.
+        for (let i = sourcesBase; i < backSources.length; i++)
+            resolveCone(backSources[i]);
+        if (!reached && start.bflags & BF.Dirty) {
+            start.bflags &= ~BF.Dirty;
+            writeBack(start, start.pendingValue);
         }
     }
     finally {
+        backSources.length = sourcesBase;
         activeSub = prev;
         --batchDepth;
         draining = false;
     }
 }
-/** Resolve any back-write a woken reactive node reads DIRECTLY. `checkDirty`
- *  alone catches back-writes that move a source (it ascends to the source),
- *  but a stateful "stash" moves only the VIEW (the complement echoes a value
- *  back, no source changes) — invisible to a source-based check. Resolving the
- *  node's back-marked deps here makes that view-change visible before the
- *  dirtiness check. Granular: only this node's own deps. */
+/** Resolve any back-write a woken node reads directly. `checkDirty` catches
+ *  back-writes that move a source, but a stateful stash moves only the VIEW (no
+ *  source changes) — invisible to a source-based check, so resolve this node's
+ *  back-marked deps here. A forward-only wake walks no cone and pays nothing. */
 function resolveBackDeps(node) {
     for (let l = node.deps; l !== undefined; l = l.nextDep) {
         const d = l.dep;
@@ -1126,116 +1288,177 @@ function resolveBackDeps(node) {
             backResolve(d);
     }
 }
-/** Backward commit/compute (dual of forward `_update`): drive a back-write of
- *  `target` toward the sources, applying each lens's `put`, clearing `BF.Pending`
- *  on descent, and staging each source as it's reached (so a later sibling reading
- *  that SAME source composes rather than clobbers). A `SKIP` per-parent slot
- *  prunes a branch; every other slot is written verbatim, `undefined` included. A
- *  `merge` accumulates (folded post-order by `resolveCone`); a read-only parent
- *  throws (already caught at MARK time). */
+/** Backward commit/compute (dual of `_update`): drive a back-write of `target`
+ *  toward the sources, applying each lens's `put` and staging each source as it's
+ *  reached (so a later sibling composes rather than clobbers). A `SKIP` slot prunes
+ *  a branch; every other slot is written verbatim, `undefined` included.
+ *
+ *  Iterative depth-first, left-to-right (children pushed in reverse onto the
+ *  pooled `wbNode`/`wbTarget` stack), so a sibling read sees a prior sibling's
+ *  staged write — bounded by pooled stack memory, not the call stack. */
 function writeBack(node, target) {
-    if (isSource(node)) {
-        node._writeSource(target); // source — staged now, visible to later siblings
-        // Clear this source's back-`Pending`, then re-assert it iff a lens-child is
-        // STILL armed (an overlapping co-writer through this same source) — a later
-        // read must still resolve them, else that write is lost. (Forward writes
-        // live on `flags`, back-state on `bflags`, so the source-stage above no
-        // longer touches `Pending`; we own clearing it here.) `_lensSubs` holds only
-        // ever-back-written children, so this is a short flag scan, not a registry walk.
-        node.bflags &= ~BF.Pending;
-        const subs = node._lensSubs;
-        if (subs !== undefined) {
-            for (let i = 0; i < subs.length; i++)
-                if (subs[i].bflags & BACK_MARKED) {
-                    node.bflags |= BF.Pending;
+    wbNode[0] = node;
+    wbTarget[0] = target;
+    let top = 1;
+    let sTop = 0;
+    while (top > 0) {
+        if (COUNTS)
+            counts.writeBackVisit++;
+        const cur = wbNode[--top];
+        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.)
+            cur.bflags &= ~BF.Pending;
+            for (let e = cur.childEdgesTail; e !== undefined; e = e.prevChild) {
+                if (COUNTS)
+                    counts.reassertScan++;
+                if (e.child.bflags & BACK_MARKED) {
+                    cur.bflags |= BF.Pending;
                     break;
                 }
-        }
-        return;
-    }
-    node.bflags &= ~BF.Pending; // passing through clears the path marker
-    const b = node._bwd;
-    if (b === undefined)
-        throw new TypeError("Cannot write through to a computed");
-    if (b.merge !== undefined) {
-        b.merge.contributions.push(target); // gathered here; `resolveCone` folds post-order
-        return;
-    }
-    const parent = b.parent;
-    if (parent === undefined)
-        return; // pin sink: absorb
-    if (Array.isArray(parent)) {
-        const n = parent.length;
-        let out;
-        const sc = b.stateful;
-        if (sc !== undefined) {
-            const vals = new Array(n);
-            for (let i = 0; i < n; i++)
-                vals[i] = parent[i].value;
-            // Bring the complement to the current sources before `bwd` (the dual of
-            // the forward getter's step) so it measures devs/fracs from a prior
-            // sibling write, not a stale snapshot. External unless the sources still
-            // equal this lens's own last back-write.
-            const last = sc.last;
-            let external = last === undefined;
-            if (last !== undefined) {
-                for (let i = 0; i < n; i++)
-                    if (vals[i] !== last[i]) {
-                        external = true;
-                        break;
-                    }
             }
-            sc.complement = sc.step(vals, sc.complement, external);
-            const res = b.put(target, vals, sc.complement);
-            const upd = res.updates;
-            // Build the committed candidate IN `vals` (its source reads are spent) and
-            // keep it as `last` for the next own-vs-external comparison. A `SKIP` slot —
-            // or a slot past a short `upd` — leaves that parent at its current `vals[i]`.
-            const um = upd.length < n ? upd.length : n;
-            for (let i = 0; i < um; i++)
-                if (upd[i] !== SKIP)
-                    vals[i] = upd[i];
-            sc.complement = sc.step(vals, res.complement, false);
-            sc.last = vals;
-            out = upd;
+            continue;
         }
-        else {
-            out = b.put(target);
+        cur.bflags &= ~BF.Pending; // passing through clears the path marker
+        const b = cur._bwd;
+        if (b === undefined)
+            throw new TypeError("Cannot write through to a computed");
+        const mn = b.merge;
+        if (mn !== undefined) {
+            mn.contributions.push(tgt); // gathered here; `resolveCone` folds post-order
+            continue;
         }
-        // A short `out` skips the trailing parents (the dual of a forward getter
-        // reading fewer deps); `SKIP` skips a specific slot; a real `undefined` is
-        // written verbatim.
-        let wrote = false;
-        const m = out.length < n ? out.length : n;
-        for (let i = 0; i < m; i++) {
-            const u = out[i];
+        const pe = cur.parentEdges;
+        if (pe === undefined)
+            continue; // pin sink (parentless): absorb
+        const sc = b.stateful;
+        if (sc !== undefined && !b.scatter) {
+            // 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;
             if (u !== SKIP) {
-                wrote = true;
-                writeBack(parent[i], u);
+                wbNode[top] = p;
+                wbTarget[top] = u;
+                top++;
             }
+            else {
+                // Stash: the view moved through the complement alone (see the scatter case).
+                cur.flags |= F.Dirty;
+                const subs = cur.subs;
+                if (subs !== undefined)
+                    propagate(subs, runDepth > 0, activeExcluded);
+            }
+            continue;
+        }
+        if (b.scatter) {
+            // Gather ordered parents (index-ordered edges) for the tuple `put`.
+            let n = 0;
+            for (let e = pe; e !== undefined; e = e.nextParent)
+                n++;
+            const parents = new Array(n);
+            for (let e = pe; e !== undefined; e = e.nextParent)
+                parents[e.index] = e.parent;
+            let out;
+            if (sc !== undefined) {
+                const vals = new Array(n);
+                let ver = 0;
+                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;
+            }
+            else {
+                if (COUNTS)
+                    counts.put++;
+                out = b.put(tgt);
+            }
+            // Push non-SKIP children in REVERSE so index 0 is popped (processed) first
+            // — depth-first, left-to-right. A short `out` skips the trailing parents.
+            let wrote = false;
+            const m = out.length < n ? out.length : n;
+            for (let i = m - 1; i >= 0; i--) {
+                const u = out[i];
+                if (u !== SKIP) {
+                    wrote = true;
+                    wbNode[top] = parents[i];
+                    wbTarget[top] = u;
+                    top++;
+                }
+            }
+            // A stateful lens can change its VIEW through the complement alone, moving no
+            // source (a "stash"; `!wrote` ⇒ no children pushed). The forward cone never
+            // fires, so invalidate this node's cache and propagate to its observers here.
+            if (!wrote && sc !== undefined) {
+                cur.flags |= F.Dirty;
+                const subs = cur.subs;
+                if (subs !== undefined)
+                    propagate(subs, runDepth > 0, activeExcluded);
+            }
+            continue;
         }
-        // A stateful lens can change its VIEW through the complement alone, moving
-        // no source (a degenerate "stash" — e.g. a collapsed axis remembering the
-        // written angle, or a broken parse holding the typed text). No source write
-        // means the forward cone never fires, so invalidate the node's own cache and
-        // propagate to its observers here.
-        if (!wrote && sc !== undefined) {
-            node.flags |= F.Dirty;
-            const subs = node.subs;
-            if (subs !== undefined)
-                propagate(subs, runDepth > 0, activeNetwork);
+        // 1→1 lens (single index-0 parent-edge).
+        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;
         }
-        return;
+        sc.stamp = ver;
+        wbStateful[i] = undefined;
     }
-    // 1→1 lens.
-    writeBack(parent, b.put(target));
 }
-/** Fold one merge's gathered contributions ONCE (its policy; default
- *  last-writer-wins) and write the result up to its parent. Called post-order
- *  from `resolveCone` once every contributor has cascaded in — fan-in is the one
- *  non-dual ingredient. Runs untracked (`backResolve` already cleared
- *  `activeSub`). */
+/** Fold a merge's contributions once (policy; default last-writer-wins) and write
+ *  the result up to its parent. Called post-order from `resolveCone`. */
 function foldMerge(parent, mn) {
+    if (COUNTS)
+        counts.fold++;
     const vals = mn.contributions;
     const fold = mn.foldFn;
     let folded;
@@ -1248,25 +1471,31 @@ function foldMerge(parent, mn) {
     vals.length = 0; // reuse the merge-owned buffer in place (fold must not retain it)
     writeBack(parent, folded);
 }
+// ─────────────────────────────────────────────────────────────────────────
+// Public API — factories (cell / derive / lens) over the builders above.
+// ─────────────────────────────────────────────────────────────────────────
 /** Writable source; passes an existing `Writable` through (idempotent). */
 export function cell(initial, opts) {
     if (initial instanceof Cell)
         return initial;
     return new Cell(initial, opts);
 }
-// Bare (untyped) factories. Construct a plain `Cell`, inferring `R`
-// from the closures (the polymorphic-`this` statics are for typed
-// subclasses like `Vec.lens`).
+// Bare (untyped) factories: plain `Cell`, inferring `R` from the closures.
 const CELL_CTOR = Cell;
 // biome-ignore lint/suspicious/noExplicitAny: dispatch
 export function derive(...args) {
-    return dispatchDerive(CELL_CTOR, args);
+    return buildDerive(CELL_CTOR, args);
 }
 // biome-ignore lint/suspicious/noExplicitAny: dispatch
 export function lens(...args) {
-    return dispatchLens(CELL_CTOR, args);
+    return buildLens(CELL_CTOR, args);
 }
-// Effect — alien-signals verbatim.
+// ─────────────────────────────────────────────────────────────────────────
+// Effects & schedulers — the Effect watcher (internal) and the public
+// effect / batch / network / flush surface built on it.
+// ─────────────────────────────────────────────────────────────────────────
+// Effect — one watcher class for both auto-tracked effects and explicit-topology
+// networks: alien-signals' effect plus the `EM` mode toggles `network()` needs.
 class Effect {
     flags = F.Watching | F.RecursedCheck;
     subs = undefined;
@@ -1275,26 +1504,31 @@ class Effect {
     depsTail = undefined;
     fn;
     cleanup = undefined;
-    constructor(fn) {
+    /** Watcher-behavior bits (`EM`); `EM.None` for a plain effect. */
+    mode;
+    constructor(fn, mode = EM.None) {
         this.fn = fn;
-        const prev = activeSub;
-        activeSub = this;
-        try {
-            ++runDepth;
-            const ret = fn();
-            this.cleanup = typeof ret === "function" ? ret : undefined;
-        }
-        finally {
-            --runDepth;
-            activeSub = prev;
-            this.flags &= ~F.RecursedCheck;
-        }
+        this.mode = mode;
     }
     _update() {
         this.flags = F.Mutable;
         return true;
     }
     _notify() {
+        const mode = this.mode;
+        if (mode & EM.Manual) {
+            this.flags |= F.Watching; // re-arm but don't queue; only `flush()` advances
+            return;
+        }
+        if (mode & EM.Sync) {
+            // Eager watcher (network): append + force a synchronous flush.
+            queued[queuedLength++] = this;
+            syncFlush = true;
+            this.flags &= ~F.Watching;
+            return;
+        }
+        // Plain effect: batch-insert this effect and any subscribed to it, in
+        // dependency order (alien-signals).
         let e = this;
         let insertIndex = queuedLength;
         const firstInsertedIndex = insertIndex;
@@ -1324,8 +1558,8 @@ class Effect {
             this._runCleanup();
     }
     _run() {
-        // Resolve back-writes this effect reads directly (incl. view-only stashes),
-        // then let `checkDirty` resolve any back-`Pending` source reached deeper.
+        // Resolve back-writes this node reads directly (incl. view-only stashes);
+        // `checkDirty` resolves any back-`Pending` source reached deeper.
         if (this.deps !== undefined)
             resolveBackDeps(this);
         const flags = this.flags;
@@ -1335,27 +1569,39 @@ class Effect {
                 if (!this.flags)
                     return;
             }
-            this.depsTail = undefined;
-            this.flags = F.Watching | F.RecursedCheck;
-            const prev = activeSub;
-            activeSub = this;
-            try {
-                ++cycle;
-                ++runDepth;
-                const ret = this.fn();
-                this.cleanup = typeof ret === "function" ? ret : undefined;
-            }
-            finally {
-                --runDepth;
-                activeSub = prev;
-                this.flags &= ~F.RecursedCheck;
-                purgeDeps(this);
-            }
+            this._invoke();
         }
         else if (this.deps !== undefined) {
             this.flags = F.Watching;
         }
     }
+    /** Run the body — the single path for first fire, scheduled re-run, and manual
+     *  `flush()`. Auto-tracks deps unless `NoTrack`; self-excludes writes under `Exclude`. */
+    _invoke() {
+        const noTrack = this.mode & EM.NoTrack;
+        if (!noTrack)
+            this.depsTail = undefined;
+        this.flags = F.Watching | F.RecursedCheck;
+        const prevSub = activeSub;
+        const prevExc = activeExcluded;
+        activeSub = noTrack ? undefined : this;
+        if (this.mode & EM.Exclude)
+            activeExcluded = this;
+        try {
+            ++cycle;
+            ++runDepth;
+            const ret = this.fn();
+            this.cleanup = typeof ret === "function" ? ret : undefined;
+        }
+        finally {
+            --runDepth;
+            activeSub = prevSub;
+            activeExcluded = prevExc;
+            this.flags &= ~F.RecursedCheck;
+            if (!noTrack)
+                purgeDeps(this);
+        }
+    }
     _runCleanup() {
         const c = this.cleanup;
         this.cleanup = undefined;
@@ -1371,28 +1617,45 @@ class Effect {
 }
 export function effect(fn) {
     const e = new Effect(fn);
+    e._invoke();
     return () => e._unwatched();
 }
-/** Run effects woken by a write. Backward work is pulled lazily per read
- *  (`resolveBackDeps` + `checkDirty` → `backResolve`, which also folds merges),
- *  so flush owns NO backward bookkeeping — just the effect queue. */
+/** Run effects woken by a write. Backward work is pulled lazily per read, so
+ *  flush owns no backward bookkeeping — just the effect queue. */
 function flush() {
     if (flushing)
         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.
+    let err;
+    let threw = false;
     try {
         while (notifyIndex < queuedLength) {
             const e = queued[notifyIndex];
             queued[notifyIndex++] = undefined;
-            e._run();
+            try {
+                e._run();
+            }
+            catch (ex) {
+                if (!threw) {
+                    err = ex;
+                    threw = true;
+                }
+            }
         }
     }
     finally {
         notifyIndex = 0;
         queuedLength = 0;
-        networkQueued = false;
+        syncFlush = false;
         flushing = false;
     }
+    if (threw)
+        throw err;
 }
 /** Queue an effect flush for the end of the current microtask turn (idempotent).
  *  A write wakes effects asynchronously; many writes in one turn coalesce. */
@@ -1406,26 +1669,24 @@ function schedule() {
     });
 }
 /** Resolve the queue after a write: no-op inside a `batch`/flush (the barrier
- *  owns flushing), else synchronously if a network is waiting (eager solve) or
- *  deferred to the microtask (coalesced effects). */
+ *  owns flushing), else synchronously if a `Sync` watcher is waiting (eager
+ *  solve) or deferred to the microtask (coalesced effects). */
 function autoFlush() {
     if (batchDepth !== 0 || flushing)
         return;
-    if (networkQueued)
+    if (syncFlush)
         flush();
     else
         schedule();
 }
-/** Run all pending effects NOW, synchronously. The escape hatch for code (tests,
- *  imperative call sites) that must observe effect side-effects before yielding
- *  to the microtask queue. Reads never need it — they pull current values. */
+/** Run all pending effects now, synchronously — the escape hatch for code that
+ *  must observe effect side-effects before yielding. Reads never need it. */
 export function settle() {
     flush();
 }
-/** Group writes and flush effects SYNCHRONOUSLY at the end of `fn` — a sync
- *  barrier. Effects coalesce on the microtask turn anyway (see `schedule`), so
- *  `batch` is no longer needed for that; reach for it only when you must run the
- *  woken effects before the call returns (and don't want a `settle()`). */
+/** Group writes and flush effects synchronously at the end of `fn`. Effects
+ *  coalesce on the microtask turn anyway; reach for `batch` only to run the woken
+ *  effects before the call returns. */
 export function batch(fn) {
     ++batchDepth;
     try {
@@ -1446,193 +1707,114 @@ export function untracked(fn) {
         activeSub = prev;
     }
 }
-class _NetworkNode {
-    subs = undefined;
-    subsTail = undefined;
-    deps = undefined;
-    depsTail = undefined;
-    flags = F.Watching | F.RecursedCheck;
-    body;
-    manual;
-    /** Per-instance last-seen dep values; used to compute `dirty`. */
-    lastValues = new Map();
-    pending = false;
-    disposed = false;
-    _ownCycle = 0;
-    _depsSet = new Set();
-    _handle;
-    constructor(body, manual) {
-        this.body = body;
-        this.manual = manual;
-    }
-    /** Two-phase init so the body sees its own handle on the first fire. */
-    _initWithHandle(handle, initialDeps) {
-        this._handle = handle;
-        this._linkBatch(initialDeps);
-        this._runBody(EMPTY_DIRTY);
-    }
-    _update() {
-        this.flags = F.Mutable;
-        return true;
-    }
-    _notify() {
-        if (this.manual) {
-            this.pending = true;
-            this.flags |= F.Watching;
-            return;
-        }
-        queued[queuedLength++] = this;
-        networkQueued = true; // eager: a queued network forces a synchronous flush
-        this.flags &= ~F.Watching;
-    }
-    _unwatched() {
-        this.disposed = true;
-        this.flags = F.None;
-        disposeAllDepsInReverse(this);
-        const sub = this.subs;
-        if (sub !== undefined)
-            unlink(sub);
-        this.lastValues.clear();
-    }
-    _run() {
-        if (this.disposed)
-            return;
-        if (this.deps !== undefined)
-            resolveBackDeps(this);
-        const flags = this.flags;
-        if (flags & F.Dirty || (flags & F.Pending && checkDirty(this.deps, this))) {
-            this._runBody(this._computeDirty());
-        }
-        else if (this.deps !== undefined) {
-            this.flags = F.Watching;
-        }
-    }
-    _computeDirty() {
+/** Build a reactive sub-DAG. The body fires when any subscribed dep changes
+ *  (`dirty` = the changed subset), self-excludes its own writes, and (auto mode)
+ *  resolves synchronously. `manual: true` defers firing so only `flush()` advances;
+ *  `flush()` from inside the body throws. Network-specific state (last-values,
+ *  handle) lives in this closure, so the shared `Effect` carries none of it. */
+export function network(
+// biome-ignore lint/suspicious/noExplicitAny: deps come in many flavours
+deps, body, opts) {
+    const lastValues = new Map();
+    const depsSet = new Set();
+    let ownCycle = 0;
+    let disposed = false;
+    // Forward-declared so the closures below can reach the node; assigned before
+    // any runs (the first `_invoke` happens after construction).
+    let node;
+    const computeDirty = () => {
         let dirty;
-        for (const [cell, lastVal] of this.lastValues) {
-            if (cell.peek() !== lastVal) {
-                if (dirty === undefined)
-                    dirty = new Set();
-                dirty.add(cell);
-            }
+        for (const [c, last] of lastValues) {
+            if (c.peek() !== last)
+                (dirty ??= new Set()).add(c);
         }
         return dirty ?? EMPTY_DIRTY;
-    }
-    _runBody(dirty) {
-        // RecursedCheck doubles as the "body running" guard (see flush()).
-        this.flags = F.Watching | F.RecursedCheck;
-        const prevNetwork = activeNetwork;
-        activeNetwork = this;
-        try {
-            ++cycle;
-            ++runDepth;
-            ++batchDepth;
-            try {
-                this.body(dirty, this._handle);
-            }
-            finally {
-                if (!--batchDepth)
-                    flush();
-            }
-        }
-        finally {
-            --runDepth;
-            activeNetwork = prevNetwork;
-            this.flags &= ~F.RecursedCheck;
-            this.lastValues.clear();
-            let l = this.deps;
-            while (l !== undefined) {
-                const cell = l.dep;
-                this.lastValues.set(cell, cell.peek());
-                l = l.nextDep;
-            }
-        }
-        this.pending = false;
-    }
-    flush() {
-        if (this.disposed)
-            return;
-        if (this.flags & F.RecursedCheck) {
-            throw new Error("network: flush() called from inside body — would recurse infinitely. " +
-                "Return from the body and let the next dep change drive the next fire.");
+    };
+    const linkDeps = (cells) => {
+        let tail = node.deps;
+        if (tail !== undefined)
+            while (tail.nextDep !== undefined)
+                tail = tail.nextDep;
+        node.depsTail = tail;
+        for (const s of cells) {
+            if (depsSet.has(s))
+                continue;
+            depsSet.add(s);
+            link(s, node, ++ownCycle);
         }
-        this._runBody(this._computeDirty());
-    }
-    subscribe(cells) {
-        if (this.disposed)
-            return;
-        this._linkBatch(cells);
-    }
-    unsubscribe(cells) {
-        if (this.disposed)
-            return;
-        const set = this._depsSet;
+    };
+    const unlinkDeps = (cells) => {
         for (const s of cells) {
-            if (!set.has(s))
+            if (!depsSet.has(s))
                 continue;
-            set.delete(s);
-            let l = this.deps;
-            while (l !== undefined) {
+            depsSet.delete(s);
+            for (let l = node.deps; l !== undefined; l = l.nextDep) {
                 if (l.dep === s) {
-                    unlink(l, this);
+                    unlink(l, node);
                     break;
                 }
-                l = l.nextDep;
             }
         }
-    }
-    _linkBatch(cells) {
-        const set = this._depsSet;
-        let tail = this.deps;
-        if (tail !== undefined) {
-            while (tail.nextDep !== undefined)
-                tail = tail.nextDep;
+    };
+    const handle = {
+        dispose: () => {
+            if (disposed)
+                return;
+            disposed = true;
+            node._unwatched();
+            lastValues.clear();
+        },
+        flush: () => {
+            if (disposed)
+                return;
+            // RecursedCheck doubles as the "body running" guard.
+            if (node.flags & F.RecursedCheck) {
+                throw new Error("network: flush() called from inside body — would recurse infinitely.");
+            }
+            batch(() => node._invoke());
+        },
+        subscribe: (...cells) => {
+            if (!disposed)
+                linkDeps(cells);
+        },
+        unsubscribe: (...cells) => {
+            if (!disposed)
+                unlinkDeps(cells);
+        },
+    };
+    // The Effect body: hand the changed subset to the user body, then re-snapshot
+    // the deps for the next fire.
+    const run = () => {
+        const dirty = computeDirty();
+        try {
+            body(dirty, handle);
         }
-        this.depsTail = tail;
-        for (const s of cells) {
-            if (set.has(s))
-                continue;
-            set.add(s);
-            link(s, this, ++this._ownCycle);
+        finally {
+            lastValues.clear();
+            for (let l = node.deps; l !== undefined; l = l.nextDep) {
+                const c = l.dep;
+                lastValues.set(c, c.peek());
+            }
         }
-    }
-}
-/** Build a reactive sub-DAG node with explicit topology. The body fires
- *  when any subscribed dep changes (`dirty` = the changed subset), runs
- *  inside `batch()`, and self-excludes its own writes. Topology is the
- *  deps array + later subscribe/unsubscribe (body reads add no deps).
- *  `flush()` from inside the body throws; `manual: true` defers
- *  auto-firing so only `flush()` advances. */
-export function network(
-// biome-ignore lint/suspicious/noExplicitAny: deps come in many flavours
-deps, body, opts) {
-    const node = new _NetworkNode(body, opts?.manual ?? false);
-    const handle = {
-        dispose: () => node._unwatched(),
-        flush: () => node.flush(),
-        subscribe: (...cells) => node.subscribe(cells),
-        unsubscribe: (...cells) => node.unsubscribe(cells),
     };
-    node._initWithHandle(handle, deps);
+    node = new Effect(run, EM.NoTrack | EM.Exclude | (opts?.manual ? EM.Manual : EM.Sync));
+    linkDeps(deps);
+    batch(() => node._invoke()); // first fire (lastValues empty ⇒ EMPTY_DIRTY)
     return handle;
 }
 // ── value-class authoring helpers ──────────────────────────────────
-//
-// `fieldLens`/`cachedDerive` are the two getter forms a value class declares.
-// The choice between them IS the local declaration of writability at each
-// getter (mirroring `: this` invertible method returns). For arbitrary
+// `fieldLens`/`cachedDerive` are the two getter forms a value class declares;
+// the choice between them is the local declaration of writability. For arbitrary
 // cached views, use `lazy()` directly.
-/** Bidirectional field lens onto `parent.value[key]`; write spread-
- *  replaces the composite. Cached per (instance, key). Return type is
- *  conditional: `Writable<Cls>` on a writable parent, bare `Cls` on RO.
+/** Bidirectional field lens onto `parent.value[key]` (write spread-replaces),
+ *  cached per (instance, key). `Writable<Cls>` on a writable parent, bare `Cls` on RO.
  *
  *      get x() { return fieldLens(this, "x", Num); } */
 export function fieldLens(parent, key, Cls) {
     return lazy(parent, key, () => fieldOf(parent, key, Cls));
 }
 /** Read-only derived view via `Cls.derive(parent, fn)`, memoized per
- *  (instance, key); always bare `Cls` (RO). The cache is the point — the
- *  getter form, not a new kind of cell.
+ *  (instance, key).
  *
  *      get magnitude() {
  *        return cachedDerive(this, "magnitude", Num, v => Math.hypot(v.x, v.y));
@@ -1642,12 +1824,8 @@ export function cachedDerive(parent, key, Cls, fn) {
     // biome-ignore lint/suspicious/noExplicitAny: variance escape on Cls.derive
     return lazy(parent, key, () => Cls.derive(parent, fn));
 }
-/** Every cell `s` transitively depends on, including itself. Raw cells
- *  return `{s}`; lens chains return the chain plus all parents. BFS,
- *  peeking each Computed to populate deps; the `seen` set breaks cycles.
- *  Used by `Propagators` to expand declared reads into their transitive
- *  parent set. Inspection is safe: it only reads engine state and peeks
- *  `.value` (idempotent for lazy Computeds). */
+/** Every cell `s` transitively depends on, including itself (BFS, peeking each
+ *  computed to populate deps; `seen` breaks cycles). */
 export function transitiveDeps(s) {
     const seen = new Set();
     const queue = [s];
@@ -1656,7 +1834,6 @@ export function transitiveDeps(s) {
         if (seen.has(cur))
             continue;
         seen.add(cur);
-        // Cast to reach engine fields the typed Cell<T> shape doesn't surface.
         const c = cur;
         if (c.getter !== undefined) {
             void cur.value;