@solidjs/signals 2.0.0-rc.1 → 2.0.0-rc.10

package/dist/prod/core/dev.js

@@ -1,3 +1,20 @@
+import "./core.js";
+
+/**
+ * Registers the console footer appended to the first console report of
+ * each diagnostic code — a discovery pointer to deeper guidance. Reported
+ * events carry it as trailing lines of the same console entry; events that
+ * surface as a thrown error instead get it as a follow-up line. Returning
+ * undefined for an event suppresses the footer. Passing undefined
+ * unregisters and resets the once-per-code memory.
+ *
+ * @internal A seam for `solid-js`, which owns the repair skill the footer
+ * names and installs it from both of its entries; not part of `DEV`. No-op
+ * outside dev builds, where nothing reports to the console.
+ */ function setConsoleFooter(o) {
+    return;
+}
+
 const DEV = undefined;
 
-export { DEV };
+export { DEV, setConsoleFooter };

package/dist/prod/core/effect.js

@@ -1,29 +1,36 @@
-import { REACTIVE_DISPOSED, STATUS_ERROR, EFFECT_USER, CONFIG_AUTO_DISPOSE, CONFIG_CHILDREN_FORBIDDEN, EFFECT_TRACKED, STATUS_PENDING, EFFECT_RENDER } from "./constants.js";
+import { REACTIVE_DISPOSED, LANE_RUN, STATUS_ERROR, EFFECT_USER, NOT_PENDING, CONFIG_AUTO_DISPOSE, CONFIG_CHILDREN_FORBIDDEN, EFFECT_TRACKED, EFFECT_RENDER, STATUS_PENDING } from "./constants.js";
 
-import { createEffectNode, recompute, computed, staleValues } from "./core.js";
+import { setEffectStatusNotify, ext, createEffectNode, recompute, computed, staleValues } from "./core.js";
 
 import { unwrapStatusError, StatusError } from "./error.js";
 
-import { GlobalQueue, haltReactivity } from "./scheduler.js";
+import { trimStaleDeps } from "./graph.js";
+
+import { enqueueSub } from "./heap.js";
+
+import { GlobalQueue, currentTransition, activeTransition, haltReactivity, schedule } from "./scheduler.js";
 
 /**
  * Effects are the leaf nodes of our reactive graph. When their sources change, they are
  * automatically added to the queue of effects to re-execute, which will cause them to fetch their
  * sources and recompute
- */ function effect(t, E, e, R) {
-    const r = !!R?.user;
-    const f = createEffectNode(t, E, e, r ? EFFECT_USER : EFFECT_RENDER, notifyEffectStatus, R);
-    recompute(f, true);
-    !R?.defer && (f.Re === EFFECT_USER || R?.schedule ? f.C.enqueue(f.Re, runEffect.bind(null, f)) : runEffect(f));
+ */ function effect(t, e, E, r) {
+    const n = !!r?.user;
+    const i = createEffectNode(t, e, E, n ? EFFECT_USER : EFFECT_RENDER, r);
+    recompute(i, true);
+    // A first pass that derived from a live transaction's staged world was
+    // staged into that transaction (recompute: born held); the transaction's
+    // commit replays this effect. Its first run is not this creation's (A29).
+        !r?.defer && i._e === NOT_PENDING && (i.je === EFFECT_USER || r?.schedule ? i.T.enqueue(i.je, runEffect.bind(null, i)) : runEffect(i, LANE_RUN));
 }
 
-function notifyEffectStatus(t, E) {
+function notifyEffectStatus(t, e) {
     // Use passed values if provided, otherwise read from node
-    const e = t !== undefined ? t : this.S;
-    const R = E !== undefined ? E : this._;
-    if (e & STATUS_ERROR) {
-        this.C.notify(this, STATUS_PENDING, 0);
-        if (this.Re === EFFECT_USER) {
+    const E = t !== undefined ? t : this.h;
+    const r = e !== undefined ? e : this.o?._;
+    if (E & STATUS_ERROR) {
+        this.T.notify(this, STATUS_PENDING, 0);
+        if (this.je === EFFECT_USER) {
             // The error handler is the error arm of the effect phase (#2840 ruling):
             // queue it like the effect function. It runs in the same imperative,
             // writable scope, throws escalate the same way, and a held transition
@@ -33,23 +40,43 @@ function notifyEffectStatus(t, E) {
             // phase takes the success arm instead. Blocked forwards (explicit
             // `status` arg without node-state writes) don't queue: the status
             // re-propagates unblocked at commit.
-            if (this.S & STATUS_ERROR) {
-                this.Je = true;
-                this.C.enqueue(this.Re, this.Xe ??= runEffect.bind(null, this));
+            if (this.h & STATUS_ERROR) {
+                this.Xe = true;
+                this.T.enqueue(this.je, this.An ??= runEffect.bind(null, this));
             }
             return;
         }
-        if (!this.C.notify(this, STATUS_ERROR, STATUS_ERROR)) {
-            haltReactivity(unwrapStatusError(R));
-            throw R;
+        if (!this.T.notify(this, STATUS_ERROR, STATUS_ERROR)) {
+            haltReactivity(unwrapStatusError(r));
+            throw r;
         }
-    } else if (this.Re === EFFECT_RENDER) {
-        this.C.notify(this, STATUS_PENDING | STATUS_ERROR, e, R);
+    } else if (this.je === EFFECT_RENDER) {
+        this.T.notify(this, STATUS_PENDING | STATUS_ERROR, E, r);
     }
 }
 
-function runEffect(t) {
-    if (!t.Je || t.se & REACTIVE_DISPOSED) return;
+function runEffect(t, e) {
+    if (!t.Xe || t.oe & REACTIVE_DISPOSED) return;
+    // Ownership (#3319): a value computed under a transaction is applied by that
+    // transaction's commit. The ordinary effect phase runs with a transaction
+    // active only when the flush's finalize ENTERED one (every other path parks
+    // or settles first): leave a run owned by a still-held transaction queued —
+    // `_modified` stays set — and the next gate stashes it with the owner.
+    // Mainline-owned runs (null) apply now. Lanes are exempt by design (they
+    // apply their own effects ahead of their transaction — the optimistic view)
+    // and mark their runs with LANE_RUN.
+    
+    // Lane exemption has one exception (#3331): a lane runner for an effect that
+    // no longer rides a lane — its optimistic source was superseded, so the lane
+    // has no optimistic view left to apply, and the value this effect now
+    // carries (or will, once its plain recompute lands) belongs to the still-held
+    // transaction. Hand the run to the regular queue, where the transaction's
+    // gate stashes it with the owner. Lane-less runners with no live owner
+    // (reverts, wake-only lanes) apply now.
+        if (t.pn !== null && !currentTransition(t.pn).Rn && (e & LANE_RUN ? !t.o?.me : activeTransition !== null)) {
+        t.T.enqueue(t.je, t.An);
+        return;
+    }
     // Error arm (#2840), user effects only: a compute-phase error that is still
     // the node's settled state at effect time runs the bundle's error handler in
     // this same imperative, writable scope. Unwrap the StatusError used for
@@ -60,86 +87,99 @@ function runEffect(t) {
     // Render effects bypass: their errors route to boundaries synchronously in
     // notifyEffectStatus, and a runner queued by an earlier valueChanged in the
     // same flush must not be hijacked by a later-arriving error status.
-        if (t.S & STATUS_ERROR && t.Re === EFFECT_USER) {
-        const E = unwrapStatusError(t._);
-        t._t = t.be;
-        t.Je = false;
+        if (t.h & STATUS_ERROR && t.je === EFFECT_USER) {
+        const e = unwrapStatusError(t.o?._);
+        t.xn = t.ce;
+        t.Xe = false;
         try {
-            t.Et ? t.Et(E, () => {
-                const E = t.Nt;
-                t.Nt = undefined;
-                E?.();
-            }) : console.error(E);
-        } catch (E) {
-            if (!t.C.notify(t, STATUS_ERROR, STATUS_ERROR)) {
-                haltReactivity(E);
-                throw E;
+            t.Mn ? t.Mn(e, () => {
+                const e = t.wn;
+                t.wn = undefined;
+                e?.();
+            }) : console.error(e);
+        } catch (e) {
+            if (!t.T.notify(t, STATUS_ERROR, STATUS_ERROR)) {
+                haltReactivity(e);
+                throw e;
             }
         }
         return;
     }
-    const E = t.Nt;
-    t.Nt = undefined;
+    // Captured before the callback: its own throw errors the node below, but
+    // the compute pass that produced `_value` was clean, so its tail still goes.
+        const E = t.o?._ == null;
+    const r = t.wn;
+    t.wn = undefined;
     try {
-        E?.();
-        const e = t.ft(t.be, t._t);
+        r?.();
+        const e = t.Qn(t.ce, t.xn);
         if (false && e !== undefined && typeof e !== "function") ;
         // The final cleanup is invoked by disposeChildren at true disposal.
-                t.Nt = e;
-    } catch (E) {
-        t._ = new StatusError(t, E);
-        t.S |= STATUS_ERROR;
-        if (!t.C.notify(t, STATUS_ERROR, STATUS_ERROR)) {
-            haltReactivity(E);
-            throw E;
+                t.wn = e;
+    } catch (e) {
+        ext(t)._ = new StatusError(t, e);
+        t.h |= STATUS_ERROR;
+        if (!t.T.notify(t, STATUS_ERROR, STATUS_ERROR)) {
+            haltReactivity(e);
+            throw e;
         }
     } finally {
-        t._t = t.be;
-        t.Je = false;
+        t.xn = t.ce;
+        t.Xe = false;
+        // The run applied: this is the frame now, so the dependency tail the
+        // compute pass left linked goes (A30, #3438 — `recompute` defers an
+        // effect's trim while a run is owed; the twin of `commitPendingNode`'s
+        // trim for a staged pass). An errored compute kept its full list with
+        // `_depsTail` marking where it stopped; leave it, as the commit does.
+                if (E) trimStaleDeps(t);
     }
 }
 
-GlobalQueue.et = runEffect;
+GlobalQueue.Cn = runEffect;
 
 /**
  * Internal tracked effect - bypasses heap, goes directly to effect queue.
  * Runs as a leaf owner: child primitives and onCleanup are forbidden (false throws).
  * Uses stale reads.
- */ function trackedEffect(t, E) {
+ */ function trackedEffect(t, e) {
     const run = () => {
-        if (!e.Je || e.se & REACTIVE_DISPOSED) return;
+        // `_modified` is NOT redundant with the heap: the heap dedups within a
+        // pass, but a held transition's passes each enqueue `_run` into the same
+        // user queue, and this gate is what collapses them into one run at commit.
+        if (!E.Xe || E.oe & REACTIVE_DISPOSED) return;
         try {
-            e.Je = false;
-            recompute(e);
+            E.Xe = false;
+            recompute(E);
         } finally {}
     };
-    const e = computed(() => {
-        const E = e.Nt;
-        e.Nt = undefined;
-        E?.();
-        const R = staleValues(t);
-        e.Nt = R;
+    const E = computed(() => {
+        const e = E.wn;
+        E.wn = undefined;
+        e?.();
+        const r = staleValues(t);
+        E.wn = r;
     }, {
-        ...E,
+        ...e,
         lazy: true
     });
-    e.Nt = undefined;
-    e.T = e.T & ~CONFIG_AUTO_DISPOSE | CONFIG_CHILDREN_FORBIDDEN;
-    e.Je = true;
-    e.Re = EFFECT_TRACKED;
-    e.i = (t, E) => {
-        const R = t !== undefined ? t : e.S;
-        if (R & STATUS_ERROR) {
-            e.C.notify(e, STATUS_PENDING, 0);
-            const t = E !== undefined ? E : e._;
-            if (!e.C.notify(e, STATUS_ERROR, STATUS_ERROR)) {
-                haltReactivity(unwrapStatusError(t));
-                throw t;
-            }
-        }
-    };
-    e.ht = run;
-    e.C.enqueue(EFFECT_USER, run);
+    E.wn = undefined;
+    E.C = E.C & ~CONFIG_AUTO_DISPOSE | CONFIG_CHILDREN_FORBIDDEN;
+    E.Xe = true;
+    E.je = EFFECT_TRACKED;
+    // Status dispatch rides the SHARED notifier (statusNotifierOf keys off
+    // _type): its error arm is behavior-identical to the closure that used to
+    // live here, without the per-node NodeExtension allocation.
+        E.$e = run;
+    // The first run rides the heap like every wake (GlobalQueue._update), so a
+    // tracked effect created inside a render-effect callback runs after that
+    // pass's staged writes commit, not before.
+        enqueueSub(E);
+    schedule();
 }
 
+// Install the shared effect status notifier (statusNotifierOf serves it to
+// every effect node) — module-scope: any bundle that creates effects
+// evaluates this module.
+setEffectStatusNotify(notifyEffectStatus);
+
 export { effect, trackedEffect };

package/dist/prod/core/error-hooks.js

@@ -0,0 +1,71 @@
+import { ROOT_ERROR_HOOK } from "./scheduler.js";
+
+let ambientHook;
+
+const reported = new WeakSet;
+
+/**
+ * Registers the ambient client error hook — the one call a browser `init()`
+ * makes to see every failure a boundary renders a fallback for, in
+ * production. (Uncaught errors reach `reportError` / `window.onerror`.)
+ *
+ * ```ts
+ * configureClientErrors({
+ *   onError: (error, { ownerPath }) =>
+ *     Sentry.captureException(error, {
+ *       mechanism: { type: "solid.error_boundary", handled: true }
+ *     })
+ * });
+ * ```
+ */ function configureClientErrors(e) {
+    if (e && e.onError !== undefined && typeof e.onError !== "function") {
+        throw new TypeError(`Invalid onError: expected a function, received ${typeof e.onError}.`);
+    }
+    ambientHook = e ? e.onError : undefined;
+}
+
+/** The nearest root's hook above `owner` (parked under `ROOT_ERROR_HOOK`), else the ambient one. */ function hookFor(e) {
+    for (let n = e; n; n = n._parent) {
+        const e = n[ROOT_ERROR_HOOK];
+        if (e !== undefined) return e;
+    }
+    return ambientHook;
+}
+
+/** Component labels up the owner chain, root first — `_name` where the runtime keeps it. */ function labels(e) {
+    const n = [];
+    for (let o = e; o; o = o._parent) {
+        const e = o._name;
+        if (typeof e === "string" && e.length) n.push(e);
+    }
+    return n.length ? n.reverse() : undefined;
+}
+
+/**
+ * Tells the client error hook about `error`, caught by the boundary whose
+ * owner is `owner`, thrown by `thrower` (the computation the engine's status
+ * wrapper named; unknown for a value that never crossed one) — once per
+ * error object. A throwing hook is reported on the console and otherwise
+ * ignored — a monitor must never take the app down.
+ * @internal
+ */ function reportClientError(e, n, o) {
+    const r = e !== null && (typeof e === "object" || typeof e === "function");
+    if (r) {
+        if (reported.has(e)) return;
+        reported.add(e);
+    }
+    const t = hookFor(n);
+    if (t === undefined) return;
+    const i = {};
+    const f = labels(n);
+    const c = labels(o) ?? f;
+    if (c !== undefined) i.ownerPath = c;
+    if (f !== undefined) i.boundaryPath = f;
+    try {
+        t(e, i);
+    } catch (e) {
+        console.error(e);
+    }
+}
+
+export { configureClientErrors, reportClientError };

package/dist/prod/core/error.js

@@ -53,6 +53,18 @@ class StatusError extends Error {
     return r instanceof StatusError ? r.cause : r;
 }
 
+/**
+ * Rejection value of `until(fn, { timeout })` when the predicate does not turn
+ * truthy within the window. Inside an `action()`, the rejection is thrown back
+ * in at the `yield` point — catchable there, or the action fails and its
+ * optimistic state reverts.
+ */ class TimeoutError extends Error {
+    constructor(r = "Timed out waiting for condition") {
+        super(r);
+        this.name = "TimeoutError";
+    }
+}
+
 class NoOwnerError extends Error {
     constructor() {
         super("");
@@ -65,4 +77,4 @@ class ContextNotFoundError extends Error {
     }
 }
 
-export { ContextNotFoundError, NoOwnerError, NotReadyError, StatusError, unwrapStatusError };
+export { ContextNotFoundError, NoOwnerError, NotReadyError, StatusError, TimeoutError, unwrapStatusError };

package/dist/prod/core/external.js

@@ -46,11 +46,11 @@ function wireExternalSource(e) {
         equals: false,
         ownedWrite: true
     });
-    const r = externalSourceConfig.factory(e.ce, () => {
+    const r = externalSourceConfig.factory(e.he, () => {
         setSignal(n, undefined);
     });
     cleanup(() => r.dispose());
-    e.ce = e => {
+    e.he = e => {
         read(n);
         return r.track(e);
     };
@@ -64,8 +64,8 @@ function externalUntrack(e) {
 // removed on reset) so core's null checks stay equivalent to the old
 // `externalSourceConfig` truthiness checks.
 function syncExternalHooks() {
-    GlobalQueue.dt = externalSourceConfig ? wireExternalSource : null;
-    GlobalQueue.St = externalSourceConfig ? externalUntrack : null;
+    GlobalQueue.Zn = externalSourceConfig ? wireExternalSource : null;
+    GlobalQueue.jn = externalSourceConfig ? externalUntrack : null;
 }
 
 function enableExternalSource(e) {

package/dist/prod/core/graph.js

@@ -1,78 +1,127 @@
-import { CONFIG_AUTO_DISPOSE, REACTIVE_ZOMBIE, STATUS_PENDING, REACTIVE_RECOMPUTING_DEPS } from "./constants.js";
+import { CONFIG_AUTO_DISPOSE, STATUS_PENDING, REACTIVE_DISPOSED, REACTIVE_ZOMBIE, CONFIG_SLOT_NODE, REACTIVE_RECOMPUTING_DEPS } from "./constants.js";
+
+import { slotUnobservedHook } from "./core.js";
 
 import { deleteFromHeap, queueFor } from "./heap.js";
 
 import { disposeChildren } from "./owner.js";
 
-import "./scheduler.js";
+import { bumpNotifyEpoch } from "./scheduler.js";
 
 // https://github.com/stackblitz/alien-signals/blob/v2.0.3/src/system.ts#L100
-function unlinkSubs(l) {
-    const n = l.it;
-    const e = l.nt;
-    const u = l.ue;
-    const s = l.ll;
-    if (u !== null) u.ll = s; else n.rt = s;
-    if (s !== null) s.ue = u; else {
-        n.o = u;
-        if (u === null) {
-            n.ut?.();
+function unlinkSubs(e) {
+    const n = e.Oe;
+    const l = e.Ne;
+    const o = e.Ae;
+    const s = e.el;
+    if (o !== null) o.el = s; else n.mn = s;
+    if (s !== null) s.Ae = o; else {
+        n.u = o;
+        if (o === null) {
+            // Slot nodes (store leaves) dispatch to the ONE shared hook — no
+            // per-node unobserved closure, no NodeExtension to hold it.
+            if (n.C & CONFIG_SLOT_NODE) slotUnobservedHook(n); else n.o?.Hn?.();
             // No more subscribers; only tear down if CONFIG_AUTO_DISPOSE is set.
             // A pending node is exempt: its in-flight async work (or the
             // transition holding it) is an observer — tearing down would orphan
             // the work and re-execute it on the next read. The settle path runs
             // this same last-one-out check when that observer releases (the
-            // untracked-read dispose in core.ts guards on pending identically).
-                        const l = n;
-            l.ce && l.T & CONFIG_AUTO_DISPOSE && !(l.se & REACTIVE_ZOMBIE) && !(l.S & STATUS_PENDING) && unobserved(l);
+            // untracked-read dormancy sweep guards on pending identically).
+                        const e = n;
+            e.he && e.C & CONFIG_AUTO_DISPOSE && !(e.oe & REACTIVE_ZOMBIE) && !(e.h & STATUS_PENDING) && unobserved(e);
         }
     }
-    return e;
+    return l;
 }
 
-function trimStaleDeps(l) {
-    const n = l.Ye;
-    let e = n !== null ? n.nt : l.tt;
-    if (e !== null) {
+function trimStaleDeps(e) {
+    const n = e.Nn;
+    let l = n !== null ? n.Ne : e.Ie;
+    if (l !== null) {
         do {
-            e = unlinkSubs(e);
-        } while (e !== null);
-        if (n !== null) n.nt = null; else l.tt = null;
+            l = unlinkSubs(l);
+        } while (l !== null);
+        if (n !== null) n.Ne = null; else e.Ie = null;
     }
 }
 
-function unobserved(l) {
-    deleteFromHeap(l, queueFor(l));
-    let n = l.tt;
-    while (n !== null) {
+// Shared by unobserved() and the disposeChildren child loop. The truthy guard
+// (not `!== null`) matters: plain Owners in a child chain have no _deps field,
+// and skipping early also avoids adding one (hidden-class churn) via the
+// null-out below.
+function clearDeps(e) {
+    let n = e.Ie;
+    if (!n) return;
+    do {
         n = unlinkSubs(n);
+    } while (n !== null);
+    e.Ie = null;
+    e.Nn = null;
+}
+
+function unobserved(e) {
+    deleteFromHeap(e, queueFor(e));
+    clearDeps(e);
+    disposeChildren(e, true);
+}
+
+/**
+ * Deferred dormancy for never-observed auto-dispose computeds (#3078).
+ *
+ * An untracked top-level read of a subscriber-less observation-lifecycle memo
+ * used to call unobserved() inline at the end of read(). That kept the leak
+ * closed (the compute links the memo into its deps' sub lists — without a
+ * teardown point a never-observed memo is retained by its sources forever;
+ * upstream alien-signals has exactly this retention), but it made reads
+ * destructive: each read disposed the node, the next read revived it with a
+ * full recompute in whatever ambient transition/lane context happened to be
+ * current, so consecutive reads could return different answers with no write
+ * in between.
+ *
+ * Instead, reads queue the node here and the scheduler sweeps at the top of
+ * the next flush (before runHeap, so a same-tick dirtying is reclaimed
+ * instead of recomputed). Reads become idempotent within a tick (the node
+ * stays alive and serves its cache, uniform with observed memos) while
+ * reclamation still happens within one microtask — the enqueue site arms
+ * schedule(), so a flush is guaranteed even when no other work is queued.
+ */ const dormantNodes = new Set;
+
+function sweepDormant() {
+    if (dormantNodes.size === 0) return;
+    for (const e of dormantNodes) {
+        // Re-validate at sweep time: the node may have gained a subscriber (its
+        // lifecycle is the unlinkSubs cascade now), gone pending (in-flight async
+        // is an observer; the settle path re-runs last-one-out), lost its
+        // AUTO_DISPOSE bit (owner teardown strips it, #3024), or already been
+        // torn down.
+        if (!e.u && e.C & CONFIG_AUTO_DISPOSE && !(e.h & STATUS_PENDING) && !(e.oe & (REACTIVE_DISPOSED | REACTIVE_ZOMBIE))) {
+            unobserved(e);
+        }
     }
-    l.tt = null;
-    l.Ye = null;
-    disposeChildren(l, true);
+    dormantNodes.clear();
 }
 
 // https://github.com/stackblitz/alien-signals/blob/v2.0.3/src/system.ts#L52
-function link(l, n, e = false) {
+function link(e, n, l = false) {
     // Repeat touches within one pass AND-combine `_pendingObserver`: a probe
     // read (`isPending(() => x())`) beside a value read of the same dep must
     // not relabel the value dependency as probe-only — the value read is what
     // real-error propagation and affects() coverage key off, regardless of
     // read order within the computation.
-    const u = n.Ye;
-    if (u !== null && u.it === l) {
-        u.ye &&= e;
+    const o = n.Nn;
+    if (o !== null && o.Oe === e) {
+        o.ze &&= l;
         return;
     }
     let s = null;
-    const t = n.se & REACTIVE_RECOMPUTING_DEPS;
+    const t = n.oe & REACTIVE_RECOMPUTING_DEPS;
     if (t) {
-        s = u !== null ? u.nt : n.tt;
-        if (s !== null && s.it === l) {
-            s.nl = n.Ze;
-            n.Ye = s;
+        s = o !== null ? o.Ne : n.Ie;
+        if (s !== null && s.Oe === e) {
+            s.Be = n.Ye;
+            n.Nn = s;
             // First touch of this pass: the previous pass's label is stale.
-                        s.ye = e;
+                        s.ze = l;
             return;
         }
     }
@@ -81,24 +130,26 @@ function link(l, n, e = false) {
     // [deps.._depsTail] prefix — the O(1) equivalent of scanning the dep list
     // (the old alien-signals `isValidLink` walk, O(n²) when a computation
     // re-reads earlier deps non-consecutively, e.g. store leaf reads).
-        const i = l.rt;
-    if (i !== null && i.fe === n && (!t || i.nl === n.Ze)) {
+        const r = e.mn;
+    if (r !== null && r.ge === n && (!t || r.Be === n.Ye)) {
         // Gen-matched during a recompute = repeat touch this pass (AND); outside
         // a recompute there is no pass boundary, so the latest read labels it.
-        if (t) i.ye &&= e; else i.ye = e;
+        if (t) r.ze &&= l; else r.ze = l;
         return;
     }
-    const o = n.Ye = l.rt = {
-        it: l,
-        fe: n,
-        nt: s,
-        ll: i,
-        ue: null,
-        nl: n.Ze,
-        ye: e
+    const u = n.Nn = e.mn = {
+        Oe: e,
+        ge: n,
+        Ne: s,
+        el: r,
+        Ae: null,
+        Be: n.Ye,
+        ze: l
     };
-    if (u !== null) u.nt = o; else n.tt = o;
-    if (i !== null) i.ue = o; else l.o = o;
+    if (o !== null) o.Ne = u; else n.Ie = u;
+    if (r !== null) r.Ae = u; else e.u = u;
+    // New subscriber edge: staged-rewrite skips (§12d) must not miss it.
+        bumpNotifyEpoch();
 }
 
-export { link, trimStaleDeps, unlinkSubs, unobserved };
+export { clearDeps, dormantNodes, link, sweepDormant, trimStaleDeps, unlinkSubs, unobserved };