bireactive 0.2.4 → 0.3.1

package/dist/core/cell.js

@@ -1,56 +1,46 @@
 // cell.ts — symmetric bidirectional reactive engine.
 //
-// Forward propagation is alien-signals verbatim (link/propagate/
-// checkDirty/shallowPropagate, Dirty/Pending/Recursed flags, lazy pull).
-// Backward is not a second engine: a write "compiles" a view-edit into
-// source-edits by walking up `_bwdParent`, applying each lens's `put` to
-// compute what the source(s) must become, committing via the SAME
-// forward write path. So views are never sticky (a view is always
-// `get(source)`; lossy lenses snap), no-op deltas short-circuit for free
-// via equality, and backward cost ≤ forward cost.
+// 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:
 //
-// Duals:
-//   * merge — N→1 backward aggregation (dual of computed's N→1 forward).
-//     Contributions land in a slot map keyed by contributor identity,
-//     fold via a user policy, reset per settle.
-//   * multi-parent lens — a write that SPLITS across N parents
-//     (`_put(target)` → per-parent update array, `propagateSplit`); the
-//     dual of a getter reading N parents. Covers coupled writables
-//     (N→M, e.g. mean/diff). Info the source can't hold lives in a
-//     stateful-lens complement, not a bespoke engine kind.
+//   role            forward (source → view)      backward (view → source)
+//   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)
 //
-// Core asymmetry: forward deps are IMPLICIT (auto-tracked reads of
-// `.value` under `activeSub`); backward targets are EXPLICIT (declared
-// at construction in `_bwdParent`). Hence no `activeBwdWrite` global.
+// 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 dual-keyed: a staged forward write for a
-// source, a deferred backward target for a getter cell (never both).
-//
-// Batching: outside a batch a write propagates backward eagerly and
-// flushes (alien's synchronous per-write semantics). Inside batch/flush,
-// lens writes deposit their latest value and queue (last-write-wins via
-// `_queueIdx`) and merge folds defer until all contributors land; the
-// flush loop alternates bwd-drain / effect-drain to a fixpoint.
-// Flag bits (alien-signals v2).
-const F = {
-    None: 0,
-    Mutable: 1,
-    Watching: 2,
-    RecursedCheck: 4,
-    Recursed: 8,
-    Dirty: 16,
-    Pending: 32,
-    /** Backward-only: cell has a pending backward contribution queued. */
-    BwdQueued: 64,
-};
+// 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;
@@ -58,18 +48,189 @@ let notifyIndex = 0;
 let queuedLength = 0;
 let activeSub;
 let flushing = 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;
+/** 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();
-/** Backward worklist: lens cells with deferred writes, merge cells
- *  awaiting fold. Drained to a fixpoint with effects by flush. */
-const bwdQueue = [];
-// 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.
+/** 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,
+    Watching: 2,
+    RecursedCheck: 4,
+    Recursed: 8,
+    Dirty: 16,
+    Pending: 32,
+};
+// Backward flag bits, on a Cell's own `bflags` word (the dual of `flags`).
+const BF = {
+    None: 0,
+    /** Dual of `F.Dirty`: this view holds an unresolved back-target in `pendingValue`. */
+    Dirty: 1,
+    /** 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,
+};
+/** Armed root OR on a back-path — i.e. a read must `backResolve` first. */
+const BACK_MARKED = BF.Dirty | BF.Pending;
+// 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;
+}
+/** Writable: carries a backward sidecar (lens / multi-out / merge / stateful / pin). */
+function isWritable(c) {
+    return c._bwd !== undefined;
+}
+/** 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: 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;
+}
+/** 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 (COUNTS)
+        counts.linkChild++;
+    e.linked = true;
+    const parent = e.parent;
+    e.prevChild = parent.childEdgesTail;
+    if (parent.childEdgesTail !== undefined)
+        parent.childEdgesTail.nextChild = e;
+    else
+        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;
+        }
+    }
+}
 /** Install a hook fired on every source value-change; returns a restore fn. */
 export function setCellWriteHook(fn) {
     const prev = writeHook;
@@ -78,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;
@@ -92,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 =
@@ -122,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;
@@ -142,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))) {
@@ -199,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;
@@ -207,7 +378,14 @@ function checkDirty(startLink, startSub) {
         const flags = dep.flags;
         if (sub.flags & F.Dirty)
             dirty = true;
-        else if ((flags & (F.Mutable | F.Dirty)) === (F.Mutable | F.Dirty)) {
+        else if ((flags & (F.Mutable | F.Dirty)) === (F.Mutable | F.Dirty) ||
+            // 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))) {
             const subs = dep.subs;
             if (dep._update()) {
                 if (subs.nextSub !== undefined)
@@ -232,11 +410,15 @@ function checkDirty(startLink, startSub) {
         while (checkDepth--) {
             l = stack.value;
             stack = stack.prev;
-            if (dirty) {
+            // `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()) {
                     if (subs.nextSub !== undefined)
                         shallowPropagate(subs);
+                    dirty = true;
                     sub = l.sub;
                     continue;
                 }
@@ -289,101 +471,65 @@ function disposeAllDepsInReverse(sub) {
         l = prev;
     }
 }
-export const DIRECT_SLOT = Symbol("merge:direct-slot");
 class MergeNode {
-    parent;
-    policy;
-    slots = new Map();
-    hasIncrementalAcc;
-    acc;
-    constructor(parent, policy) {
-        this.parent = parent;
-        this.policy = policy;
-        this.hasIncrementalAcc = policy.remove !== undefined;
-        this.acc = policy.identity;
-    }
-    receive(slot, next) {
-        if (this.hasIncrementalAcc) {
-            const remove = this.policy.remove;
-            const prior = this.slots.get(slot);
-            if (prior === undefined)
-                this.acc = this.policy.combine(this.acc, next);
-            else
-                this.acc = this.policy.combine(remove(this.acc, prior), next);
-        }
-        this.slots.set(slot, next);
-    }
-    fold() {
-        if (this.hasIncrementalAcc)
-            return this.acc;
-        let acc = this.policy.identity;
-        for (const v of this.slots.values())
-            acc = this.policy.combine(acc, v);
-        return acc;
-    }
-    reset() {
-        this.slots.clear();
-        this.acc = this.policy.identity;
+    foldFn;
+    /** 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` + `queueIdx`.
+// 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`). Always called by
-     *  the engine in 1-arg form `put(target)`; a source-reading lens bakes
-     *  `settled(parent)` into this closure at build time. Multi-output:
-     *  returns a per-parent update array. Stateful: the spec's `bwd`. */
+    /** 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;
-    /** Index in `bwdQueue` of this cell's latest push; the drain skips stale
-     *  entries so each cell propagates backward once per flush, last-write. */
-    queueIdx = -1;
+    /** `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;
-    /** Forward projection `fwd(sources, complement) → view`. */
-    // biome-ignore lint/suspicious/noExplicitAny: opaque fwd shape
-    fwd;
-    /** Advance the complement: `step(sources, complement, external)`. */
+    /** 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;
-    /** Source values last written back (own-vs-external test); `undefined`
-     *  until the first back-write. */
-    lastBwd = 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 fwd shape
-    fwd, 
     // biome-ignore lint/suspicious/noExplicitAny: opaque step shape
     step) {
         this.complement = complement;
-        this.fwd = fwd;
         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)
@@ -413,35 +559,58 @@ 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 {
-    flags = F.Mutable;
+    /** @internal */
+    flags;
+    /** @internal */
     subs;
+    /** @internal */
     subsTail;
+    /** @internal */
     deps;
+    /** @internal */
     depsTail;
-    /** Forward derivation (computed/lens/merge). `undefined` ⇒ source. */
+    /** @internal Forward derivation (computed/lens/merge). `undefined` ⇒ source. */
     getter;
-    /** Per-instance equality, always defined (defaults to `Object.is` at
-     *  construction) so hot paths call it without an `undefined` branch. */
+    /** @internal Per-instance equality; always defined (defaults to `Object.is`). */
     _equals;
-    /** First-subscriber / last-subscriber lifecycle hooks. */
+    /** @internal First-subscriber / last-subscriber lifecycle hooks. */
     _watched;
+    /** @internal */
     _unwatchedHook;
-    /** Source: `currentValue` = committed, `pendingValue` = staged write.
-     *  Getter cell: `currentValue` = last derived cache, `pendingValue`
-     *  reused as the deferred backward target (see `set value`). The two
-     *  roles never coexist, so two fields suffice for four. */
+    /** @internal Source: committed value + staged write. */
     currentValue;
+    /** @internal */
     pendingValue;
-    /** Backward sidecar: target(s) + lens closures + queue slot, or
-     *  `undefined` for a read-only cell (source or computed). Allocated only
-     *  for writable derived cells, keeping the common node lean. Writability
-     *  is exactly `_bwd !== undefined`. See `BwdSpec`. */
+    /** @internal Backward sidecar; `undefined` iff read-only. Writability is `_bwd !== undefined`. */
     _bwd;
+    /** @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 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.currentValue = initial;
-        this.pendingValue = initial;
-        // Pre-init every optional slot for a stable V8 hidden class across variants.
+        this.flags = F.Mutable;
         this.subs = undefined;
         this.subsTail = undefined;
         this.deps = undefined;
@@ -450,7 +619,17 @@ export class Cell {
         this._equals = Object.is;
         this._watched = undefined;
         this._unwatchedHook = undefined;
+        this.currentValue = initial;
+        this.pendingValue = initial;
         this._bwd = undefined;
+        this.parentEdges = undefined;
+        this.parentEdgesTail = undefined;
+        this.childEdges = undefined;
+        this.childEdgesTail = undefined;
+        this.bflags = BF.None;
+        this.bEpoch = 0;
+        this.version = 0;
+        this.name = undefined;
         if (opts !== undefined) {
             if (opts.equals !== undefined)
                 this._equals = opts.equals;
@@ -458,32 +637,37 @@ export class Cell {
                 this._watched = opts.watched;
             if (opts.unwatched !== undefined)
                 this._unwatchedHook = opts.unwatched;
+            if (opts.name !== undefined)
+                this.name = opts.name;
         }
     }
-    _enqueueBwd() {
-        this.flags |= F.BwdQueued;
-        this._bwd.queueIdx = bwdQueue.length;
-        bwdQueue.push(this);
-    }
-    /** Source write (alien's signal setter). Self-excludes the active
-     *  network so a body writing its own dep doesn't re-trigger itself. */
+    /** @internal Single write-commit point; self-excludes the active network. */
     _writeSource(next) {
+        // 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);
-            if (batchDepth === 0 && !flushing && subs !== undefined)
-                flush();
+            if (subs !== undefined) {
+                // Convert the cone's arm-time `Pending` into `Dirty` so a second observer
+                // (not just the first reader) sees the change. If this lands mid-pull, the
+                // freshly-`Dirty` nodes are honored by `checkDirty`'s unwind.
+                propagate(subs, runDepth > 0, activeExcluded);
+                autoFlush();
+            }
         }
     }
+    /** @internal */
     _update() {
         if (this.getter !== undefined) {
-            // Computed/lens/merge: re-run the forward derivation.
+            if (COUNTS)
+                counts.recompute++;
             this.depsTail = undefined;
             this.flags = F.Mutable | F.RecursedCheck;
             const prev = activeSub;
@@ -494,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;
@@ -502,13 +689,30 @@ export class Cell {
                 purgeDeps(this);
             }
         }
+        // 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;
         const prevV = this.currentValue;
         this.currentValue = this.pendingValue;
         return !this._equals(prevV, this.currentValue);
     }
+    /** @internal */
     _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);
@@ -527,28 +731,32 @@ export class Cell {
             activeSub = prev;
         }
     }
-    /** Guard: silent coercion to string/number is almost always a bug. */
-    [Symbol.toPrimitive](hint) {
-        throw new TypeError(`Cell cannot be coerced to ${hint} — use \`.value\``);
-    }
     // 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-aggregating node — bwd dual of computed. Forward, the
-     *  identity view of its parent; backward, folds contributions from
-     *  upstream lenses (slot-keyed) and direct writes (DIRECT_SLOT). */
-    merge(policy) {
+    // 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: forward the identity view of its parent, backward the point
+     *  where N contributors fold 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");
         }
@@ -557,28 +765,27 @@ 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(parent, policy);
+        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;
     }
-    /** Lift `Val<Inner<Cls>>` → `Cls`: instance → identity, RO cell →
+    /** Coerce `Val<Inner<Cls>>` → `Cls`: instance → identity, RO cell →
      *  tracked `derive`, literal → fresh seed. */
-    // biome-ignore lint/suspicious/noExplicitAny: variance escape
-    static from(v) {
+    static coerce(v) {
         if (v instanceof this)
             return v;
         if (v instanceof Cell) {
@@ -589,32 +796,37 @@ 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;
-        const b = (cell._bwd = new BwdSpec());
-        b.put = () => undefined; // absorb (no parent → sink)
+        // Parentless `_bwd`: `writeBack` absorbs it (no parent edges, no closure).
+        cell._bwd = new BwdSpec();
         return cell;
     }
-    /** Typed field lens onto `parent.value[key]`. A read-only computed
-     *  parent yields a RO derive view; any writable parent yields a
-     *  bidirectional field lens with spread-replace `put`. */
-    // biome-ignore lint/suspicious/noExplicitAny: variance escape
-    static fieldOf(
-    // biome-ignore lint/suspicious/noExplicitAny: parent is contravariant on put
-    parent, key, Cls) {
-        const ctor = Cls;
-        const get = (s) => s[key];
-        // Read-only ⇔ computed: a getter with no backward sidecar.
-        const ro = parent.getter !== undefined && parent._bwd === undefined;
-        if (ro) {
-            return buildDerived(ctor, () => get(parent.value));
-        }
-        // Spread-replace reads the current source ⇒ source-reading (lens) form.
-        return buildLens1(ctor, parent, get, (v, s) => ({ ...s, [key]: v }), true);
+}
+/** Typed field lens onto `parent.value[key]`. RO parent → RO derive;
+ *  writable parent → bidirectional lens with spread-replace `put`. */
+export function fieldOf(
+// biome-ignore lint/suspicious/noExplicitAny: parent is contravariant on put
+parent, key, Cls) {
+    const ctor = Cls;
+    const get = (s) => s[key];
+    const ro = parent.getter !== undefined && parent._bwd === undefined;
+    if (ro) {
+        return buildDerived(ctor, () => get(parent.value));
     }
+    // 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) {
@@ -623,40 +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 bake the (non-committing) current source into the
-    // closure so the engine always calls the 1-arg form (no arity branch).
-    b.put = readsSource ? (t) => bwd(t, settled(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
+    };
+}
+// 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());
-    b.parent = parents;
-    b.put = readsSource
-        ? (target) => {
-            for (let i = 0; i < n; i++)
-                vals[i] = parents[i].peek();
-            return bwd(target, vals);
+    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);
         }
-        : (target) => bwd(target);
+    }
+    else {
+        const p = parent;
+        cell.getter = (() => fwd(p.value));
+        // Source-reading lenses linearize at the parent's primal (`backPrimal`), so the
+        // engine always calls the 1-arg form and never recomputes the parent's cone.
+        b.put = readsSource ? (t) => bwd(t, backPrimal(p)) : bwd;
+        linkLens(cell, p, 0);
+    }
+    setWriteBlocked(cell);
     return cell;
 }
 // biome-ignore lint/suspicious/noExplicitAny: variance escape
@@ -671,35 +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.fwd, 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.lastBwd;
-        if (lb !== undefined) {
-            external = false;
-            for (let i = 0; i < n; i++) {
-                if (vals[i] !== lb[i]) {
-                    external = true;
-                    break;
-                }
-            }
+            ver += parents[i].version;
         }
-        sc.complement = sc.step(vals, sc.complement, external);
-        return sc.fwd(vals, sc.complement);
+        // Step only when sources moved since the last sync (lazy own-vs-external).
+        if (ver !== sc.stamp) {
+            if (COUNTS)
+                counts.step++;
+            sc.complement = sc.step(vals, sc.complement);
+            sc.stamp = ver;
+        }
+        return fwd(vals, sc.complement);
     });
+    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
@@ -707,52 +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.fwd, 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.lastBwd;
-        const external = lb === undefined || lb[0] !== v;
-        sc.complement = sc.step(vals, sc.complement, external);
-        return sc.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;
-    if (Array.isArray(parent))
-        return buildLensN(ctor, parent, fn, undefined, false);
-    return buildDerived(ctor, () => 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;
+        return buildDerived(Cls, args[0]);
+    const parent = args[0];
+    const fn = args[1];
     if (Array.isArray(parent))
-        return buildLensN(ctor, parent, a, b, readsSource);
-    return buildLens1(ctor, parent, a, b, readsSource);
+        return buildDerived(Cls, arrayGetter(parent, fn));
+    return buildDerived(Cls, () => fn(parent.value));
 }
-// Install `value` on the prototype (for silly TypeScript inference reasons I'd like to avoid if we can figure it out).
+// 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 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 &&
@@ -763,26 +1038,11 @@ Object.defineProperty(Cell.prototype, "value", {
                         shallowPropagate(subs);
                 }
             }
-            else if (!flags) {
-                // First read: lazy init.
-                this.flags = F.Mutable | F.RecursedCheck;
-                const prev = activeSub;
-                activeSub = this;
-                let threw = true;
-                try {
-                    this.currentValue = this.getter();
-                    threw = false;
-                }
-                finally {
-                    activeSub = prev;
-                    this.flags = threw ? F.Mutable | F.Dirty : this.flags & ~F.RecursedCheck;
-                }
-            }
             if (activeSub !== undefined)
                 link(this, activeSub, cycle);
             return this.currentValue;
         }
-        // Cell path.
+        // Source path.
         if (flags & F.Dirty) {
             this.flags = F.Mutable;
             const prevV = this.currentValue;
@@ -802,248 +1062,441 @@ Object.defineProperty(Cell.prototype, "value", {
             this._writeSource(next);
             return;
         }
-        // Backward write. Deferred while batching/flushing so repeated writes
-        // coalesce (last-write-wins) and merge folds wait for all
-        // contributors; eager + synchronous otherwise. Exception: inside a
-        // network body writes are eager so the body's fixpoint loop observes
-        // its own edits via `peek()` between steps.
         const b = this._bwd;
         if (b === undefined) {
             throw new TypeError("Cannot write to a computed");
         }
-        const deferred = (batchDepth > 0 || flushing) && activeNetwork === undefined;
-        if (b.merge !== undefined) {
-            b.merge.receive(DIRECT_SLOT, next);
-            if (deferred)
-                this._enqueueBwd();
-            else
-                bwdUntracked(this, undefined, false);
-            return;
-        }
-        if (deferred && (Array.isArray(b.parent) || b.stateful !== undefined)) {
-            // Multi-parent / stateful: defer to flush so a split coalesces, a
-            // merge folds after all contributors land, and a complement steps
-            // once. Reuse `pendingValue` (unused by a getter's forward path) as
-            // the deferred backward target; drained by flush. Entry no-op vs the
-            // current view (GetPut) skips the walk.
-            if (this._equals(next, this.peek()))
-                return;
-            this.pendingValue = next;
-            this._enqueueBwd();
+        // 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;
         }
-        // Single-parent lens: run the walk now. Inside a batch `_writeSource`
-        // stages the source (Dirty + pending) and defers only the flush, so
-        // the view reads back consistently and a later write supersedes via
-        // the source's pending value — last-write-wins, no queue, no lost
-        // revert. We must NOT peek the view here when batching: that would
-        // commit the source's pending value and break net-zero revert
-        // coalescing — `propagateBwd`'s `settled` no-op stop prunes a true
-        // no-op without committing. Outside a batch, the O(1) GetPut check is
-        // safe (no source is staged) and worth keeping.
-        if (!deferred && this._equals(next, this.peek()))
-            return;
-        bwdUntracked(this, next, deferred);
+        arm(this, next);
     },
     enumerable: false,
     configurable: false,
 });
-// Backward pass (propagateBwd).
-//
-// Walk up `_bwdParent`, applying `put` at each lens / folding at each
-// merge, until a source is committed (via the forward write path) or a
-// parent merge is reached. `deferred` (inside batch/flush) stops at a
-// parent merge after depositing so it folds once all contributors land;
-// eager folds merges inline. Not a second engine: every path terminates
-// in `_writeSource`.
-// Backward evaluation runs UNTRACKED so `bwd`/`step`/`fwd` reads don't
-// establish forward deps on whatever `activeSub` is writing (e.g. an
-// effect that writes a lens). All backward entry points route through here.
-function bwdUntracked(cell, target, deferred) {
-    const prev = activeSub;
-    activeSub = undefined;
-    try {
-        propagateBwd(cell, target, deferred);
+// ─────────────────────────────────────────────────────────────────────────
+// 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");
     }
-    finally {
-        activeSub = prev;
+    if (COUNTS)
+        counts.arm++;
+    if (!(node.bflags & BF.Dirty)) {
+        markDown(node); // flag path + wake cones FIRST (a throw arms nothing)
+        node.bflags |= BF.Dirty;
     }
+    node.pendingValue = target;
+    autoFlush();
 }
-/** A cell's current value for the backward pass's internal no-op checks,
- *  WITHOUT side effects. A source staged earlier in this batch reads its
- *  pending value directly; reading it via `peek` would COMMIT the pending
- *  value (`_update`: currentValue = pendingValue), so a later net-zero
- *  revert would look like a real change and over-fire downstream. A
- *  non-source (lens/computed) has no such hazard and recomputes via peek. */
-function settled(cell) {
-    return cell.getter === undefined && (cell.flags & F.Dirty) !== 0
-        ? cell.pendingValue
-        : cell.peek();
-}
-function propagateBwd(start, target, deferred) {
-    let cell = start;
-    let v = target;
-    while (true) {
-        // Multi-parent lens: SPLIT the write into each parent (dual of a
-        // getter reading N parents — the `put` yields N upstream values).
-        const cb = cell._bwd;
-        const parent = cb.parent;
-        if (Array.isArray(parent)) {
-            propagateSplit(cell, v, deferred);
-            return;
+/** 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` 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.
+            if (!(node.bflags & BF.Pending)) {
+                node.bflags |= BF.Pending;
+                const subs = node.subs;
+                if (subs !== undefined)
+                    propagate(subs, runDepth > 0, activeExcluded);
+            }
         }
-        let push;
-        if (cb.merge !== undefined) {
-            const node = cb.merge;
-            push = node.fold();
-            node.reset();
+        else if (node === start || !(node.bflags & BF.Pending)) {
+            // On the back-path. An already-marked intermediate (≠ start) has its
+            // subtree marked — stop (diamond dedup).
+            if (node !== start)
+                node.bflags |= BF.Pending;
+            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);
+            }
         }
-        else {
-            // Single-arg always: a source-reading lens baked `settled(parent)`
-            // into `put` at build time (see `buildLens1`); `pin` ignores `v`.
-            push = cb.put(v);
+        if (next !== undefined) {
+            node = next;
         }
-        // Parentless lens (e.g. `pin`): no upstream, write absorbed. Sink.
-        if (parent === undefined)
-            return;
-        // Concrete no-op stop: if the parent already holds `push`, committing
-        // changes nothing upstream, so the walk stops. Sound for ANY topology
-        // (no speculation). A lossy lens hides an off-grid edit by returning
-        // the current source from `put`. Merge parents fold instead. `settled`
-        // reads a batched source's pending value WITHOUT committing it, so a
-        // net-zero revert leaves the source unchanged and downstream un-fired.
-        const pb = parent._bwd;
-        const parentMerge = pb !== undefined ? pb.merge : undefined;
-        if (parentMerge === undefined && parent._equals(push, settled(parent)))
-            return;
-        if (parentMerge !== undefined) {
-            parentMerge.receive(cell, push);
-            if (deferred) {
-                if (!(parent.flags & F.BwdQueued))
-                    parent._enqueueBwd();
-                return;
-            }
-            cell = parent;
-            continue;
+        else if (stack !== undefined && stack.length > 0) {
+            node = stack.pop();
         }
-        if (parent.getter === undefined) {
-            // Source: commit + forward-propagate (the forward write).
-            parent._writeSource(push);
+        else {
             return;
         }
-        // Parent is a lens: keep walking, carrying its new view value.
-        cell = parent;
-        v = push;
     }
 }
-/** Split a multi-parent cell's write across its N parents. `_put(target)`
- *  returns the per-parent update array (`undefined` ⇒ leave parent);
- *  each defined update recurses via `propagateBwd`. Eager splits coalesce
- *  under one flush (same guarantee as `batch()`); the coalescing lives
- *  here since such a cell may be reached as a write start or mid-chain. */
-function propagateSplit(cell, target, deferred) {
-    const b = cell._bwd;
-    const parents = b.parent;
-    const n = parents.length;
-    // STATEFUL lens: `bwd` reads the complement and returns per-parent
-    // updates plus the post-write complement. We commit the stepped
-    // complement and fork the source updates; absorption is the lens's job
-    // (its `bwd` returns `undefined` updates, forked as no-ops).
-    const sc = b.stateful;
-    if (sc !== undefined) {
-        // Bring the complement current with the sources before the back-write
-        // (a source may have changed without the view being read, leaving
-        // `step` un-run). Untracked, so reading `.value` adds no dependency.
-        void cell.value;
-        const vals = new Array(n);
-        for (let i = 0; i < n; i++)
-            vals[i] = parents[i].peek();
-        const res = b.put(target, vals, sc.complement);
-        const updates = res.updates;
-        const cand = new Array(n);
-        let anyWrite = false;
-        for (let i = 0; i < n; i++) {
-            const u = updates[i];
-            if (u === undefined) {
-                cand[i] = vals[i];
-            }
-            else {
-                cand[i] = u;
-                anyWrite = true;
+/** 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.
+ *
+ *  Iterative post-order over the back-cone (was a recursion bounded by lens-nesting
+ *  depth), 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;
             }
         }
-        sc.complement = sc.step(cand, res.complement, false);
-        if (!anyWrite) {
-            // Complement-only change (no source moves): mark dirty for a correct next read.
-            cell.flags = F.Mutable | F.Dirty;
-            return;
-        }
-        sc.lastBwd = cand;
-        if (deferred) {
-            forkInto(parents, updates, n);
-            return;
-        }
-        ++batchDepth;
-        try {
-            forkInto(parents, updates, n);
-        }
-        finally {
-            if (!--batchDepth)
-                flush();
-        }
-        return;
+        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);
     }
-    const updates = b.put(target);
-    // No speculation: each defined update forks to its parent, where
-    // `_writeSource`'s equality check prunes no-op sources and the forward
-    // pass prunes unchanged views. Absorption ⇒ `undefined` updates.
-    if (deferred) {
-        forkInto(parents, updates, n);
-        return;
+}
+/** `resolveCone` pre-order work: reset a merge's buffer, drive an armed target. */
+function enterCone(node) {
+    if (COUNTS)
+        counts.resolveConeVisit++;
+    const b = node._bwd;
+    if (b !== undefined && b.merge !== undefined)
+        b.merge.contributions.length = 0;
+    if (node.bflags & BF.Dirty) {
+        node.bflags &= ~BF.Dirty;
+        writeBack(node, node.pendingValue);
     }
+}
+/** 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 {
-        forkInto(parents, updates, n);
+        if (isSource(start)) {
+            resolveCone(start);
+            return;
+        }
+        // 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);
+                }
+                else if (next === undefined)
+                    next = p;
+                else
+                    (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 {
-        if (!--batchDepth)
-            flush();
+        backSources.length = sourcesBase;
+        activeSub = prev;
+        --batchDepth;
+        draining = false;
+    }
+}
+/** 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;
+        if (d.bflags & BACK_MARKED && !draining)
+            backResolve(d);
     }
 }
-/** Route each defined update to its parent: a source commits directly, a
- *  lens/multi-parent/merge re-enters the backward pass. Always called
- *  under a bumped `batchDepth` so commits coalesce into one flush. */
-function forkInto(parents, updates, n) {
-    for (let i = 0; i < n; i++) {
-        const u = updates[i];
-        if (u === undefined)
+/** 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 exactly as the old recursion did — bounded by stack memory, not
+ *  the call stack. */
+function writeBack(node, target) {
+    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;
+                }
+            }
+            continue;
+        }
+        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;
+        }
+        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) {
+                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;
-        const parent = parents[i];
-        if (parent.getter === undefined)
-            parent._writeSource(u);
-        else
-            propagateBwd(parent, u, true);
+        }
+        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;
+        }
+        // 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;
+        }
+        sc.stamp = ver;
+        wbStateful[i] = undefined;
     }
 }
+/** 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;
+    if (fold !== undefined)
+        folded = fold(vals);
+    else if (vals.length > 0)
+        folded = vals[vals.length - 1];
+    else
+        return; // last-writer-wins with no contributor: leave the parent
+    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;
@@ -1052,26 +1505,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;
@@ -1101,6 +1559,10 @@ class Effect {
             this._runCleanup();
     }
     _run() {
+        // 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;
         if (flags & F.Dirty || (flags & F.Pending && checkDirty(this.deps, this))) {
             if (this.cleanup) {
@@ -1108,27 +1570,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;
@@ -1144,49 +1618,76 @@ class Effect {
 }
 export function effect(fn) {
     const e = new Effect(fn);
+    e._invoke();
     return () => e._unwatched();
 }
-// Alternates backward-drain and effect-drain to a fixpoint: backward
-// commits sources (queuing effects); effects may write (more effects /
-// more bwd entries). Loops until both queues are exhausted.
+/** 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;
-    let bwdIndex = 0;
+    // 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 {
-        // Head-checked so the common already-drained case skips the body.
-        while (bwdIndex < bwdQueue.length || notifyIndex < queuedLength) {
-            while (bwdIndex < bwdQueue.length) {
-                const cell = bwdQueue[bwdIndex];
-                const cb = cell._bwd;
-                if (cb.queueIdx !== bwdIndex || !(cell.flags & F.BwdQueued)) {
-                    bwdIndex++;
-                    continue;
-                }
-                bwdIndex++;
-                cell.flags &= ~F.BwdQueued;
-                if (cb.merge !== undefined) {
-                    bwdUntracked(cell, undefined, true);
-                }
-                else {
-                    bwdUntracked(cell, cell.pendingValue, true);
-                }
-            }
-            while (notifyIndex < queuedLength) {
-                const e = queued[notifyIndex];
-                queued[notifyIndex++] = undefined;
+        while (notifyIndex < queuedLength) {
+            const e = queued[notifyIndex];
+            queued[notifyIndex++] = undefined;
+            try {
                 e._run();
             }
+            catch (ex) {
+                if (!threw) {
+                    err = ex;
+                    threw = true;
+                }
+            }
         }
     }
     finally {
-        bwdQueue.length = 0;
         notifyIndex = 0;
         queuedLength = 0;
+        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. */
+function schedule() {
+    if (scheduled)
+        return;
+    scheduled = true;
+    queueMicrotask(() => {
+        scheduled = false;
+        flush();
+    });
+}
+/** Resolve the queue after a write: no-op inside a `batch`/flush (the barrier
+ *  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 (syncFlush)
+        flush();
+    else
+        schedule();
+}
+/** 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`. 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 {
@@ -1207,191 +1708,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;
-        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;
-        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 prevSettler = activeNetwork;
-        activeNetwork = this;
-        try {
-            ++cycle;
-            ++runDepth;
-            ++batchDepth;
-            try {
-                this.body(dirty, this._handle);
-            }
-            finally {
-                if (!--batchDepth)
-                    flush();
-            }
-        }
-        finally {
-            --runDepth;
-            activeNetwork = prevSettler;
-            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;
 }
-// MISC stuff used by a few places, to revisit...
 // ── value-class authoring helpers ──────────────────────────────────
-//
-// `field`/`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 field(this, "x", Num); } */
-export function field(parent, key, Cls) {
-    return lazy(parent, key, () => Cell.fieldOf(parent, key, Cls));
+ *      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). The cache is the point.
  *
  *      get magnitude() {
  *        return cachedDerive(this, "magnitude", Num, v => Math.hypot(v.x, v.y));
@@ -1401,12 +1825,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];
@@ -1415,7 +1835,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;