bireactive 0.2.3 → 0.3.0

package/dist/core/cell.js

@@ -2,26 +2,62 @@
 //
 // 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.
 //
-// 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.
+// Backward is the SAME shape as forward — a lazy push-pull — not a second
+// engine, and it carries NO dynamic side tables: state lives on flags plus two
+// STATIC adjacencies that mirror forward's `deps`/`subs`. The lens graph is
+// stored both ways at construction: `_bwd.parent` is the down edge (a view's
+// declared parents, the dual of `deps`) and `_lensSubs` is its transpose, the
+// up edge (a cell's direct lens-children, the dual of `subs`). Backward is then
+// the forward engine run on this reverse graph — one traversal each direction:
 //
-// 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.
+//   role            forward (source → view)      backward (view → source)
+//   ----            ------------------------      ------------------------
+//   down edge       subs (who reads me)          _bwd.parent (my parents)
+//   up edge         deps (my deps)               _lensSubs (my lens-children)
+//   push (mark)     propagate (down `subs`)      markDown (down `_bwd.parent`)
+//   pull (resolve)  checkDirty (up `deps`)       resolveCone (up `_lensSubs`)
+//   commit/compute  _update / getter             writeBack
+//   "dirty" flag    F.Dirty (source staged)      BF.Dirty (view holds target)
+//   "pending" flag  F.Pending (on the cone)      BF.Pending (on the back-path)
+//
+// Forward flags live on `flags`, backward on a SEPARATE `bflags` word — the two
+// engines never share a bit, so a forward reset can't disturb a back-write.
+//
+// Forward: a source write PUSHES dirtiness down the cone (`Pending`, cheap
+// flagging) and the value is PULLED up on read (`checkDirty` ascends `deps` to
+// the `Dirty` source). Backward is the exact dual. A write to a view PUSHES
+// (`markDown`): stash the `target` on the view itself (`pendingValue` +
+// `BF.Dirty`, the dual of a source's `F.Dirty`), descend the static backward
+// path flagging each node down to its sources `BF.Pending` (the dual of
+// `F.Pending`), and wake each source's forward cone so observers re-fire. No `put`
+// runs, no source moves. The work is PULLED per read, source-CENTRIC: a read
+// that reaches a back-marked cell `backResolve`s — for a source directly, or by
+// DESCENDING a view's marked back-path to its sources first. Each source then
+// `resolveCone`s: ASCEND `_lensSubs` through the `BF.Pending` cone to the armed
+// views (the dual of `checkDirty` ascending `deps`) and `writeBack` each,
+// applying its lens's `put` and staging the source via the SAME forward
+// `_writeSource`. A source reflects ALL its writers (they compose into one
+// committed value), so a source's cone resolves together and commits once.
+// Because resolution follows only the sources the read DEPENDS on, reading one
+// chain leaves unrelated sources armed (GRANULAR — does only the work a read
+// demands); overlapping co-writers on a shared source all compose; an
+// UNOBSERVED write does no backward work; re-writing a view before any read
+// keeps only the last target. Reads pull at clean entry points
+// (getter top, source `_update`/`_writeSource`, effect `_run`) — never
+// mid-compute, so a source-reading `put` never re-enters a half-computed cell.
+// Views are never sticky (a view is always `get(source)`; lossy lenses snap),
+// no-op deltas short-circuit via equality (the GetPut law).
+//
+// The ONE irreducibly non-dual ingredient is fan-in accumulation: where the
+// forward engine broadcasts one source to N readers, the backward engine
+// ACCUMULATES N contributors into one value (the transpose of fan-out). A
+// `merge` folds POST-ORDER inside `resolveCone`: its contributors are resolved
+// first (each cascades a `put` into the node's `MergeNode`), then it folds ONCE
+// by the node's policy (default last-writer-wins) and writes to its parent — the
+// dual of a forward getter reading its deps then computing. Everything else —
+// 1→1 chains, multi-parent splits (1→N / N→M, e.g. mean/diff), complement-
+// carrying stateful lenses — resolves during the walk.
 //
 // Mode table — a cell's role is fully determined by which fields are set:
 //   source      getter undefined                 (truth in currentValue)
@@ -31,15 +67,12 @@
 //   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).
+// `BwdSpec`). `pendingValue` is a source's staged forward write only; a getter
+// cell never uses it.
+// Forward flag bits (alien-signals v2), on `flags`. Backward state lives in a
+// SEPARATE word (`bflags`, `BF` below) so the two engines never share a bit: a
+// forward recompute that resets `flags` can't disturb a pending back-write, and
+// vice versa — the duals are fully decoupled (no preservation hacks).
 const F = {
     None: 0,
     Mutable: 1,
@@ -48,9 +81,74 @@ const F = {
     Recursed: 8,
     Dirty: 16,
     Pending: 32,
-    /** Backward-only: cell has a pending backward contribution queued. */
-    BwdQueued: 64,
 };
+// Backward flag bits, on a Cell's own `bflags` word (the dual of `flags`).
+const BF = {
+    None: 0,
+    /** Backward dual of `F.Dirty`: this VIEW holds an unresolved back-write target
+     *  in `pendingValue` (a getter cell never uses that field forward). The root
+     *  of a pending back-write; `writeBack` consumes the target and clears it. */
+    Dirty: 1,
+    /** Backward dual of `F.Pending`: this node lies on the back-path from a
+     *  `BF.Dirty` view down to its sources. `markDown` sets it on descent; it gates
+     *  `resolveCone`, which ascends `_lensSubs` only through `BF.Pending` nodes (so
+     *  a read resolves only its own back-cone), and `writeBack` clears it on the
+     *  way back down. */
+    Pending: 2,
+};
+// Named mask (legibility): a cell's whole backward state in one test.
+/** Armed root OR on a back-path — i.e. a read must `backResolve` first. */
+const BACK_MARKED = BF.Dirty | BF.Pending;
+/** Multi-out / stateful back-write sentinel: "leave this parent untouched."
+ *  A `bwd` returning per-parent updates yields `SKIP` for a parent it declines
+ *  to write; every other slot value is written verbatim — INCLUDING `undefined`,
+ *  which is a first-class cell value, not a hole. A SHORT array skips the trailing
+ *  parents (so writing only the leading few needs no `SKIP` padding); `[]` skips
+ *  all. (Single-out 1→1 `put` has no skip notion: it always writes its one parent,
+ *  so it stays `undefined`-safe by construction.) */
+export const SKIP = Symbol("bireactive.SKIP");
+// Mode predicates — the single place a cell's role is read off its fields (see
+// the mode table by `BwdSpec`). V8 inlines these; the backward walk reads them
+// instead of duplicating `getter`/`_bwd` field probes.
+/** 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. A split routes around
+ *  it; a sole parent has nowhere to land (the back-walk throws). */
+function isReadOnlyDerived(c) {
+    return !isSource(c) && !isWritable(c);
+}
+/** Forward primal a source-reading `bwd` linearizes at, WITHOUT a cascading
+ *  recompute (the lazy dual of reverse-mode AD reusing a stored linearization
+ *  point). Source or realized derived → its live/last-settled value (PutGet
+ *  holds for any source state, so a stale primal still round-trips); unrealized
+ *  derived (`Dirty`) → realize once via `.value`, seeding `currentValue`. */
+function backPrimal(c) {
+    if (c.getter === undefined || c.flags & F.Dirty)
+        return c.value;
+    return c.currentValue;
+}
+/** Register `node` on each backward parent's `_lensSubs` (the edge `resolveCone`
+ *  ascends), once, lazily on the first back-write — so a lens only ever read
+ *  forward never allocates it. Idempotent via `_linkedBack`; persists for life. */
+function linkBack(node) {
+    if (node._linkedBack)
+        return;
+    node._linkedBack = true;
+    const parent = node._bwd.parent; // set for every mode except `pin` (parentless)
+    if (parent === undefined)
+        return;
+    if (Array.isArray(parent))
+        for (let i = 0; i < parent.length; i++)
+            (parent[i]._lensSubs ??= []).push(node);
+    else
+        (parent._lensSubs ??= []).push(node);
+}
 let cycle = 0;
 let runDepth = 0;
 let batchDepth = 0;
@@ -58,14 +156,26 @@ let notifyIndex = 0;
 let queuedLength = 0;
 let activeSub;
 let flushing = false;
+/** A microtask is queued to flush the effect queue. Effects run ASYNCHRONOUSLY
+ *  (end of the current microtask turn), so a burst of synchronous writes wakes
+ *  each effect at most once — no `batch()` needed for coalescing. Reads stay
+ *  synchronous and pull-based (a `.value` reflects writes immediately); only
+ *  EFFECT side-effects defer. `settle()` forces a synchronous flush. */
+let scheduled = false;
+/** A `network` (constraint solver / explicit reactive sub-DAG) is in the queue.
+ *  Networks are EAGER — a write that wakes one flushes the whole queue
+ *  synchronously, so a read right after the write sees post-solve state (and any
+ *  effect woken alongside runs after the network, in queue order). Only writes
+ *  that wake effects ALONE defer to the microtask. */
+let networkQueued = false;
 /** Network running its body, if any. Source writes self-exclude it so a
  *  network reading+writing a cell doesn't re-trigger itself. */
 let activeNetwork;
 const queued = [];
+/** Re-entrancy guard: while a back-resolve runs, a `put`'s source read commits
+ *  normally (in-order composition) but must NOT trigger a nested resolve. */
+let draining = false;
 const EMPTY_DIRTY = new Set();
-/** 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.
@@ -207,7 +317,15 @@ 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 (leaf: no getter) looks unchanged until its
+            // back-write resolves; `_update` resolves it (pulls its registered views,
+            // runs the `put`s), then reports whether it moved — like a forward-`Dirty`
+            // source. Intermediate views are also back-`Pending`, but they have a
+            // getter and fall through to the `Pending` recurse below.
+            (flags & F.Mutable &&
+                dep.bflags & BF.Pending &&
+                isSource(dep))) {
             const subs = dep.subs;
             if (dep._update()) {
                 if (subs.nextSub !== undefined)
@@ -232,11 +350,18 @@ 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 — `shallowPropagate` fires when a lazy back-write
+            // commits its source mid-`checkDirty` (a hazard a forward-only engine never
+            // sees, since sources commit before the pull). Honor that bit too, else we'd
+            // clear its `F.Pending` below without recomputing — stranding a `Dirty` node
+            // whose observers never re-run.
+            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,41 +414,15 @@ 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 this merge's cone resolves; folded and cleared
+     *  in `foldMerge` (the merge-owned buffer, mutated in place). The parent it
+     *  writes to is just `b.parent` (a merge's `b.parent` IS its fold target), so
+     *  this node carries only the policy + buffer — no duplicate edge. */
+    contributions = [];
+    constructor(fold) {
+        this.foldFn = fold;
     }
 }
 // BwdSpec — the backward sidecar.
@@ -340,23 +439,20 @@ class MergeNode {
 // 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`.
+// `parent` + `put`.
 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` — backward derivation (dual of `getter`). A 1→1 / multi-out
+     *  lens is called as `put(target)` (a source-reading lens reads the current
+     *  parent(s) at walk time, untracked); multi-out returns a per-parent update
+     *  array. Stateful is the spec's `bwd`, called `put(target, sources, c)`. */
     // biome-ignore lint/suspicious/noExplicitAny: put fn is opaque shape
     put = undefined;
     /** Backward aggregation node; presence IS the merge-mode discriminant. */
     merge = undefined;
     /** Complement machinery; presence IS the stateful-mode discriminant. */
     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;
 }
 /** Runtime state of a stateful (complement-carrying) lens — the rare
  *  backward mode, kept off `BwdSpec` so plain lenses don't carry its slots.
@@ -365,22 +461,21 @@ class BwdSpec {
 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, external)`. (The
+     *  forward projection `fwd` is captured directly in the getter closure — it
+     *  is only ever read there — so it costs no slot here.) */
     // 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;
+    /** Sources this lens last committed back (the own-vs-external test compares
+     *  live sources against these); `undefined` until the first back-write. A
+     *  back-write reads the live sources into a fresh array, builds the committed
+     *  candidate in place, and keeps it as `last` for the next own-vs-external
+     *  comparison. */
+    last = undefined;
     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;
     }
 }
@@ -414,34 +509,40 @@ export const isLens = (v) => v instanceof Cell && v.getter !== undefined && v._b
 /** Read-only mode: derived with no backward path. */
 export const isReadonly = (v) => v instanceof Cell && v.getter !== undefined && v._bwd === undefined;
 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 Backward dual of `subs`: direct lens-children for back-write cone traversal. */
+    _lensSubs;
+    /** @internal Backward flag word (`BF`), dual of forward `flags`. */
+    bflags;
+    /** @internal Guards against `linkBack` re-registering a duplicate in `_lensSubs`. */
+    _linkedBack;
+    // Every slot is assigned exactly once below, in declaration order, for a stable
+    // V8 hidden class across all variants (source / computed / lens / merge).
     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 +551,12 @@ export class Cell {
         this._equals = Object.is;
         this._watched = undefined;
         this._unwatchedHook = undefined;
+        this.currentValue = initial;
+        this.pendingValue = initial;
         this._bwd = undefined;
+        this._lensSubs = undefined;
+        this.bflags = BF.None;
+        this._linkedBack = false;
         if (opts !== undefined) {
             if (opts.equals !== undefined)
                 this._equals = opts.equals;
@@ -460,14 +566,12 @@ export class Cell {
                 this._unwatchedHook = opts.unwatched;
         }
     }
-    _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) {
+        // A forward write to a source with an unresolved back-write demand resolves
+        // it 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)) {
@@ -475,15 +579,15 @@ export class Cell {
             if (writeHook !== undefined)
                 writeHook(this);
             const subs = this.subs;
-            if (subs !== undefined)
+            if (subs !== undefined) {
                 propagate(subs, runDepth > 0, activeNetwork);
-            if (batchDepth === 0 && !flushing && subs !== undefined)
-                flush();
+                autoFlush();
+            }
         }
     }
+    /** @internal */
     _update() {
         if (this.getter !== undefined) {
-            // Computed/lens/merge: re-run the forward derivation.
             this.depsTail = undefined;
             this.flags = F.Mutable | F.RecursedCheck;
             const prev = activeSub;
@@ -502,12 +606,20 @@ export class Cell {
                 purgeDeps(this);
             }
         }
+        // A back-`Pending` source first resolves its armed back-write (`backResolve`
+        // pulls the views registered on it, runs the `put`s, stages it via
+        // `_writeSource`) — so its `pendingValue` reflects the back-write before we
+        // commit it.
+        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() {
         if (this.getter !== undefined && this.depsTail !== undefined) {
             this.flags = F.Mutable | F.Dirty;
@@ -527,10 +639,6 @@ 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
@@ -545,10 +653,11 @@ export class Cell {
     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) {
+    /** Backward fan-in node. Forward, the identity view of its parent;
+     *  backward, the convergence point where N contributors (upstream lenses
+     *  and direct writes) fold into one value for the parent. `fold` is handed
+     *  every live push at once; omitted, it is last-writer-wins. */
+    merge(fold) {
         if (this.getter !== undefined && this._bwd === undefined) {
             throw new TypeError("merge: receiver is read-only");
         }
@@ -558,7 +667,7 @@ export class Cell {
         cell.getter = () => parent.value;
         const b = (cell._bwd = new BwdSpec());
         b.parent = parent;
-        b.merge = new MergeNode(parent, policy);
+        b.merge = new MergeNode(fold);
         return cell;
     }
     // biome-ignore lint/suspicious/noExplicitAny: dispatch
@@ -575,10 +684,10 @@ export class Cell {
     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) {
@@ -594,27 +703,25 @@ export class Cell {
         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 at `parent === undefined` before any
+        // `put`, so the sink needs no closure — writability is just `_bwd !== undefined`.
+        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`. */
+// biome-ignore lint/suspicious/noExplicitAny: variance escape
+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));
     }
+    return buildLens1(ctor, parent, get, (v, s) => ({ ...s, [key]: v }), true);
 }
 // biome-ignore lint/suspicious/noExplicitAny: variance escape
 function buildDerived(Cls, getter) {
@@ -629,9 +736,11 @@ function buildLens1(Cls, parent, fwd, bwd, readsSource) {
     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;
+    // Source-reading lenses linearize at the parent's primal (`backPrimal`: the
+    // last-settled value for a derived, the staged truth for a source) so the
+    // engine always calls the 1-arg form (no arity branch) and never recomputes a
+    // derived parent's cone just to read it back.
+    b.put = readsSource ? (t) => bwd(t, backPrimal(parent)) : bwd;
     b.parent = parent;
     return cell;
 }
@@ -650,13 +759,21 @@ function buildLensN(Cls, parents, fwd, bwd, readsSource) {
         return cell; // read-only derive-N
     const b = (cell._bwd = new BwdSpec());
     b.parent = parents;
-    b.put = readsSource
-        ? (target) => {
+    if (readsSource) {
+        // Own reused buffer, NOT the getter's `vals`: the walk reads each parent's
+        // primal (`backPrimal`), so a separate array avoids aliasing the getter's.
+        // `bwd` consumes it synchronously and must not retain it (same as `fwd`);
+        // re-entry through the same lens is impossible (the lens graph is a DAG).
+        const args = new Array(n);
+        b.put = (target) => {
             for (let i = 0; i < n; i++)
-                vals[i] = parents[i].peek();
-            return bwd(target, vals);
-        }
-        : (target) => bwd(target);
+                args[i] = backPrimal(parents[i]);
+            return bwd(target, args);
+        };
+    }
+    else {
+        b.put = (target) => bwd(target);
+    }
     return cell;
 }
 // biome-ignore lint/suspicious/noExplicitAny: variance escape
@@ -671,7 +788,8 @@ 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));
+    const sc = (b.stateful = new StatefulCore(spec.init(seed), spec.step));
+    const fwd = spec.fwd;
     b.put = spec.bwd;
     b.parent = parents;
     cell.getter = (() => {
@@ -680,7 +798,7 @@ spec) {
         // External unless the live sources still equal this lens's own last
         // back-write.
         let external = true;
-        const lb = sc.lastBwd;
+        const lb = sc.last;
         if (lb !== undefined) {
             external = false;
             for (let i = 0; i < n; i++) {
@@ -691,7 +809,7 @@ spec) {
             }
         }
         sc.complement = sc.step(vals, sc.complement, external);
-        return sc.fwd(vals, sc.complement);
+        return fwd(vals, sc.complement);
     });
     return cell;
 }
@@ -707,16 +825,17 @@ 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 sc = (b.stateful = new StatefulCore(spec.init([parent.peek()]), spec.step));
+    const fwd = spec.fwd;
     b.put = spec.bwd;
     b.parent = [parent];
     const vals = [undefined];
     cell.getter = (() => {
         const v = (vals[0] = parent.value);
-        const lb = sc.lastBwd;
+        const lb = sc.last;
         const external = lb === undefined || lb[0] !== v;
         sc.complement = sc.step(vals, sc.complement, external);
-        return sc.fwd(vals, sc.complement);
+        return fwd(vals, sc.complement);
     });
     return cell;
 }
@@ -746,9 +865,17 @@ function dispatchLens(ctor, args) {
         return buildLensN(ctor, parent, a, b, readsSource);
     return buildLens1(ctor, parent, a, b, readsSource);
 }
-// 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 a prototype getter
+// better, and it keeps the field-only class shape for a stable hidden class.
 Object.defineProperty(Cell.prototype, "value", {
     get() {
+        // Reading is the PULL. A back-marked cell resolves at this clean entry,
+        // BEFORE its own compute, so a source-reading `put` never re-enters a
+        // half-computed cell. `backResolve` descends `_bwd` to the sources and pulls
+        // the writers registered there, touching only this cell's back-cone
+        // (granular — sibling chains untouched).
+        if (this.bflags & BACK_MARKED && !draining)
+            backResolve(this);
         const flags = this.flags;
         if (this.getter !== undefined) {
             if (flags & F.RecursedCheck) {
@@ -763,26 +890,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,228 +914,339 @@ 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);
+        // GetPut for a multi-parent split: its `put` may move sources even when the
+        // view is unchanged (a lossy redistribution that `_writeSource`'s per-source
+        // equality can't catch), so absorb a write that maps to the current view
+        // here. (Stateful excluded — peeking would step its complement.)
+        if (Array.isArray(b.parent) && b.stateful === undefined && this._equals(next, this.peek())) {
             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();
-            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);
-    }
-    finally {
-        activeSub = prev;
+/** Backward push: arm a back-write of `target` on view `node` (the dual of a
+ *  source `set`). A re-write of a still-armed view (an unobserved drag) keeps
+ *  only the last target — the path down to the sources is already marked, so
+ *  skip the walk and coalesce. The trailing `schedule` wakes the effects the
+ *  push woke (on the microtask turn); each effect's read pulls its own cone. */
+function arm(node, target) {
+    if (!(node.bflags & BF.Dirty)) {
+        markDown(node); // flag path + wake cones, FIRST (a throw arms nothing)
+        node.bflags |= BF.Dirty;
     }
+    node.pendingValue = target; // the view holds its own demand (getters ignore this field)
+    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 forward `propagate`: descend `start`'s static backward
+ *  path down `_bwd.parent` to its sources, flag each node `BF.Pending`, register
+ *  the reverse edge (`linkBack`), and wake every source's forward cone. Runs no
+ *  `put` — an over-approximation `resolveCone` later resolves precisely.
+ *
+ *  `BF.Pending` is its own dedup: an already-marked node has its whole (static)
+ *  subtree marked, so descent stops there (diamonds cost one visit). A merge
+ *  relays to its parent; a sole read-only-derived parent has nowhere to land →
+ *  throw. The 1→1 spine allocates nothing (`stack` is built only on a branch). */
+function markDown(start) {
+    let node = start;
+    let stack;
+    for (;;) {
+        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, activeNetwork);
+            }
         }
-        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 (dual of a `Pending` intermediate). An already-marked
+            // intermediate (≠ start) has its subtree marked — stop (diamond dedup).
+            if (node !== start)
+                node.bflags |= BF.Pending;
+            linkBack(node); // register the reverse edge lazily, on first back-write
+            // `b.parent` is the back-target for EVERY mode (a merge's fold target is
+            // just its single, always-writable parent), so one descent covers all.
+            const parent = node._bwd.parent;
+            if (parent !== undefined) {
+                if (Array.isArray(parent)) {
+                    const multi = parent.length > 1;
+                    for (let i = 0; i < parent.length; i++) {
+                        const p = parent[i];
+                        if (isReadOnlyDerived(p)) {
+                            // A split routes around it; a sole parent can't.
+                            if (!multi)
+                                throw new TypeError("Cannot write through to a computed");
+                        }
+                        else if (next === undefined)
+                            next = p;
+                        else
+                            (stack ??= []).push(p);
+                    }
+                }
+                else if (isReadOnlyDerived(parent)) {
+                    throw new TypeError("Cannot write through to a computed");
+                }
+                else {
+                    next = parent;
+                }
+            }
         }
-        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;
-            }
-        }
-        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;
+/** RESOLVE (pull), dual of forward `checkDirty`: resolve ONE node's whole
+ *  back-cone. Ascend the static reverse adjacency `_lensSubs` (only `BACK_MARKED`
+ *  children) to the armed views above, `writeBack`ing each. Source-CENTRIC — a
+ *  source must reflect ALL its writers (they compose into one committed value),
+ *  so a call on the source resolves every co-writer together and commits once.
+ *  `BF.Dirty` is the dedup.
+ *
+ *  Recursive so a MERGE folds POST-ORDER (the one non-dual ingredient): resolve
+ *  its contributors first (each cascades a `put` into `contributions`), then fold
+ *  once on the way back up and write the parent, as a getter reads deps then
+ *  computes. */
+function resolveCone(node) {
+    const b = node._bwd;
+    const merge = b !== undefined ? b.merge : undefined;
+    if (merge !== undefined)
+        merge.contributions.length = 0; // self-heal contributions left by a prior throw
+    // Drive this node's own armed target first (composes before child writes —
+    // preserves last-writer-wins order among co-writers of a shared parent).
+    if (node.bflags & BF.Dirty) {
+        node.bflags &= ~BF.Dirty;
+        writeBack(node, node.pendingValue);
+    }
+    const children = node._lensSubs;
+    if (children !== undefined) {
+        for (let i = 0; i < children.length; i++) {
+            const c = children[i];
+            if (c.bflags & BACK_MARKED)
+                resolveCone(c);
         }
-        sc.lastBwd = cand;
-        if (deferred) {
-            forkInto(parents, updates, n);
-            return;
+    }
+    node.bflags &= ~BF.Pending; // resolved (idempotent with `writeBack`'s clear)
+    if (merge !== undefined)
+        foldMerge(b.parent, merge); // contributors in → fold once
+}
+/** PULL entry for a back-marked `start`. Source-centric: a source read resolves
+ *  its own cone; a VIEW read first DESCENDS its marked back-path (`_bwd.parent`
+ *  through `BF.Pending`) to the sources, then resolves each source's whole cone
+ *  (so co-writers compose and the source commits once). The `draining` guard
+ *  stops a `put`'s source read from re-entering. */
+function backResolve(start) {
+    draining = true;
+    ++batchDepth;
+    const prev = activeSub;
+    activeSub = undefined;
+    try {
+        if (isSource(start)) {
+            resolveCone(start);
         }
-        ++batchDepth;
-        try {
-            forkInto(parents, updates, n);
+        else {
+            // Descend the marked back-path to every source, resolving each source's
+            // cone. A view with no source to land on (a `pin` sink) resolves itself.
+            let node = start;
+            let stack;
+            let reached = false;
+            for (;;) {
+                let next;
+                const b = node._bwd;
+                const parent = b !== undefined ? b.parent : undefined; // merge's parent IS b.parent
+                if (parent !== undefined) {
+                    if (Array.isArray(parent)) {
+                        for (let i = 0; i < parent.length; i++) {
+                            const p = parent[i];
+                            if (isSource(p)) {
+                                reached = true;
+                                if (p.bflags & BF.Pending)
+                                    resolveCone(p);
+                            }
+                            else if (p.bflags & BF.Pending) {
+                                if (next === undefined)
+                                    next = p;
+                                else
+                                    (stack ??= []).push(p);
+                            }
+                        }
+                    }
+                    else if (isSource(parent)) {
+                        reached = true;
+                        if (parent.bflags & BF.Pending)
+                            resolveCone(parent);
+                    }
+                    else if (parent.bflags & BF.Pending) {
+                        next = parent;
+                    }
+                }
+                if (next !== undefined)
+                    node = next;
+                else if (stack !== undefined && stack.length > 0)
+                    node = stack.pop();
+                else
+                    break;
+            }
+            if (!reached && start.bflags & BF.Dirty) {
+                start.bflags &= ~BF.Dirty;
+                writeBack(start, start.pendingValue);
+            }
         }
-        finally {
-            if (!--batchDepth)
-                flush();
+    }
+    finally {
+        activeSub = prev;
+        --batchDepth;
+        draining = false;
+    }
+}
+/** Resolve any back-write a woken reactive node reads DIRECTLY. `checkDirty`
+ *  alone catches back-writes that move a source (it ascends to the source),
+ *  but a stateful "stash" moves only the VIEW (the complement echoes a value
+ *  back, no source changes) — invisible to a source-based check. Resolving the
+ *  node's back-marked deps here makes that view-change visible before the
+ *  dirtiness check. Granular: only this node's own deps. */
+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);
+    }
+}
+/** Backward commit/compute (dual of forward `_update`): drive a back-write of
+ *  `target` toward the sources, applying each lens's `put`, clearing `BF.Pending`
+ *  on descent, and staging each source as it's reached (so a later sibling reading
+ *  that SAME source composes rather than clobbers). A `SKIP` per-parent slot
+ *  prunes a branch; every other slot is written verbatim, `undefined` included. A
+ *  `merge` accumulates (folded post-order by `resolveCone`); a read-only parent
+ *  throws (already caught at MARK time). */
+function writeBack(node, target) {
+    if (isSource(node)) {
+        node._writeSource(target); // source — staged now, visible to later siblings
+        // Clear this source's back-`Pending`, then re-assert it iff a lens-child is
+        // STILL armed (an overlapping co-writer through this same source) — a later
+        // read must still resolve them, else that write is lost. (Forward writes
+        // live on `flags`, back-state on `bflags`, so the source-stage above no
+        // longer touches `Pending`; we own clearing it here.) `_lensSubs` holds only
+        // ever-back-written children, so this is a short flag scan, not a registry walk.
+        node.bflags &= ~BF.Pending;
+        const subs = node._lensSubs;
+        if (subs !== undefined) {
+            for (let i = 0; i < subs.length; i++)
+                if (subs[i].bflags & BACK_MARKED) {
+                    node.bflags |= BF.Pending;
+                    break;
+                }
         }
         return;
     }
-    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);
+    node.bflags &= ~BF.Pending; // passing through clears the path marker
+    const b = node._bwd;
+    if (b === undefined)
+        throw new TypeError("Cannot write through to a computed");
+    if (b.merge !== undefined) {
+        b.merge.contributions.push(target); // gathered here; `resolveCone` folds post-order
         return;
     }
-    ++batchDepth;
-    try {
-        forkInto(parents, updates, n);
-    }
-    finally {
-        if (!--batchDepth)
-            flush();
+    const parent = b.parent;
+    if (parent === undefined)
+        return; // pin sink: absorb
+    if (Array.isArray(parent)) {
+        const n = parent.length;
+        let out;
+        const sc = b.stateful;
+        if (sc !== undefined) {
+            const vals = new Array(n);
+            for (let i = 0; i < n; i++)
+                vals[i] = parent[i].value;
+            // Bring the complement to the current sources before `bwd` (the dual of
+            // the forward getter's step) so it measures devs/fracs from a prior
+            // sibling write, not a stale snapshot. External unless the sources still
+            // equal this lens's own last back-write.
+            const last = sc.last;
+            let external = last === undefined;
+            if (last !== undefined) {
+                for (let i = 0; i < n; i++)
+                    if (vals[i] !== last[i]) {
+                        external = true;
+                        break;
+                    }
+            }
+            sc.complement = sc.step(vals, sc.complement, external);
+            const res = b.put(target, vals, sc.complement);
+            const upd = res.updates;
+            // Build the committed candidate IN `vals` (its source reads are spent) and
+            // keep it as `last` for the next own-vs-external comparison. A `SKIP` slot —
+            // or a slot past a short `upd` — leaves that parent at its current `vals[i]`.
+            const um = upd.length < n ? upd.length : n;
+            for (let i = 0; i < um; i++)
+                if (upd[i] !== SKIP)
+                    vals[i] = upd[i];
+            sc.complement = sc.step(vals, res.complement, false);
+            sc.last = vals;
+            out = upd;
+        }
+        else {
+            out = b.put(target);
+        }
+        // A short `out` skips the trailing parents (the dual of a forward getter
+        // reading fewer deps); `SKIP` skips a specific slot; a real `undefined` is
+        // written verbatim.
+        let wrote = false;
+        const m = out.length < n ? out.length : n;
+        for (let i = 0; i < m; i++) {
+            const u = out[i];
+            if (u !== SKIP) {
+                wrote = true;
+                writeBack(parent[i], u);
+            }
+        }
+        // A stateful lens can change its VIEW through the complement alone, moving
+        // no source (a degenerate "stash" — e.g. a collapsed axis remembering the
+        // written angle, or a broken parse holding the typed text). No source write
+        // means the forward cone never fires, so invalidate the node's own cache and
+        // propagate to its observers here.
+        if (!wrote && sc !== undefined) {
+            node.flags |= F.Dirty;
+            const subs = node.subs;
+            if (subs !== undefined)
+                propagate(subs, runDepth > 0, activeNetwork);
+        }
+        return;
     }
+    // 1→1 lens.
+    writeBack(parent, b.put(target));
 }
-/** 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)
-            continue;
-        const parent = parents[i];
-        if (parent.getter === undefined)
-            parent._writeSource(u);
-        else
-            propagateBwd(parent, u, true);
-    }
+/** Fold one merge's gathered contributions ONCE (its policy; default
+ *  last-writer-wins) and write the result up to its parent. Called post-order
+ *  from `resolveCone` once every contributor has cascaded in — fan-in is the one
+ *  non-dual ingredient. Runs untracked (`backResolve` already cleared
+ *  `activeSub`). */
+function foldMerge(parent, mn) {
+    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);
 }
 /** Writable source; passes an existing `Writable` through (idempotent). */
 export function cell(initial, opts) {
@@ -1101,6 +1324,10 @@ class Effect {
             this._runCleanup();
     }
     _run() {
+        // Resolve back-writes this effect reads directly (incl. view-only stashes),
+        // then let `checkDirty` resolve any back-`Pending` source reached deeper.
+        if (this.deps !== undefined)
+            resolveBackDeps(this);
         const flags = this.flags;
         if (flags & F.Dirty || (flags & F.Pending && checkDirty(this.deps, this))) {
             if (this.cleanup) {
@@ -1146,47 +1373,59 @@ export function effect(fn) {
     const e = new Effect(fn);
     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
+ *  (`resolveBackDeps` + `checkDirty` → `backResolve`, which also folds merges),
+ *  so flush owns NO backward bookkeeping — just the effect queue. */
 function flush() {
     if (flushing)
         return;
     flushing = true;
-    let bwdIndex = 0;
     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;
-                e._run();
-            }
+        while (notifyIndex < queuedLength) {
+            const e = queued[notifyIndex];
+            queued[notifyIndex++] = undefined;
+            e._run();
         }
     }
     finally {
-        bwdQueue.length = 0;
         notifyIndex = 0;
         queuedLength = 0;
+        networkQueued = false;
         flushing = false;
     }
 }
+/** 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 network is waiting (eager solve) or
+ *  deferred to the microtask (coalesced effects). */
+function autoFlush() {
+    if (batchDepth !== 0 || flushing)
+        return;
+    if (networkQueued)
+        flush();
+    else
+        schedule();
+}
+/** Run all pending effects NOW, synchronously. The escape hatch for code (tests,
+ *  imperative call sites) that must observe effect side-effects before yielding
+ *  to the microtask queue. Reads never need it — they pull current values. */
+export function settle() {
+    flush();
+}
+/** Group writes and flush effects SYNCHRONOUSLY at the end of `fn` — a sync
+ *  barrier. Effects coalesce on the microtask turn anyway (see `schedule`), so
+ *  `batch` is no longer needed for that; reach for it only when you must run the
+ *  woken effects before the call returns (and don't want a `settle()`). */
 export function batch(fn) {
     ++batchDepth;
     try {
@@ -1243,6 +1482,7 @@ class _NetworkNode {
             return;
         }
         queued[queuedLength++] = this;
+        networkQueued = true; // eager: a queued network forces a synchronous flush
         this.flags &= ~F.Watching;
     }
     _unwatched() {
@@ -1257,6 +1497,8 @@ class _NetworkNode {
     _run() {
         if (this.disposed)
             return;
+        if (this.deps !== undefined)
+            resolveBackDeps(this);
         const flags = this.flags;
         if (flags & F.Dirty || (flags & F.Pending && checkDirty(this.deps, this))) {
             this._runBody(this._computeDirty());
@@ -1279,7 +1521,7 @@ class _NetworkNode {
     _runBody(dirty) {
         // RecursedCheck doubles as the "body running" guard (see flush()).
         this.flags = F.Watching | F.RecursedCheck;
-        const prevSettler = activeNetwork;
+        const prevNetwork = activeNetwork;
         activeNetwork = this;
         try {
             ++cycle;
@@ -1295,7 +1537,7 @@ class _NetworkNode {
         }
         finally {
             --runDepth;
-            activeNetwork = prevSettler;
+            activeNetwork = prevNetwork;
             this.flags &= ~F.RecursedCheck;
             this.lastValues.clear();
             let l = this.deps;
@@ -1374,10 +1616,9 @@ deps, body, opts) {
     node._initWithHandle(handle, deps);
     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.
+// `fieldLens`/`cachedDerive` are the two getter forms a value class declares.
 // The choice between them IS the local declaration of writability at each
 // getter (mirroring `: this` invertible method returns). For arbitrary
 // cached views, use `lazy()` directly.
@@ -1385,9 +1626,9 @@ deps, body, opts) {
  *  replaces the composite. Cached per (instance, key). Return type is
  *  conditional: `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