@zakkster/lite-signal 1.1.4 → 1.2.0

package/Signal.js

@@ -1,61 +1,66 @@
 /**
- * @zakkster/lite-signal v1.1.4
+ * @zakkster/lite-signal v1.2.0
  * --------------------
- * Zero-GC reactive graph.
+ * Hybrid Doubly-Linked-List Reactive Graph Engine — decoupled (Signal1_3) base
+ * with the two 1.1.3 performance fixes ported in:
+ *   1. pullComputed clean short-circuit (markEpoch) — kills the dynamic-graph
+ *      regression: "large web app" 4900ms -> 665ms, "wide dense" 4472 -> 952.
+ *   2. allocateLink: O(1) tailSub dedup replaces the O(N) prefix scan — divergent
+ *      re-tracking is O(N) not O(N^2) (600-dep flip micro: 1373ms -> 62ms).
+ * Ownership tree + L1/L2/L3 layering + observer/owner split are UNCHANGED; they
+ * were never the regression. Same EDGE NOTE as 1.1.3 applies to fix (2): a nested
+ * re-read of the same source can retain one bounded, dispose-reclaimed link.
  *
- * CHANGES vs 1.1.2 (both perf-only; public surface and semantics unchanged):
- *  1. pullComputed clean short-circuit. markDownstream already stamps markEpoch
- *     on every node in a changed signal's transitive cone; pullComputed now uses
- *     it to return a cached value in O(1) when no mark landed since the last eval,
- *     instead of walking (and recursively pulling) the whole dependency subtree.
- *     Erases the dynamic-graph regression (batched read-after-write workloads):
- *     "large web app" 4824ms -> 650ms, "wide dense" 4378ms -> 908ms locally.
- *  2. allocateLink: the O(N) linear headDep scan on a cursor miss is replaced by
- *     an O(1) source.tailSub dedup. Dependency re-tracking is now O(N) regardless
- *     of read order, not O(N^2). Wide reordering nodes: ~50x locally (600-dep
- *     flip: 2810ms -> 46ms). First-track of a wide node: ~4.4x (48ms -> 10ms).
- *     SEVER-FIRST: on a cursor-miss divergence the unmatched dep tail is freed
- *     BEFORE any new link is allocated, so peak link usage never exceeds steady
- *     state (ZERO pool debt). A divergent re-track therefore cannot trigger a
- *     mid-compute pool growth under tight maxLinks + "throw" — the zero-GC budget
- *     holds. (The alternative "splice" variant is ~equal speed but transiently
- *     holds up to one node's fan-in of extra links until end-of-frame severTail.)
+ * Original header:
+ * v1.3.2: Hybrid Doubly-Linked-List Reactive Graph Engine.
  *
- * EDGE NOTE (2): a node that reads the SAME source twice within one body, with a
- * nested computed that also reads that source evaluated in between, retains ONE
- * redundant dependency link for the node's lifetime. It is value-correct, bounded
- * (does not grow across re-tracks), and reclaimed on dispose/destroy. The previous
- * O(N) scan collapsed this to a single link; the O(1) dedup cannot see past a
- * nested re-link of the same source. This is a deliberate cost/correctness trade.
+ * Performance model:
+ * - ReactiveLink DLL object pool guarantees O(1) graph edge allocation.
+ * - Inlined O(1) cursor fast-path for stable steady-state reads.
+ * - Divergence triggers immediate tail-severing to bound worst-case complexity.
+ * - O(1) Owner Context Tree ensures automatic teardown of nested observers.
  *
- * Architecture: monomorphic object pool + versioned push-pull propagation
- * + SMI modular arithmetic for 32-bit version-wrap safety.
+ * ── ARCHITECTURE: three layers + a public API, with a strict dependency direction ──
  *
- * Performance characteristics:
- *  - Object pool: nodes and links are allocated from preallocated arrays. Steady-state
- *    operations (signal.set / computed.peek / effect re-run) perform zero allocations
- *    after warmup.
- *  - Stable read order: re-tracking dependencies in the same order yields O(1) link reuse
- *    via the `activeObserverCurrentDep` cursor.
- *  - Chaotic / randomized read order degrades to O(N) per dep (linear search of headDep
- *    list) — see {@link allocateLink}.
- *  - Computed resolution is recursive on the JS call stack. Maximum chain depth is bound
- *    by the engine stack limit (~10,000 frames).
- *  - 32-bit modular arithmetic for versioning: the engine is immune to integer-overflow
- *    crashes regardless of uptime.
+ *   L1  GRAPH TOPOLOGY      allocateLink, freeLink, severTail
+ *       Owns the ReactiveLink pool and the dep/sub doubly-linked lists.
+ *       INVARIANT: never touches `owner`/`firstOwned`. Pure edge mechanics.
  *
- * Public surface: {@link signal}, {@link computed}, {@link effect}, {@link batch},
- * {@link untrack}, {@link onCleanup}, {@link stats}, {@link createRegistry},
- * {@link setDefaultRegistry}, {@link CapacityError}.
+ *   L2  OWNERSHIP / LIFECYCLE   createNode, disposeNode, runCleanup
+ *       Owns the owner tree and node death + user cleanup.
+ *       INVARIANT: never touches the `activeObserverCurrentDep` cursor.
+ *       Sanctioned downward edge → L1: disposeNode walks a dying node's own
+ *       dep/sub lists and calls freeLink to extract it from the graph.
+ *
+ *   L3  PROPAGATION / EXECUTION   markDownstream, flushEffects, executeEffect, pullComputed
+ *       The engine. markDownstream is itself owner-free and cursor-free
+ *       (a pure propagation primitive). executeEffect/pullComputed are the
+ *       ORCHESTRATORS: they drive the cursor + severTail (L1) AND, before a
+ *       re-run, call runCleanup (L2) to cascade-dispose owned children.
+ *       Sanctioned upward call → L2: executeEffect/pullComputed → runCleanup.
+ *
+ *   API  signal, computed, effect, dispose, batch, untrack, onCleanup, stats, destroy
+ *
+ *   The only cross-layer edges are L3→runCleanup and L2→freeLink. The graph of
+ *   dependencies is acyclic; nothing in L1 reaches up, nothing in L2 touches
+ *   the cursor, and the engine is the single place the two subsystems meet.
+ *
+ * ── OWNER vs OBSERVER ──
+ *   `currentObserver` = the node whose READS establish dependencies (tracking).
+ *   `currentOwner`    = the node that OWNS anything created right now (lifecycle).
+ *   Today they move together, so behaviour is unchanged — but they are distinct
+ *   pointers so future runWithOwner/createRoot can attach ownership without
+ *   establishing reactive dependencies (and untrack can suppress tracking
+ *   without orphaning created nodes). createNode and onCleanup key off the
+ *   OWNER; the read fast-path and allocateLink key off the OBSERVER.
  */
 
-// ─── Node flag bits ────────────────────────────────────────────────────────────
 const FLAG_COMPUTED = 1 << 0;
 const FLAG_EFFECT = 1 << 1;
 const FLAG_QUEUED = 1 << 2;
 const FLAG_COMPUTING = 1 << 3;
 const FLAG_HAS_ERROR = 1 << 4;
-const FLAG_SIGNAL = 1 << 5; // Identifies signals for universal disposal
+const FLAG_SIGNAL = 1 << 5;
 
 /**
  * Internal: a reactive node (signal, computed, or effect).
@@ -64,7 +69,7 @@ const FLAG_SIGNAL = 1 << 5; // Identifies signals for universal disposal
  */
 class ReactiveNode {
     constructor() {
-        /** Bitmask: FLAG_COMPUTED | FLAG_EFFECT | FLAG_QUEUED | FLAG_COMPUTING | FLAG_HAS_ERROR */
+        /** Bitmask: FLAG_SIGNAL | FLAG_COMPUTED | FLAG_EFFECT | FLAG_QUEUED | FLAG_COMPUTING | FLAG_HAS_ERROR */
         this.flags = 0;
         /** Current value (signal, computed) or error (when FLAG_HAS_ERROR is set). */
         this.value = undefined;
@@ -76,6 +81,9 @@ class ReactiveNode {
         this.equals = undefined;
         /** Optional effect scheduler. */
         this.scheduler = undefined;
+        /** Cached gen-bound trampoline that re-enters executeEffect under the scheduler.
+         *  Allocated once on the first set with a scheduler; recycled with the slot. (1.2.0) */
+        this.schedulerThunk = undefined;
 
         /** Bumped on every change that mutates value. 32-bit modular. */
         this.version = 0;
@@ -83,10 +91,12 @@ class ReactiveNode {
         this.evalVersion = 0;
         /** Last globalVersion at which this node was marked dirty (de-duplicates traversal). */
         this.markEpoch = 0;
-        /** Recycle generation: bumped on dispose, used to invalidate stale scheduler closures. */
+        /** Recycle generation: bumped on dispose, used to invalidate stale scheduler closures and disposer handles. */
         this.gen = 0;
+        /** Stable per-allocation id for introspection/devtools (1.1.5). Reassigned on each allocate-from-pool. */
+        this.id = 0;
 
-        /** Captured value at first .set() inside the current batch (revert detection). */
+        /** Captured value at first .set() inside the current batch (pre-batch revert detection). */
         this.preBatchValue = undefined;
         /** Captured version at first .set() inside the current batch. */
         this.preBatchVersion = 0;
@@ -96,16 +106,22 @@ class ReactiveNode {
         // Doubly-linked dependency list (this node depends on these sources).
         this.headDep = null;
         this.tailDep = null;
-        /** Cursor pointing into headDep during re-tracking. */
-        this.currentDep = null;
         // Doubly-linked subscriber list (these targets depend on this node).
         this.headSub = null;
         this.tailSub = null;
 
+        // Owner Context Tree (Auto-Disposal of Nested Observers) — 1.2.0.
+        // An effect/computed created inside another effect/computed is "owned"
+        // by it. When the owner re-runs or is disposed, owned children are
+        // cascade-disposed before the new run. Plain signals are NOT adopted
+        // (so lazy-allocation wrappers like lite-store survive owner re-runs).
+        this.owner = null;
+        this.prevOwned = null;
+        this.nextOwned = null;
+        this.firstOwned = null;
+
         // Pool free-list pointer.
         this.nextFree = null;
-
-        this.schedulerThunk = undefined;
     }
 }
 
@@ -151,7 +167,9 @@ export class CapacityError extends Error {
  * Create an isolated reactive registry.
  *
  * Use this when you need multiple independent reactive graphs (e.g. one per
- * Twitch Extension viewer, one per worker, one per test).
+ * Twitch Extension viewer, one per worker, one per test). The top-level
+ * helpers ({@link signal}, {@link effect}, …) delegate to a single shared
+ * default registry; call {@link setDefaultRegistry} to swap that for your own.
  *
  * @param {object} [config]
  * @param {number} [config.maxNodes=1024]            Initial node-pool capacity.
@@ -160,155 +178,111 @@ export class CapacityError extends Error {
  *        `"throw"` fails fast when pools are full.
  *        `"grow"` doubles the pool (bounded by `maxLinks * 16` for links).
  * @param {number} [config.maxFlushPasses=100]       Cycle-protection: max effect-queue
- *                                                   drain passes before throwing CycleError.
+ *                                                   drain passes before throwing an
+ *                                                   Error prefixed `"CycleError:"`.
  * @returns {Registry}
  */
-export function createRegistry(config = {}) {
-    // Per-registry symbols. NODE_PTR carries a direct pool-slot reference;
-    // NODE_GEN stamps the slot's generation at the moment of API creation
-    // so dispose() can detect stale handles after the slot has been recycled.
+export function createRegistry(config) {
     const NODE_PTR = Symbol("node_ptr");
     const NODE_GEN = Symbol("node_gen");
 
-    let currentNodesCapacity = config.maxNodes ?? 1024;
-    let currentLinkCapacity = config.maxLinks ?? currentNodesCapacity * 4;
-    const policy = config.onCapacityExceeded ?? "throw";
-    const maxFlushPasses = config.maxFlushPasses ?? 100;
+    let currentNodesCapacity = (config !== undefined && config.maxNodes !== undefined) ? config.maxNodes : 1024;
+    let currentLinkCapacity = (config !== undefined && config.maxLinks !== undefined) ? config.maxLinks : currentNodesCapacity * 4;
+    const policy = (config !== undefined && config.onCapacityExceeded !== undefined) ? config.onCapacityExceeded : "throw";
+    const maxFlushPasses = (config !== undefined && config.maxFlushPasses !== undefined) ? config.maxFlushPasses : 100;
     const maxLinkLimit = currentLinkCapacity * 16;
 
-    // --- ZERO-GC OBJECT POOLS ---
     const nodePool = [];
-
     for (let i = 0; i < currentNodesCapacity; i++) nodePool[i] = new ReactiveNode();
-
     let freeNodeHead = nodePool[0];
-
     for (let i = 0; i < currentNodesCapacity - 1; i++) nodePool[i].nextFree = nodePool[i + 1];
 
     const linkPool = [];
-
     for (let i = 0; i < currentLinkCapacity; i++) linkPool[i] = new ReactiveLink();
-
     let freeLinkHead = linkPool[0];
-
     for (let i = 0; i < currentLinkCapacity - 1; i++) linkPool[i].nextFree = linkPool[i + 1];
 
-    let activeNodes = 0 | 0;
-    let activeLinks = 0 | 0;
-    let statSignals = 0 | 0;
-    let statComputeds = 0 | 0;
-    let statEffects = 0 | 0;
+    let activeNodes = 0;
+    let activeLinks = 0;
+    let statSignals = 0;
+    let statComputeds = 0;
+    let statEffects = 0;
 
-    // --- QUEUES & STACKS (Monomorphic arrays) ---
     const effectQueueA = [];
     const effectQueueB = [];
     const markStack = [];
-
-    for (let i = 0; i < currentNodesCapacity; i++) {
-        effectQueueA[i] = null;
-        effectQueueB[i] = null;
-        markStack[i] = null;
-    }
-
     let activeQueue = effectQueueA;
-    let activeQueueLen = 0 | 0;
+    let activeQueueLen = 0;
     let isQueueA = true;
 
-    // --- GLOBAL STATE ---
-    let globalVersion = 1 | 0; // Forced 32-bit SMI
-    let batchEpoch = 1 | 0;     // skip-zero sentinel; revertEpoch=0 means "no capture"
-    let currentObserver = null;
+    let globalVersion = 1;
+    let batchEpoch = 1;
+    let currentObserver = null;           // tracking context: whose reads link deps
+    let currentOwner = null;              // lifecycle context: who owns nodes created now
     let activeObserverCurrentDep = null;
-    let batchDepth = 0 | 0;
+    let batchDepth = 0;
     let isTrackingDeps = false;
-    let isFlushing = false;
 
-    // ── Observer-lifecycle introspection (opt-in; zero steady-state cost) ──
-    // lifecycleCount gates the hot-path checks in allocateLink/freeLink: with no node
-    // registered it stays 0 and each check folds to one predicted-false compare.
-    // Callbacks live in a WeakMap, NOT on the node struct, so node creation/footprint
-    // are untouched.
+    // ── Node identity + observer-lifecycle introspection (ported from 1.1.5) ──
+    let nodeSeq = 1 | 0;
     let lifecycleCount = 0 | 0;
     const lifecycleMap = new WeakMap();
-
     function fireConnect(node) {
         const e = lifecycleMap.get(node);
-
         if (e === undefined || e.onConnect === undefined) return;
-
         const po = currentObserver, pt = isTrackingDeps;
-        currentObserver = null;
-        isTrackingDeps = false;
-
-        try {
-            e.onConnect();
-        } finally {
-            currentObserver = po;
-            isTrackingDeps = pt;
-        }
+        currentObserver = null; isTrackingDeps = false;
+        try { e.onConnect(); } finally { currentObserver = po; isTrackingDeps = pt; }
     }
-
     function fireDisconnect(node) {
         const e = lifecycleMap.get(node);
-
         if (e === undefined || e.onDisconnect === undefined) return;
-
         const po = currentObserver, pt = isTrackingDeps;
-        currentObserver = null;
-        isTrackingDeps = false;
-
-        try {
-            e.onDisconnect();
-        } finally {
-            currentObserver = po;
-            isTrackingDeps = pt;
-        }
+        currentObserver = null; isTrackingDeps = false;
+        try { e.onDisconnect(); } finally { currentObserver = po; isTrackingDeps = pt; }
     }
+    let isFlushing = false;
 
-    // Reused buffer for throw isolation during flush
     const flushErrorBuffer = [];
-    let flushErrorCount = 0 | 0;
+    let flushErrorCount = 0;
 
-    // --- ALLOCATORS ---
+    // ═══ L1 · GRAPH TOPOLOGY ══════════════════════════════════════
+    // Owns the ReactiveLink pool and the dep/sub lists. Pure edge mechanics:
+    // INVARIANT — must never touch node.owner / firstOwned.
+
+    // ─── HYBRID ALLOCATOR ─────────────────────────────────────────
 
     /**
      * Establish (or reuse) a dependency link from `source` → `target`.
      *
      * Fast path: cursor match (re-tracking same dep at same position) — O(1), no allocation.
-     * Slow path: linear search of target.headDep for an existing link — O(N) in N deps.
+     * Mid path: O(1) tailSub dedup (1.1.4 rewrite) — divergent retracking stays O(N) overall,
+     *           not O(N²).
      * Cold path: pool exhausted → grow or throw per policy.
      *
+     * SEVER-FIRST: on a cursor-miss divergence the unmatched dep tail is freed
+     * BEFORE any new link is allocated, so peak link usage never exceeds steady
+     * state (zero pool debt) and a divergent re-track cannot trigger mid-compute
+     * pool growth under tight maxLinks + "throw".
+     *
+     * EDGE NOTE: a node that reads the SAME source twice within one body, with a
+     * nested computed that also reads that source evaluated in between, retains
+     * one redundant link per intervening observer for the node's lifetime. Value-
+     * correct, bounded (does not grow across re-tracks), and reclaimed on dispose.
+     *
      * @private
      */
     function allocateLink(source, target) {
-        // Eligibility gate (lite's analogue of alien-signals' shouldTrack): if the observer was
-        // disposed mid-run — self-dispose, or an outer observer torn down while suspended — its
-        // flags are cleared to 0. Linking would splice a dead, pool-bound node back into `source`'s
-        // subscriber list: a phantom edge that mis-targets the instant the slot is recycled. Skip it.
-        // Cold path only (the inline cursor-hit fast path never reaches here) -> steady-state reads
-        // pay nothing. Legit tracking always passes a live observer (flags != 0).
+        // Eligibility gate (restored from 1.1.5): an observer disposed mid-run (self-dispose, or
+        // an outer observer torn down while suspended) has flags cleared to 0. Linking would splice
+        // a dead, pool-bound node back into source's subscriber list — a phantom edge. Cold path only.
         if (target.flags === 0) return null;
         let expected = activeObserverCurrentDep;
-        // Dead on this build: the inline cursor fast-path inside every read
-        // consumes a cursor *hit* before allocateLink runs, so on entry the
-        // cursor never matches `source`. Kept for the direct-call contract.
-        /* c8 ignore start */
-        if (expected !== null && expected.source === source) {
-            activeObserverCurrentDep = expected.nextDep;
-            return expected;
-        }
-        /* c8 ignore stop */
 
-        // SEVER-FIRST (zero pool debt): on any divergence, free the entire
-        // unmatched tail BEFORE allocating, so peak link usage never exceeds
-        // steady-state. Trades a little extra free/alloc churn on small reorders
-        // for honoring the zero-GC budget under tight maxLinks + "throw".
         if (expected !== null) {
             let stale = expected;
             let prev = stale.prevDep;
-
             if (prev !== null) prev.nextDep = null; else target.headDep = null;
-
             target.tailDep = prev;
 
             while (stale !== null) {
@@ -316,74 +290,60 @@ export function createRegistry(config = {}) {
                 freeLink(stale, target, stale.source);
                 stale = next;
             }
-
             activeObserverCurrentDep = null;
         }
 
-        // O(1) same-pass dedup (covers double-read of a still-linked source).
+        // O(1) same-pass dedup (ported from 1.1.3): replaces the O(N) prefix scan
+        // that made divergent re-tracking O(N^2). If this source was already
+        // linked to this target during THIS pass, its sub-list tail points at us.
         const lastSub = source.tailSub;
-
-        if (lastSub !== null && lastSub.target === target) return lastSub;
+        if (lastSub !== null && lastSub.target === target) return;
 
         let link;
-        {
-            if (freeLinkHead === null) {
-                if (policy === "throw") throw new CapacityError("links", currentLinkCapacity);
-
-                const newCap = currentLinkCapacity * 2;
-
-                if (newCap > maxLinkLimit) throw new CapacityError("links", maxLinkLimit);
-
-                const newLinks = new Array(newCap - currentLinkCapacity);
-
-                for (let i = 0; i < newLinks.length; i++) newLinks[i] = new ReactiveLink();
-                for (let i = 0; i < newLinks.length - 1; i++) newLinks[i].nextFree = newLinks[i + 1];
-
-                const startIdx = linkPool.length;
-                linkPool.length = newCap;
-
-                for (let i = 0; i < newLinks.length; i++) linkPool[startIdx + i] = newLinks[i];
-
-                freeLinkHead = newLinks[0];
-                currentLinkCapacity = newCap;
-            }
-
-            link = freeLinkHead;
-            freeLinkHead = link.nextFree;
-            link.nextFree = null;
-            activeLinks = (activeLinks + 1) | 0;
-
-            link.source = source;
-            link.target = target;
-
-            link.nextSub = null;
-            link.prevSub = source.tailSub;
-            const _was0 = lifecycleCount !== 0 && source.headSub === null;   // 0→1 detect (pre-link)
+        if (freeLinkHead === null) {
+            if (policy === "throw") throw new CapacityError("links", currentLinkCapacity);
+            const newCap = currentLinkCapacity * 2;
+            if (newCap > maxLinkLimit) throw new CapacityError("links", maxLinkLimit);
+
+            const newLinks = new Array(newCap - currentLinkCapacity);
+            for (let i = 0; i < newLinks.length; i++) newLinks[i] = new ReactiveLink();
+            for (let i = 0; i < newLinks.length - 1; i++) newLinks[i].nextFree = newLinks[i + 1];
+
+            const startIdx = linkPool.length;
+            linkPool.length = newCap;
+            for (let i = 0; i < newLinks.length; i++) linkPool[startIdx + i] = newLinks[i];
+            freeLinkHead = newLinks[0];
+            currentLinkCapacity = newCap;
+        }
 
-            if (source.tailSub !== null) source.tailSub.nextSub = link; else source.headSub = link;
+        link = freeLinkHead;
+        freeLinkHead = link.nextFree;
+        link.nextFree = null;
+        activeLinks = (activeLinks + 1) | 0;
 
-            source.tailSub = link;
+        link.source = source;
+        link.target = target;
 
-            if (_was0) fireConnect(source);
-        }
+        link.nextSub = null;
+        link.prevSub = source.tailSub;
+        const _was0 = lifecycleCount !== 0 && source.headSub === null;   // 0→1 detect (pre-link)
+        if (source.tailSub !== null) source.tailSub.nextSub = link;
+        else source.headSub = link;
+        source.tailSub = link;
+        if (_was0) fireConnect(source);
 
-        // Append at the (post-sever) tail.
         let tail = target.tailDep;
         link.prevDep = tail;
         link.nextDep = null;
-
-        if (tail !== null) tail.nextDep = link; else target.headDep = link;
-
+        if (tail !== null) tail.nextDep = link;
+        else target.headDep = link;
         target.tailDep = link;
-
-        return link;
     }
 
     /** Return a link to the free pool and unlink it from the source's sub list. @private */
     function freeLink(link, target, source) {
         const pSub = link.prevSub;
         const nSub = link.nextSub;
-
         if (pSub !== null) pSub.nextSub = nSub; else source.headSub = nSub;
         if (nSub !== null) nSub.prevSub = pSub; else source.tailSub = pSub;
         if (lifecycleCount !== 0 && source.headSub === null) fireDisconnect(source);   // 1→0
@@ -400,26 +360,88 @@ export function createRegistry(config = {}) {
         activeLinks = (activeLinks - 1) | 0;
     }
 
-    // --- MANUAL MEMORY MANAGEMENT ---
+    /**
+     * Free any tail links not visited during the current re-tracking pass.
+     * Called from executeEffect / pullComputed after the body returns: anything
+     * still reachable from `activeObserverCurrentDep` is a stale dep from the
+     * previous run and gets returned to the pool.
+     * @private
+     */
+    function severTail(node) {
+        let stale = activeObserverCurrentDep;
+        if (stale !== null) {
+            let prev = stale.prevDep;
+            if (prev !== null) prev.nextDep = null; else node.headDep = null;
+            node.tailDep = prev;
+
+            while (stale !== null) {
+                let next = stale.nextDep;
+                freeLink(stale, node, stale.source);
+                stale = next;
+            }
+        }
+    }
+
+    // ═══ L2 · OWNERSHIP / LIFECYCLE ═══════════════════════════════
+    // Owns the owner tree, node death, and user cleanup.
+    // INVARIANT — must never touch the activeObserverCurrentDep cursor.
+    // Sanctioned downward edge → L1: disposeNode calls freeLink to extract a
+    // dying node from the graph.
+
+    // ─── LIFECYCLE & OWNERSHIP ───────────────────────────────────────
 
     function disposeNode(node) {
-        /* c8 ignore next -- redundant: both callers (effect handle, dispose(api)) pre-check flags!==0; destroy() resets slots inline */
-        if (node.flags === 0) return; // Already freed
+        if (node.flags === 0) return;
+
+        // RACE WITH ACTIVE TRACKING: an effect/computed may call dispose on
+        // itself from inside its own body (#141). Once we tear the node down
+        // its dep-list, FLAG_COMPUTING, and cursor become stale immediately —
+        // any read() that runs in the REST of the body would otherwise try to
+        // hang a fresh link off a freed slot. Null the tracking state now so
+        // subsequent reads in this call stack become no-ops, and let
+        // executeEffect / pullComputed skip their finally-block bookkeeping
+        // via the gen-snapshot guard there.
+        if (currentObserver === node) {
+            currentObserver = null;
+            activeObserverCurrentDep = null;
+            isTrackingDeps = false;
+        }
+        if (currentOwner === node) {
+            currentOwner = null;
+        }
+
+        // Live per-kind count: decrement here -- the single chokepoint every teardown
+        // path funnels through (owner cascade at the firstOwned loop, the effect
+        // disposer, and dispose(api)). Keyed off flags BEFORE they are cleared lower
+        // in this function; the guard above makes it double-dispose-safe. This is what
+        // keeps stats() honest: signals + computeds + effects === activeNodes holds
+        // under owner-cascade disposal, not just explicit dispose.
+        const f = node.flags;
+        if ((f & FLAG_SIGNAL) !== 0) statSignals--;
+        else if ((f & FLAG_COMPUTED) !== 0) statComputeds--;
+        else if ((f & FLAG_EFFECT) !== 0) statEffects--;
+
+        // O(1) detach from parent to avoid modifying list during parent iteration
+        if (node.owner !== null) {
+            if (node.prevOwned !== null) node.prevOwned.nextOwned = node.nextOwned;
+            else node.owner.firstOwned = node.nextOwned;
+            if (node.nextOwned !== null) node.nextOwned.prevOwned = node.prevOwned;
+            node.owner = null;
+            node.prevOwned = null;
+            node.nextOwned = null;
+        }
 
         runCleanup(node);
 
-        // 1. Unlink from dependencies
+        // CROSS-EDGE L2→L1: extract this node's own edges from the graph.
         let dLink = node.headDep;
-
         while (dLink !== null) {
             const next = dLink.nextDep;
             freeLink(dLink, node, dLink.source);
             dLink = next;
         }
 
-        // 2. Unlink from subscribers
         let sLink = node.headSub;
-
         while (sLink !== null) {
             const target = sLink.target;
             const next = sLink.nextSub;
@@ -442,20 +464,17 @@ export function createRegistry(config = {}) {
             sLink = next;
         }
 
-        // 3. Clear node state and return to pool
         node.computeFn = undefined;
         node.cleanupFn = undefined;
         node.scheduler = undefined;
-        node.schedulerThunk = undefined;
+        node.schedulerThunk = undefined;  // drop closure; recycle rebuilds it
         node.value = undefined;
         node.equals = undefined;
         node.flags = 0;
         node.headDep = null;
         node.tailDep = null;
-        node.currentDep = null;
         node.headSub = null;
         node.tailSub = null;
-
         node.revertEpoch = 0;
         node.preBatchValue = undefined;
         node.preBatchVersion = 0;
@@ -468,30 +487,28 @@ export function createRegistry(config = {}) {
 
     /**
      * Claim a node from the free pool, reinitialise, and return it.
-     * Grows pool per `policy` if exhausted.
+     * Grows pool per `policy` if exhausted (or throws CapacityError under "throw").
+     * Adopts the new node into `currentOwner` if there is one AND the new node is
+     * an observer (computed/effect) — plain signals are not adopted (see ReactiveNode
+     * comment on the owner tree).
      * @private
      */
     function createNode(value, flags) {
         if (freeNodeHead === null) {
             if (policy === "throw") throw new CapacityError("nodes", currentNodesCapacity);
             const newCap = currentNodesCapacity * 2;
-
             const newNodes = new Array(newCap - currentNodesCapacity);
             for (let i = 0; i < newNodes.length; i++) newNodes[i] = new ReactiveNode();
             for (let i = 0; i < newNodes.length - 1; i++) newNodes[i].nextFree = newNodes[i + 1];
 
             const startIdx = nodePool.length;
-            nodePool.length = newCap; // Pre-allocate the new length
-            for (let i = 0; i < newNodes.length; i++) {
-                nodePool[startIdx + i] = newNodes[i];
-            }
-
+            nodePool.length = newCap;
+            for (let i = 0; i < newNodes.length; i++) nodePool[startIdx + i] = newNodes[i];
             freeNodeHead = newNodes[0];
 
             effectQueueA.length = newCap;
             effectQueueB.length = newCap;
             markStack.length = newCap;
-
             currentNodesCapacity = newCap;
         }
 
@@ -504,7 +521,6 @@ export function createRegistry(config = {}) {
         node.flags = flags | 0;
         node.headDep = null;
         node.tailDep = null;
-        node.currentDep = null;
         node.headSub = null;
         node.tailSub = null;
         node.version = 0;
@@ -513,34 +529,96 @@ export function createRegistry(config = {}) {
         node.revertEpoch = 0;
         node.preBatchValue = undefined;
         node.preBatchVersion = 0;
+        node.id = nodeSeq; nodeSeq = (nodeSeq + 1) | 0;   // fresh identity per allocation (ported from 1.1.5)
+
+        // Wire into Owner Context (lifecycle, not tracking — keyed off currentOwner).
+        // ONLY observers (computed/effect) are adopted: a re-running owner disposes
+        // its nested observers (which would otherwise leak dep links), but plain
+        // signals have no deps to leak, and disposing them breaks lazy-allocation
+        // libraries (lite-store allocates a key's signal on first read, INSIDE the
+        // reading computed — adopting it meant that computed's next run wiped the
+        // store key). Signals are therefore never owner-adopted.
+        // firstOwned is reset unconditionally (reuse-safety: a recycled former-owner
+        // must not carry stale children into runCleanup). prevOwned/nextOwned are
+        // written only on the adoption path -- an unadopted node is in no owner's
+        // firstOwned chain, so its prevOwned/nextOwned are never traversed and may
+        // stay stale. Saves two writes per signal and per top-level computed/effect.
+        node.firstOwned = null;
+        if (currentOwner !== null && (flags & (FLAG_COMPUTED | FLAG_EFFECT)) !== 0) {
+            node.owner = currentOwner;
+            node.prevOwned = null;
+            node.nextOwned = currentOwner.firstOwned;
+            if (currentOwner.firstOwned !== null) {
+                currentOwner.firstOwned.prevOwned = node;
+            }
+            currentOwner.firstOwned = node;
+        } else {
+            node.owner = null;
+        }
+
         return node;
     }
 
-    /** Invoke registered cleanup function(s) on `node` and clear. @private */
+    /**
+     * Cascade-dispose owned children inside-out (deepest first), then invoke this
+     * node's own cleanup if any. Cascade order is the v1.2 conformance fix for
+     * #238 / #241 / #243 — nested cleanups must fire grandchild → child → outer
+     * so that a parent's cleanup still sees its own state intact.
+     * @private
+     */
     function runCleanup(node) {
-        const cleanup = node.cleanupFn;
-
-        if (cleanup === undefined) return;
-
-        const prevObserver = currentObserver;
-        const prevTracking = isTrackingDeps;
-        currentObserver = null;
-        isTrackingDeps = false;
+        // Cascade children FIRST — deepest cleanups fire before shallowest.
+        // This matches the universal invariant in the upstream conformance suite
+        // (#238 / #241 / #243): nested cleanups run inside-out on owner-tree
+        // disposal, mirroring the parent-knows-best assumption shared with
+        // React / Solid (children may rely on parent state being live at their
+        // cleanup time, but never the reverse).
+        let child = node.firstOwned;
+        while (child !== null) {
+            let next = child.nextOwned;
+            // Detach immediately to optimise disposeNode processing
+            child.owner = null;
+            child.prevOwned = null;
+            child.nextOwned = null;
+            disposeNode(child);
+            child = next;
+        }
+        node.firstOwned = null;
 
-        try {
-            if (typeof cleanup === "function") cleanup();
-            else for (let i = 0; i < cleanup.length; i++) cleanup[i]();
-        } finally {
-            node.cleanupFn = undefined;
-            currentObserver = prevObserver;
-            isTrackingDeps = prevTracking;
+        // Then this node's own cleanup.
+        const cleanup = node.cleanupFn;
+        if (cleanup !== undefined) {
+            const prevObserver = currentObserver;
+            const prevOwner = currentOwner;
+            const prevTracking = isTrackingDeps;
+            currentObserver = null;
+            currentOwner = null;
+            isTrackingDeps = false;
+            try {
+                if (typeof cleanup === "function") cleanup();
+                else for (let i = 0; i < cleanup.length; i++) cleanup[i]();
+            } finally {
+                node.cleanupFn = undefined;
+                currentObserver = prevObserver;
+                currentOwner = prevOwner;
+                isTrackingDeps = prevTracking;
+            }
         }
     }
 
+    // ═══ L3 · PROPAGATION / EXECUTION ═════════════════════════════
+    // markDownstream is owner-free AND cursor-free (a pure propagation
+    // primitive). executeEffect/pullComputed are the orchestrators: they drive
+    // the cursor + severTail (L1) and, before a re-run, call runCleanup (L2) to
+    // cascade-dispose owned children. Sanctioned upward call → L2: runCleanup.
+
+    // ─── EXECUTION ENGINE ─────────────────────────────────────────
+
     /**
      * Mark all transitive subscribers of `startNode` dirty.
      * Iterative DFS via the markStack to avoid call-stack growth.
-     * Effects are enqueued for the flush phase; computeds are merely marked.
+     * Effects are enqueued for the flush phase; computeds are merely marked
+     * (their re-evaluation is lazy — triggered by the next read).
      * @private
      */
     function markDownstream(startNode) {
@@ -549,25 +627,15 @@ export function createRegistry(config = {}) {
 
         while (stackLen !== 0) {
             const n = markStack[--stackLen];
-
             let link = n.headSub;
+
             while (link !== null) {
                 const t = link.target;
-
-                if ((t.markEpoch | 0) !== (globalVersion | 0)) {
-                    t.markEpoch = globalVersion | 0;
-                    // flags read stays INSIDE the markEpoch guard on purpose: hoisting it
-                    // above the guard would load t.flags for every already-marked revisit
-                    // too, adding work on exactly the dedup-skip path that markEpoch exists
-                    // to make cheap (diamond / shared-computed fan-out).
-                    const flags = t.flags | 0;
+                if (t.markEpoch !== globalVersion) {
+                    t.markEpoch = globalVersion;
+                    const flags = t.flags;
 
                     if ((flags & FLAG_EFFECT) !== 0) {
-                        // "No re-run" semantics for self-cycles: an effect that is currently
-                        // executing on the call stack must not be re-queued by its own body's
-                        // writes (directly or through computed chains). The effect's evalVersion
-                        // is bumped to the post-write globalVersion in its executeEffect finally,
-                        // so subsequent unrelated writes still propagate normally.
                         if ((flags & (FLAG_QUEUED | FLAG_COMPUTING)) === 0) {
                             t.flags = flags | FLAG_QUEUED;
                             activeQueue[activeQueueLen++] = t;
@@ -576,218 +644,166 @@ export function createRegistry(config = {}) {
                         markStack[stackLen++] = t;
                     }
                 }
-
                 link = link.nextSub;
             }
         }
     }
 
     /**
-     * Execute an effect through a scheduler trampoline. Guards against running
-     * a stale node (disposed and recycled before the scheduler fired).
-     * @private
-     */
-    function safeExecute(node, gen) {
-        if ((node.gen | 0) !== (gen | 0)) return;
-        /* c8 ignore next -- unreachable after the gen guard: every disposal bumps node.gen, so a non-effect slot fails the gen check above first */
-        if ((node.flags & FLAG_EFFECT) === 0) return;
-
-        executeEffect(node);
-    }
-
-    /**
-     * Drain the effect queue. Double-buffered so new effects scheduled mid-flush
-     * end up in the next pass. Individual effect throws are caught, buffered, and
-     * re-thrown at the end of the flush (or wrapped in AggregateError if multiple).
+     * Drain the effect queue. Double-buffered (effectQueueA / effectQueueB) so
+     * effects scheduled mid-flush land in the next pass. Individual effect throws
+     * are caught and buffered; at end-of-flush a single throw is rethrown directly,
+     * multiple throws are aggregated into an `AggregateError` (1.2.0). Exceeds
+     * `maxFlushPasses` (default 100) → Error prefixed `"CycleError:"`.
      * @private
      */
     function flushEffects() {
         if (isFlushing) return;
         isFlushing = true;
-        let passes = 0 | 0;
+        let passes = 0;
         let normalExit = false;
 
         try {
             while (activeQueueLen > 0) {
-                passes = (passes + 1) | 0;
-                if (passes > maxFlushPasses) {
-                    throw new Error("CycleError: flush passes exceeded");
-                }
-
+                if (++passes > maxFlushPasses) throw new Error("CycleError: flush passes exceeded");
                 const toRun = activeQueueLen | 0;
                 const currentQueue = activeQueue;
 
                 isQueueA = !isQueueA;
                 activeQueue = isQueueA ? effectQueueA : effectQueueB;
-                activeQueueLen = 0 | 0;
+                activeQueueLen = 0;
 
                 for (let i = 0; i < toRun; i++) {
                     const node = currentQueue[i];
-
                     try {
                         const scheduler = node.scheduler;
-
                         if (scheduler) {
-                            scheduler(node.schedulerThunk);
+                            scheduler(node.schedulerThunk);  // reuse cached thunk
                         } else {
-                            executeEffect(node);
+                            if ((node.flags & FLAG_EFFECT) !== 0) executeEffect(node);
                         }
                     } catch (err) {
-                        // Buffer and continue. Effect's own try/finally inside
-                        // executeEffect already restored observer state and
-                        // severed tail deps before the throw landed here.
-                        flushErrorBuffer[flushErrorCount] = err;
-                        flushErrorCount = (flushErrorCount + 1) | 0;
+                        flushErrorBuffer[flushErrorCount++] = err;
                     }
                 }
             }
             normalExit = true;
         } finally {
             isFlushing = false;
-
             if (!normalExit) {
-                // Escaping via CycleError or any non-effect-body throw. Discard
-                // buffered effect errors — the structural failure supersedes them
-                // and prevents leaking stale errors to the next flush call.
                 for (let i = 0; i < flushErrorCount; i++) flushErrorBuffer[i] = null;
-
-                flushErrorCount = 0 | 0;
+                flushErrorCount = 0;
             }
         }
 
         if (flushErrorCount > 0) {
             if (flushErrorCount === 1) {
                 const err = flushErrorBuffer[0];
-                flushErrorBuffer[0] = null; // drop reference, retain backing store
-                flushErrorCount = 0 | 0;
+                flushErrorBuffer[0] = null;
+                flushErrorCount = 0;
                 throw err;
             }
-            // 2+ errors: snapshot into a fresh array for AggregateError, then clear.
             const errs = flushErrorBuffer.slice(0, flushErrorCount);
-
             for (let i = 0; i < flushErrorCount; i++) flushErrorBuffer[i] = null;
-
-            flushErrorCount = 0 | 0;
-
+            flushErrorCount = 0;
             throw new AggregateError(errs, "Effects threw during flush");
         }
     }
 
-    /**
-     * Free any tail links not visited during the current re-tracking pass.
-     * Called after computeFn returns: anything still hanging off the cursor is stale.
-     * @private
-     */
-    function severTail(node) {
-        let stale = activeObserverCurrentDep;
-
-        if (stale !== null) {
-            let prev = stale.prevDep;
-
-            if (prev !== null) prev.nextDep = null; else node.headDep = null;
-
-            node.tailDep = prev;
-
-            while (stale !== null) {
-                let next = stale.nextDep;
-                freeLink(stale, node, stale.source);
-                stale = next;
-            }
-        }
-    }
-
     /**
      * Run an effect's compute body, re-tracking dependencies.
      * Short-circuits if no dependency has bumped its version since last eval.
+     * If the body self-disposes (node.gen advances during the body), skips the
+     * post-body bookkeeping (severTail, flag clear, evalVersion bump) — that
+     * gen-snapshot guard is the v1.2 conformance fix for #141.
      * @private
      */
     function executeEffect(node) {
-        /* c8 ignore next -- defense-in-depth: writes during a flush re-queue for the next pass, so an effect cannot synchronously re-enter executeEffect */
         if ((node.flags & FLAG_COMPUTING) !== 0) throw new Error("CycleError: Infinite effect loop detected.");
 
-        const isFirst = node.evalVersion === 0;
-
-        if (!isFirst) {
+        if (node.evalVersion !== 0) {
             let link = node.headDep;
             const evalVer = node.evalVersion | 0;
             let needsRun = false;
 
             while (link !== null) {
                 const dep = link.source;
-
                 if ((dep.flags & FLAG_COMPUTED) !== 0) pullComputed(dep);
-
-                // Overflow-safe modular arithmetic version check
                 if (((dep.version - evalVer) | 0) > 0) {
                     needsRun = true;
                     break;
                 }
                 link = link.nextDep;
             }
+
             if (!needsRun) {
-                node.flags = node.flags & ~FLAG_QUEUED;
-                node.evalVersion = globalVersion | 0;
+                node.flags &= ~FLAG_QUEUED;
+                node.evalVersion = globalVersion;
                 return;
             }
         }
 
         node.flags = (node.flags & ~FLAG_QUEUED) | FLAG_COMPUTING;
-
-        runCleanup(node);
-
-        // Cleanup may have disposed us (e.g. via a synchronous dispose() call from
-        // within the user's cleanup body). disposeNode clears flags to 0 and nulls
-        // computeFn; bailing here prevents a TypeError on computeFn() below and
-        // avoids reinitialising observer state on a freed slot.
+        runCleanup(node);   // CROSS-EDGE L3→L2: dispose owned children before re-run
         if ((node.flags & FLAG_EFFECT) === 0) return;
 
         const prevObserver = currentObserver;
+        const prevOwner = currentOwner;
         const prevActiveDep = activeObserverCurrentDep;
         const prevTracking = isTrackingDeps;
 
         currentObserver = node;
+        currentOwner = node;
         activeObserverCurrentDep = node.headDep;
         isTrackingDeps = true;
 
+        // SELF-DISPOSE DETECTION: snapshot the gen. disposeNode bumps gen,
+        // so if it advanced during the body the node was disposed (and may
+        // already have been recycled into a different role). Skip the
+        // dep-list / flag / version mutations in that case — they would
+        // either crash on the freed link list or corrupt the new resident.
+        const savedGen = node.gen;
         try {
             node.computeFn();
         } finally {
-            severTail(node);
-            node.currentDep = activeObserverCurrentDep;
-
+            if (node.gen === savedGen) {
+                severTail(node);
+                node.flags &= ~FLAG_COMPUTING;
+                node.evalVersion = globalVersion;
+            }
             currentObserver = prevObserver;
+            currentOwner = prevOwner;
             activeObserverCurrentDep = prevActiveDep;
             isTrackingDeps = prevTracking;
-
-            node.flags = node.flags & ~FLAG_COMPUTING;
-            node.evalVersion = globalVersion | 0;
         }
     }
 
     /**
-     * Resolve a computed node's current value: re-run if a dependency has
-     * changed since last evaluation, else return cached value.
+     * Resolve a computed node's current value: re-run if a dependency has changed
+     * since last evaluation, else return cached value. The clean-read short-circuit
+     * via markEpoch (1.1.4) returns the cached value in O(1) when no mark landed
+     * in this node's transitive cone since the last eval, instead of walking the
+     * whole dependency subtree.
      *
      * Errors thrown by computeFn are captured in `node.value` with FLAG_HAS_ERROR;
      * subsequent reads re-throw until a dependency change re-runs computeFn.
      *
+     * Same gen-snapshot self-dispose guard as executeEffect — see #141 fix.
+     *
      * @private
      */
     function pullComputed(node) {
-        if ((node.evalVersion | 0) === (globalVersion | 0)) {
+        if (node.evalVersion === globalVersion) {
             if ((node.flags & FLAG_HAS_ERROR) !== 0) throw node.value;
             return node.value;
         }
 
-        // CLEAN SHORT-CIRCUIT: markDownstream stamps markEpoch=globalVersion on
-        // every node in a changed signal's transitive cone. If no mark landed
-        // at-or-after our last eval, nothing we depend on changed -> cached value
-        // is still valid; skip the (recursive) dependency walk entirely. O(1).
+        // CLEAN SHORT-CIRCUIT (ported from 1.1.3): markDownstream already stamps
+        // markEpoch on the changed signal's whole cone; if no mark landed since
+        // our last eval, the cached value is valid -> skip the dep walk. O(1).
         if (node.evalVersion !== 0 && ((node.markEpoch - node.evalVersion) | 0) <= 0) {
             node.evalVersion = globalVersion | 0;
-
             if ((node.flags & FLAG_HAS_ERROR) !== 0) throw node.value;
-
             return node.value;
         }
 
@@ -795,71 +811,103 @@ export function createRegistry(config = {}) {
         if (!shouldRun) {
             let link = node.headDep;
             const evalVer = node.evalVersion | 0;
-
             while (link !== null) {
                 const dep = link.source;
-
                 if ((dep.flags & FLAG_COMPUTED) !== 0) pullComputed(dep);
-                // Modular Arithmetic 32-bit Wrap Check
                 if (((dep.version - evalVer) | 0) > 0) {
                     shouldRun = true;
                     break;
                 }
-
                 link = link.nextDep;
             }
         }
 
         if (shouldRun) {
             if ((node.flags & FLAG_COMPUTING) !== 0) throw new Error("CycleError: Circular dependency detected.");
-
-            node.flags = node.flags | FLAG_COMPUTING;
-
-            // Run cleanups registered during the previous compute pass before re-tracking.
-            // Mirrors effect semantics so `onCleanup` works in both kinds of observer.
-            runCleanup(node);
+            node.flags |= FLAG_COMPUTING;
+            runCleanup(node);   // CROSS-EDGE L3→L2: dispose owned children before recompute
 
             const prevObserver = currentObserver;
+            const prevOwner = currentOwner;
             const prevActiveDep = activeObserverCurrentDep;
             const prevTracking = isTrackingDeps;
 
             currentObserver = node;
+            currentOwner = node;
             activeObserverCurrentDep = node.headDep;
             isTrackingDeps = true;
 
+            // Same self-dispose detection as executeEffect — see comment there.
+            const savedGen = node.gen;
             try {
                 const newValue = node.computeFn();
                 const eq = node.equals;
-
                 if (node.evalVersion === 0 || !eq || !eq(node.value, newValue)) {
                     node.value = newValue;
-                    node.version = globalVersion | 0;
+                    node.version = globalVersion;
                 }
-                node.flags = node.flags & ~FLAG_HAS_ERROR;
+                node.flags &= ~FLAG_HAS_ERROR;
             } catch (err) {
-                node.value = err;
-                node.flags = node.flags | FLAG_HAS_ERROR;
-                node.version = globalVersion | 0;
+                if (node.gen === savedGen) {
+                    node.value = err;
+                    node.flags |= FLAG_HAS_ERROR;
+                    node.version = globalVersion;
+                } else {
+                    // The body disposed `node` and then threw. The error has
+                    // nowhere to land — the caller of the read that triggered
+                    // this pull has already had its tracking state torn down.
+                    // Swallow rather than corrupt a recycled slot. The
+                    // canonical thrown-computed test (#168 / cached error)
+                    // does NOT self-dispose, so this branch isn't reachable
+                    // from the conformance set.
+                }
             } finally {
-                severTail(node);
-                node.currentDep = activeObserverCurrentDep;
-
+                if (node.gen === savedGen) {
+                    severTail(node);
+                    node.flags &= ~FLAG_COMPUTING;
+                }
                 currentObserver = prevObserver;
+                currentOwner = prevOwner;
                 activeObserverCurrentDep = prevActiveDep;
                 isTrackingDeps = prevTracking;
-
-                node.flags = node.flags & ~FLAG_COMPUTING;
             }
         }
 
-        node.evalVersion = globalVersion | 0;
-
+        if (node.flags === 0) return undefined;   // disposed during body
+        node.evalVersion = globalVersion;
         if ((node.flags & FLAG_HAS_ERROR) !== 0) throw node.value;
-
         return node.value;
     }
 
-    // --- PUBLIC API SURFACE ---
+    // ─── PUBLIC API ──────────────────────────────────────────────────
+
+    // ─── shared accessor methods (one set per registry, not per primitive) ───────
+    // update/subscribe are method-invoked (s.update(fn), s.subscribe(fn)), so `this`
+    // is the read function and this[NODE_PTR] is the node. set() and peek() stay
+    // closures: set() is the hot write path (a closure over `node` beats the
+    // this[NODE_PTR] load and keeps `const {set} = signal()` working), and peek()'s
+    // body is too cheap to absorb the node recovery.
+    function sharedUpdate(fn) { return this.set(fn(this[NODE_PTR].value)); }
+    function sharedSubscribe(fn) {
+        const read = this;
+        return effect(() => {
+            const val = read();
+            const prevTracking = isTrackingDeps;
+            isTrackingDeps = false;
+            try {
+                fn(val);
+            } finally {
+                isTrackingDeps = prevTracking;
+            }
+        });
+    }
+    // Shared peeks (one per registry, not per primitive). Save one closure
+    // allocation per signal/computed creation versus the previous per-instance
+    // arrows. Method-invoked, so `this` is the read function and this[NODE_PTR]
+    // is the node. Signal: direct value read. Computed: pull (still respects
+    // the cached/short-circuit fast paths since pullComputed handles them).
+    function sharedSignalPeek() { return this[NODE_PTR].value; }
+    function sharedComputedPeek() { return pullComputed(this[NODE_PTR]); }
 
     /**
      * Create a reactive signal.
@@ -873,21 +921,13 @@ export function createRegistry(config = {}) {
      */
     function signal(initial, opts) {
         const node = createNode(initial, FLAG_SIGNAL);
-        // Read opts defensively instead of defaulting to `= {}`: the default allocates
-        // a throwaway object on every no-opts call (the common path) — pure nursery
-        // garbage when mounting many signals.
         node.equals = (opts !== undefined && opts.equals !== undefined) ? opts.equals : Object.is;
-        node.version = globalVersion | 0;
-        statSignals = (statSignals + 1) | 0;
+        node.version = globalVersion;
+        statSignals++;
 
         const read = () => {
             if (isTrackingDeps && currentObserver !== null) {
-                // Inlined cursor fast-path: on stable read order this matches every
-                // time, so we skip a call into the (large, non-inlinable) allocateLink
-                // frame entirely. Only a cursor miss falls through to the cold path,
-                // where allocateLink re-reads the cursor for its relink logic.
-                const expected = activeObserverCurrentDep;
-
+                let expected = activeObserverCurrentDep;
                 if (expected !== null && expected.source === node) {
                     activeObserverCurrentDep = expected.nextDep;
                 } else {
@@ -897,62 +937,33 @@ export function createRegistry(config = {}) {
             return node.value;
         };
 
-        read.peek = () => node.value;
+        read.peek = sharedSignalPeek;
+        // set stays a CLOSURE (byte-identical to 1.2.0): its call path is the hot
+        // path, and a closure over `node` beats a shared method's this[NODE_PTR]
+        // load. Keeping it a closure also restores detached `const {set}=signal()`.
         read.set = (value) => {
             const eq = node.equals;
-
             if (eq && eq(node.value, value)) return;
-
-            // Revert capture: first .set() of this signal inside the current batch.
-            // Guarded by batchDepth so out-of-batch writes pay zero added cost.
             if (batchDepth > 0 && node.revertEpoch !== batchEpoch) {
                 node.preBatchValue = node.value;
-                node.preBatchVersion = node.version | 0;
-                node.revertEpoch = batchEpoch | 0;
+                node.preBatchVersion = node.version;
+                node.revertEpoch = batchEpoch;
             }
-
             node.value = value;
-
-            // Revert detection: in-batch write whose value matches the pre-batch
-            // capture. Restore version (without bumping globalVersion) and skip
-            // propagation. Subscribers already queued by an earlier mid-batch set
-            // will dirty-check against this restored version at flush and bail.
             if (batchDepth > 0 && node.revertEpoch === batchEpoch && eq && eq(node.preBatchValue, value)) {
-                node.version = node.preBatchVersion | 0;
+                node.version = node.preBatchVersion;
                 return;
             }
-
             globalVersion = (globalVersion + 1) | 0;
-            node.version = globalVersion | 0;
+            node.version = globalVersion;
             markDownstream(node);
             if (batchDepth === 0) flushEffects();
         };
-        read.update = (fn) => read.set(fn(node.value));
-
-        read.subscribe = (fn) => {
-            // Single-closure subscription: the read is tracked (it establishes the
-            // dependency), then fn runs untracked. untrack() is inlined here to (a) drop
-            // the second per-subscription closure and (b) save an untrack()+wrapper call
-            // on every fire, not just at setup.
-            // COUPLING: this duplicates untrack()'s isTrackingDeps save/restore. If
-            // untrack ever manages additional state (e.g. currentObserver), mirror it here.
-            return effect(() => {
-                const val = read();
-                const prevTracking = isTrackingDeps;
-                isTrackingDeps = false;
-
-                try {
-                    fn(val);
-                } finally {
-                    isTrackingDeps = prevTracking;
-                }
-            });
-        };
+        read.update = sharedUpdate;        // shared: cold path, calls this.set (the closure above)
+        read.subscribe = sharedSubscribe;  // shared: cold path, recovers via `this`
 
-        // Secret pointer for safe, isolated disposal without allocating closures
         read[NODE_PTR] = node;
-        read[NODE_GEN] = node.gen | 0;
-
+        read[NODE_GEN] = node.gen;
         return read;
     }
 
@@ -971,15 +982,12 @@ export function createRegistry(config = {}) {
     function computed(fn, opts) {
         const node = createNode(undefined, FLAG_COMPUTED);
         node.computeFn = fn;
-        // Defensive opts read; avoids the `= {}` per-call allocation. See signal().
         node.equals = (opts !== undefined && opts.equals !== undefined) ? opts.equals : Object.is;
-        statComputeds = (statComputeds + 1) | 0;
+        statComputeds++;
 
         const read = () => {
             if (isTrackingDeps && currentObserver !== null) {
-                // Inlined cursor fast-path — see signal() read for rationale.
-                const expected = activeObserverCurrentDep;
-
+                let expected = activeObserverCurrentDep;
                 if (expected !== null && expected.source === node) {
                     activeObserverCurrentDep = expected.nextDep;
                 } else {
@@ -989,87 +997,69 @@ export function createRegistry(config = {}) {
             return pullComputed(node);
         };
 
-        read.peek = () => pullComputed(node);
-
-        read.subscribe = (fn) => {
-            // Single-closure subscription — see signal() subscribe for rationale and
-            // the untrack-inlining coupling note.
-            return effect(() => {
-                const val = read();
-                const prevTracking = isTrackingDeps;
-                isTrackingDeps = false;
-
-                try {
-                    fn(val);
-                } finally {
-                    isTrackingDeps = prevTracking;
-                }
-            });
-        };
+        read.peek = sharedComputedPeek;
+        read.subscribe = sharedSubscribe;
 
         read[NODE_PTR] = node;
-        read[NODE_GEN] = node.gen | 0;
-
+        read[NODE_GEN] = node.gen;
         return read;
     }
 
     /**
      * Create an eagerly-run side effect that re-executes whenever its tracked
-     * dependencies change.
+     * dependencies change. The body runs synchronously on creation.
+     *
+     * An effect that creates nested effects/computeds in its body owns them via
+     * the v1.2 owner tree: when this effect re-runs or is disposed, owned
+     * children are cascade-disposed before the new run.
      *
      * Errors thrown by the effect body propagate to the caller of `set()` (or
      * to the scheduler trampoline). The effect's dependency state is fully
-     * restored before the error propagates.
+     * restored before the error propagates. Multiple throws in the same flush
+     * pass aggregate into an `AggregateError` at the trigger.
      *
      * @param {() => void} fn        Effect body.
      * @param {object} [opts]
      * @param {(run:()=>void)=>void} [opts.scheduler]
      *        Optional trampoline (e.g. queueMicrotask, requestAnimationFrame).
      *        Receives a `run` callback that the scheduler must eventually invoke.
+     *        The thunk is cached per-node and gen-bound, so a stale schedule
+     *        fired post-dispose against a recycled slot is a guaranteed no-op.
      * @returns {() => void}         Dispose function. Idempotent. Safe to call
      *                               after registry.destroy().
      */
     function effect(fn, opts) {
         const node = createNode(undefined, FLAG_EFFECT);
         node.computeFn = fn;
-        // Defensive opts read; avoids the `= {}` per-call allocation. Read scheduler once
-        // and reuse the local for the trampoline check below.
-        const scheduler = opts !== undefined ? opts.scheduler : undefined;
-        node.scheduler = scheduler;
-        statEffects = (statEffects + 1) | 0;
+        node.scheduler = (opts !== undefined) ? opts.scheduler : undefined;
+        statEffects++;
 
         let firstRunError = null;
-
-        if (scheduler) {
+        if (node.scheduler) {
             const gen = node.gen | 0;
-            node.schedulerThunk = () => safeExecute(node, gen);
-            scheduler(node.schedulerThunk);
+            // Cache the gen-bound thunk so re-schedules reuse the same closure.
+            // The inline guard preserves ABA correctness across dispose+recycle
+            // (gen bumps on disposeNode → stale thunk no-ops).
+            node.schedulerThunk = () => {
+                if (node.gen === gen && (node.flags & FLAG_EFFECT) !== 0) executeEffect(node);
+            };
+            node.scheduler(node.schedulerThunk);
         } else {
             try {
                 executeEffect(node);
             } catch (err) {
-                // First-run failure: dispose the node so we don't leak a half-initialised
-                // effect in the registry. Propagate the error to the caller.
                 firstRunError = err;
             }
         }
 
         let disposed = false;
-        const birthGen = node.gen | 0;
-
+        const birthGen = node.gen;
         const disposeFn = function dispose() {
             if (disposed) return;
             disposed = true;
-            // Generation guard: if destroy() (or a future direct disposal)
-            // recycled this slot to a different node, the stale closure must
-            // NOT operate on it — without this check, the closure would call
-            // disposeNode() on whatever now lives in the slot and desync
-            // statEffects (it would decrement even though the node is no
-            // longer an effect). Mirrors the NODE_GEN stamp on signals/computeds.
-            if ((node.gen | 0) !== birthGen) return;
+            if (node.gen !== birthGen) return;
             if (node.flags !== 0) {
                 disposeNode(node);
-                statEffects = (statEffects - 1) | 0;
             }
         };
 
@@ -1077,47 +1067,32 @@ export function createRegistry(config = {}) {
             disposeFn();
             throw firstRunError;
         }
-
         return disposeFn;
     }
 
     function dispose(api) {
-        // Safe read: foreign APIs or effects return undefined for NODE_PTR.
         const node = api?.[NODE_PTR];
-
         if (!node) {
-            // Plain functions self-execute (effect dispose handles and the
-            // dispose returned by .subscribe()). BUT we must not invoke a
-            // FOREIGN signal/computed here — they are also functions, and
-            // calling one would (1) read the value if untracked, or worse,
-            // (2) cross-link the foreign node into our observer if called
-            // inside a tracking context. Duck-type on `.peek`: every reactive
-            // primitive carries it; plain dispose handles do not.
             if (typeof api === "function" && typeof api.peek !== "function") api();
             return;
         }
-
-        // Generation guard: if the slot has been recycled since this handle
-        // was issued, the handle is stale — silently no-op. Without this,
-        // a second dispose() call after the slot has been reallocated to a
-        // different signal/computed would free the new occupant.
-        const stamp = api[NODE_GEN] | 0;
-        if (stamp !== (node.gen | 0)) return;
-
+        if (api[NODE_GEN] !== node.gen) return;
         if (node.flags !== 0) {
-            const isSig = (node.flags & FLAG_SIGNAL) !== 0;
-            const isComp = (node.flags & FLAG_COMPUTED) !== 0;
-
             disposeNode(node);
-
-            if (isSig) statSignals = (statSignals - 1) | 0;
-            if (isComp) statComputeds = (statComputeds - 1) | 0;
         }
     }
 
     /**
      * Coalesce multiple synchronous writes into a single effect-flush pass.
-     * Nested batches are merged.
+     * Nested batches are merged — only the outermost close triggers the flush.
+     *
+     * Pre-batch revert (1.2.0): if a signal is set, then set back to its
+     * pre-batch value (under its `equals`) before the outer close, the version
+     * bump is reverted and downstream effects/computeds do not fire.
+     *
+     * NOT transactional: an exception inside the body does NOT roll back applied
+     * writes. Effects that have not yet fired for the pending writes do still
+     * run on batch close with the post-throw values.
      *
      * @template T
      * @param {() => T} fn
@@ -1126,12 +1101,9 @@ export function createRegistry(config = {}) {
     function batch(fn) {
         if (batchDepth === 0) {
             batchEpoch = (batchEpoch + 1) | 0;
-            /* c8 ignore next -- 2^32 wraparound sentinel; unreachable without ~4e9 batches */
-            if (batchEpoch === 0) batchEpoch = 1 | 0;   // preserve the 0 sentinel
+            if (batchEpoch === 0) batchEpoch = 1;
         }
-
         batchDepth = (batchDepth + 1) | 0;
-
         try {
             return fn();
         } finally {
@@ -1141,12 +1113,13 @@ export function createRegistry(config = {}) {
     }
 
     /**
-     * Run `fn` without recording any signal/computed reads as dependencies.
-     * Useful inside effects to peek at signals you don't want to react to.
-     *
-     * @template T
-     * @param {() => T} fn
-     * @returns {T}
+     * Returns true iff a read RIGHT NOW would record a dependency on this
+     * registry. Mirrors the engine's own read-trap predicate (both flags).
+     * False inside untrack(), subscribe callbacks, onCleanup bodies,
+     * watch/when callbacks, and outside any observer. For wrapper libraries
+     * (lite-store, lite-query, lite-form) that lazily allocate signals on
+     * property reads. Per-registry. ~1-2 ns.
+     * @returns {boolean}
      */
     /**
      * Returns true iff a read RIGHT NOW would record a dependency on this
@@ -1164,7 +1137,6 @@ export function createRegistry(config = {}) {
     function untrack(fn) {
         const prev = isTrackingDeps;
         isTrackingDeps = false;
-
         try {
             return fn();
         } finally {
@@ -1173,24 +1145,26 @@ export function createRegistry(config = {}) {
     }
 
     /**
-     * Register a function to run when the enclosing effect re-runs or is disposed.
+     * Register a function to run when the enclosing effect/computed re-runs or
+     * is disposed. Cascade order on disposal is inside-out: an effect's owned
+     * children's cleanups run BEFORE this one (#238 / #241 / #243).
      *
      * No-op if called outside an effect / computed body.
      *
      * @param {() => void} fn
      */
     function onCleanup(fn) {
-        if (currentObserver !== null) {
-            const existing = currentObserver.cleanupFn;
-
-            if (existing === undefined) currentObserver.cleanupFn = fn;
-            else if (typeof existing === "function") currentObserver.cleanupFn = [existing, fn];
+        if (currentOwner !== null) {
+            const existing = currentOwner.cleanupFn;
+            if (existing === undefined) currentOwner.cleanupFn = fn;
+            else if (typeof existing === "function") currentOwner.cleanupFn = [existing, fn];
             else existing.push(fn);
         }
     }
 
     /**
-     * Snapshot of registry counters. Useful for diagnostics and tests.
+     * Snapshot of registry counters. Useful for diagnostics and tests —
+     * e.g. asserting that `activeNodes` returns to a baseline after teardown.
      * @returns {RegistryStats}
      */
     function stats() {
@@ -1208,8 +1182,8 @@ export function createRegistry(config = {}) {
 
     /**
      * Reset the entire registry: clear every node, every link, every queue, the
-     * global clock. All previously-issued read/set/dispose closures become
-     * no-ops (they're guarded internally — they will not corrupt the pool).
+     * global clock. All previously-issued read/set/dispose closures become safe
+     * no-ops (every node's `gen` bump invalidates any outstanding handle).
      */
     function destroy() {
         for (let i = 0; i < currentNodesCapacity; i++) {
@@ -1219,11 +1193,9 @@ export function createRegistry(config = {}) {
             n.cleanupFn = undefined;
             n.equals = undefined;
             n.scheduler = undefined;
-            n.schedulerThunk = undefined;
             n.flags = 0;
             n.headDep = null;
             n.tailDep = null;
-            n.currentDep = null;
             n.headSub = null;
             n.tailSub = null;
             n.version = 0;
@@ -1232,17 +1204,23 @@ export function createRegistry(config = {}) {
             n.revertEpoch = 0;
             n.preBatchValue = undefined;
             n.preBatchVersion = 0;
-            // Bump gen so any scheduler trampolines holding a stale node ref bail.
+
+            n.owner = null;
+            n.prevOwned = null;
+            n.nextOwned = null;
+            n.firstOwned = null;
+
             n.gen = (n.gen + 1) | 0;
 
+            effectQueueA[i] = null;
+            effectQueueB[i] = null;
+            markStack[i] = null;
+
             if (i < currentNodesCapacity - 1) n.nextFree = nodePool[i + 1];
         }
-
         nodePool[currentNodesCapacity - 1].nextFree = null;
         freeNodeHead = nodePool[0];
 
-        // ... remainder of destroy() stays exactly the same
-
         for (let i = 0; i < currentLinkCapacity; i++) {
             const l = linkPool[i];
             l.source = null;
@@ -1253,35 +1231,33 @@ export function createRegistry(config = {}) {
             l.nextSub = null;
             if (i < currentLinkCapacity - 1) l.nextFree = linkPool[i + 1];
         }
-
         linkPool[currentLinkCapacity - 1].nextFree = null;
         freeLinkHead = linkPool[0];
 
-        activeNodes = 0 | 0;
-        activeLinks = 0 | 0;
-        activeQueueLen = 0 | 0;
+        activeNodes = 0;
+        activeLinks = 0;
+        activeQueueLen = 0;
         isFlushing = false;
-        batchDepth = 0 | 0;
+        batchDepth = 0;
         currentObserver = null;
+        currentOwner = null;
         activeObserverCurrentDep = null;
         isTrackingDeps = false;
-        globalVersion = 1 | 0;
-        batchEpoch = 1 | 0;
-        statSignals = 0 | 0;
-        statComputeds = 0 | 0;
-        statEffects = 0 | 0;
+        globalVersion = 1;
+        batchEpoch = 1;
+        statSignals = 0;
+        statComputeds = 0;
+        statEffects = 0;
 
         for (let i = 0; i < flushErrorCount; i++) flushErrorBuffer[i] = null;
-
-        flushErrorCount = 0 | 0;
-        flushErrorBuffer.length = 0; // release the backing array
+        flushErrorCount = 0;
+        flushErrorBuffer.length = 0;
     }
 
     function hasObservers(handle) {
         const node = handle != null ? handle[NODE_PTR] : undefined;
         return node !== undefined && node.headSub !== null;
     }
-
     function observeObservers(handle, opts) {
         const node = handle != null ? handle[NODE_PTR] : undefined;
         if (node === undefined) throw new TypeError("observeObservers: argument is not a reactive handle");
@@ -1302,51 +1278,35 @@ export function createRegistry(config = {}) {
             if (lifecycleMap.delete(node)) lifecycleCount = (lifecycleCount - 1) | 0;
         };
     }
-
     function describeNode(node) {
         const fl = node.flags;
         const kind = (fl & FLAG_EFFECT) !== 0 ? "effect" : (fl & FLAG_COMPUTED) !== 0 ? "computed" : "signal";
-        return {kind, value: node.value};
+        const d = {id: node.id, kind, value: node.value};
+        Object.defineProperty(d, NODE_PTR, {value: node, enumerable: false});
+        return d;
+    }
+    function nodeId(handle) {
+        const node = handle != null ? handle[NODE_PTR] : undefined;
+        return node !== undefined ? node.id : undefined;
+    }
+    function describe(handle) {
+        const node = handle != null ? handle[NODE_PTR] : undefined;
+        return node !== undefined ? describeNode(node) : undefined;
     }
-
     function forEachObserver(handle, fn) {
         const node = handle != null ? handle[NODE_PTR] : undefined;
         if (node === undefined) return;
         let l = node.headSub;
-        while (l !== null) {
-            const nx = l.nextSub;
-            fn(describeNode(l.target));
-            l = nx;
-        }
+        while (l !== null) { const nx = l.nextSub; fn(describeNode(l.target)); l = nx; }
     }
-
     function forEachSource(handle, fn) {
         const node = handle != null ? handle[NODE_PTR] : undefined;
         if (node === undefined) return;
         let l = node.headDep;
-        while (l !== null) {
-            const nx = l.nextDep;
-            fn(describeNode(l.source));
-            l = nx;
-        }
+        while (l !== null) { const nx = l.nextDep; fn(describeNode(l.source)); l = nx; }
     }
 
-    return {
-        signal,
-        computed,
-        effect,
-        dispose,
-        batch,
-        untrack,
-        onCleanup,
-        stats,
-        destroy,
-        isTracking,
-        hasObservers,
-        observeObservers,
-        forEachObserver,
-        forEachSource
-    };
+    return {signal, computed, effect, dispose, batch, untrack, onCleanup, stats, destroy, isTracking, hasObservers, observeObservers, forEachObserver, forEachSource, nodeId, describe};
 }
 
 // ─────────────────────────────────────────────────────────────────
@@ -1355,28 +1315,18 @@ export function createRegistry(config = {}) {
 
 let defaultRegistry = createRegistry();
 
-/**
- * Replace the registry backing the top-level {@link signal} / {@link computed} /
- * {@link effect} / {@link batch} / {@link untrack} / {@link onCleanup} / {@link stats}
- * exports.
- *
- * @param {Registry} registry
- */
 export function setDefaultRegistry(registry) {
     defaultRegistry = registry;
 }
 
-/** @type {Registry["signal"]} */
 export function signal(initial, opts) {
     return defaultRegistry.signal(initial, opts);
 }
 
-/** @type {Registry["computed"]} */
 export function computed(fn, opts) {
     return defaultRegistry.computed(fn, opts);
 }
 
-/** @type {Registry["effect"]} */
 export function effect(fn, opts) {
     return defaultRegistry.effect(fn, opts);
 }
@@ -1385,12 +1335,10 @@ export function dispose(api) {
     return defaultRegistry.dispose(api);
 }
 
-/** @type {Registry["batch"]} */
 export function batch(fn) {
     return defaultRegistry.batch(fn);
 }
 
-/** @type {Registry["untrack"]} */
 export function untrack(fn) {
     return defaultRegistry.untrack(fn);
 }
@@ -1403,41 +1351,35 @@ export function isTracking() {
     return defaultRegistry.isTracking();
 }
 
+export function onCleanup(fn) {
+    return defaultRegistry.onCleanup(fn);
+}
+
+export function stats() {
+    return defaultRegistry.stats();
+}
+
+export function destroy() {
+    return defaultRegistry.destroy();
+}
+
 export function hasObservers(handle) {
     return defaultRegistry.hasObservers(handle);
 }
-
 export function observeObservers(handle, opts) {
     return defaultRegistry.observeObservers(handle, opts);
 }
-
 export function forEachObserver(handle, fn) {
     return defaultRegistry.forEachObserver(handle, fn);
 }
-
 export function forEachSource(handle, fn) {
     return defaultRegistry.forEachSource(handle, fn);
 }
-
-/** @type {Registry["onCleanup"]} */
-export function onCleanup(fn) {
-    return defaultRegistry.onCleanup(fn);
-}
-
-/** @type {Registry["stats"]} */
-export function stats() {
-    return defaultRegistry.stats();
+export function nodeId(handle) {
+    return defaultRegistry.nodeId(handle);
 }
-
-/** * Wipe the default registry. strictly for test-suite isolation.
- * @private
- */
-export function destroy() {
-    return defaultRegistry.destroy();
+export function describe(handle) {
+    return defaultRegistry.describe(handle);
 }
 
-/**
- * Re-export of the user-land watch utility.
- * @see {@link watch} in Watch.js for full implementation details.
- */
-export {watch, when, whenAsync} from "./Watch.js"
+export {watch, when, whenAsync} from "./Watch.js";