@solidjs/signals 2.0.0-rc.15 → 2.0.0-rc.17

package/dist/prod/core/effect.js

@@ -8,30 +8,30 @@ import { trimStaleDeps } from "./graph.js";
 
 import { enqueueSub } from "./heap.js";
 
-import { globalQueue, schedule, GlobalQueue, haltReactivity } from "./scheduler.js";
+import { globalQueue, schedule, heldRunHook, haltReactivity, GlobalQueue } 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(e, t, u, E) {
-    const f = !!E?.user;
-    const r = createEffectNode(e, t, u, f ? EFFECT_USER : EFFECT_RENDER, E);
+ */ function effect(t, e, E, u) {
+    const f = !!u?.user;
+    const r = createEffectNode(t, e, E, f ? EFFECT_USER : EFFECT_RENDER, u);
     recompute(r, true);
     // A first pass that read a staged value was staged itself (recompute: born
     // staged); the flush's commit replays this effect. Its first run is not this
     // creation's (A29). A lane's node likewise: its run is the lane's, queued
     // by the pass and released at the reveal (lanes.ts).
-        !E?.defer && r.Oe === NOT_PENDING && !r.m?.He?.B && (r.u === EFFECT_USER || E?.schedule ? globalQueue.enqueue(r.u, runEffect.bind(null, r)) : runEffect(r, r.u));
+        !u?.defer && r.se === NOT_PENDING && !r.T?.Re?.v && (r.i === EFFECT_USER || u?.schedule ? globalQueue.enqueue(r.i, runEffect.bind(null, r)) : runEffect(r, r.i));
 }
 
-function notifyEffectStatus(e, t) {
+function notifyEffectStatus(t, e) {
     // Use passed values if provided, otherwise read from node
-    const u = e !== undefined ? e : this.S;
-    const E = t !== undefined ? t : this.m?.F;
-    if (u & STATUS_ERROR) {
+    const E = t !== undefined ? t : this.m;
+    const u = e !== undefined ? e : this.T?.F;
+    if (E & STATUS_ERROR) {
         globalQueue.notify(this, STATUS_PENDING, 0);
-        if (this.u === EFFECT_USER) {
+        if (this.i === 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 and throws escalate the same way. No payload is queued — the node already carries `_statusFlags`/`_error`,
@@ -39,23 +39,25 @@ function notifyEffectStatus(e, t) {
             // 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.Ge = true;
-                globalQueue.enqueue(this.u, this.Y ??= runEffect.bind(null, this));
+            if (this.m & STATUS_ERROR) {
+                this.Ae = true;
+                globalQueue.enqueue(this.i, this.W ??= runEffect.bind(null, this));
             }
             return;
         }
         if (!globalQueue.notify(this, STATUS_ERROR, STATUS_ERROR)) {
-            haltReactivity(unwrapStatusError(E));
-            throw E;
+            // Dev locates the halt at the node that threw: the StatusError's
+            // source, upstream of this effect when a computed failed.
+            haltReactivity(unwrapStatusError(u));
+            throw u;
         }
-    } else if (this.u === EFFECT_RENDER) {
-        globalQueue.notify(this, STATUS_PENDING | STATUS_ERROR, u, E);
+    } else if (this.i === EFFECT_RENDER) {
+        globalQueue.notify(this, STATUS_PENDING | STATUS_ERROR, E, u);
     }
 }
 
-function runEffect(e, t) {
-    if (!e.Ge || e.R & REACTIVE_DISPOSED) return;
+function runEffect(t, e) {
+    if (!t.Ae || t.R & REACTIVE_DISPOSED) return;
     // A queued run behind a fallback (boundaries.ts) waits for the reveal: a
     // user effect's, which would read a DOM that is not attached, and a render
     // effect's update too (maintainer, 2026-10-02: "we held the queue but let
@@ -64,7 +66,7 @@ function runEffect(e, t) {
     // hidden subtree. The synchronous first render on creation is not a queued
     // run and goes through. `_modified` stays set; the boundary re-queues the
     // run (`release`).
-        if (GlobalQueue.Ee && GlobalQueue.Ee(e)) return;
+        if (heldRunHook?.(t)) 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
@@ -75,94 +77,94 @@ function runEffect(e, 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 (e.S & STATUS_ERROR && e.u === EFFECT_USER) {
-        const t = unwrapStatusError(e.m?.F);
-        e.be = e.Ae;
-        e.Ge = false;
+        if (t.m & STATUS_ERROR && t.i === EFFECT_USER) {
+        const e = unwrapStatusError(t.T?.F);
+        t.ge = t.Ie;
+        t.Ae = false;
         try {
-            e.ut ? e.ut(t, () => {
-                const t = e.st;
-                e.st = undefined;
-                t?.();
-            }) : console.error(t);
-        } catch (t) {
-            if (!globalQueue.notify(e, STATUS_ERROR, STATUS_ERROR)) {
-                haltReactivity(t);
-                throw t;
+            t.qe ? t.qe(e, () => {
+                const e = t.Je;
+                t.Je = undefined;
+                e?.();
+            }) : console.error(e);
+        } catch (e) {
+            if (!globalQueue.notify(t, STATUS_ERROR, STATUS_ERROR)) {
+                haltReactivity(e);
+                throw e;
             }
         }
         return;
     }
     // 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 u = e.m?.F == null;
-    const E = e.st;
-    e.st = undefined;
+        const E = t.T?.F == null;
+    const u = t.Je;
+    t.Je = undefined;
     try {
-        E?.();
-        const t = e.Et(e.Ae, e.be);
-        if (false && t !== undefined && typeof t !== "function") ;
+        u?.();
+        const e = t.Ke(t.Ie, t.ge);
+        if (false && e !== undefined && typeof e !== "function") ;
         // The final cleanup is invoked by disposeChildren at true disposal.
-                e.st = t;
-    } catch (t) {
-        ext(e).F = new StatusError(e, t);
-        e.S |= STATUS_ERROR;
-        if (!globalQueue.notify(e, STATUS_ERROR, STATUS_ERROR)) {
-            haltReactivity(t);
-            throw t;
+                t.Je = e;
+    } catch (e) {
+        ext(t).F = new StatusError(t, e);
+        t.m |= STATUS_ERROR;
+        if (!globalQueue.notify(t, STATUS_ERROR, STATUS_ERROR)) {
+            haltReactivity(e);
+            throw e;
         }
     } finally {
-        e.be = e.Ae;
-        e.Ge = false;
+        t.ge = t.Ie;
+        t.Ae = 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 (u) trimStaleDeps(e);
+                if (E) trimStaleDeps(t);
     }
 }
 
-GlobalQueue.q = runEffect;
+GlobalQueue.K = 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(e, t) {
+ */ function trackedEffect(t, e) {
     const run = () => {
         // `_modified` is NOT redundant with the heap: the heap dedups within a
         // pass, but several passes in one flush each enqueue `_run` into the same
         // user queue, and this gate is what collapses them into one run.
-        if (!u.Ge || u.R & REACTIVE_DISPOSED) return;
-        if (GlobalQueue.Ee && GlobalQueue.Ee(u)) return;
+        if (!E.Ae || E.R & REACTIVE_DISPOSED) return;
+        if (heldRunHook?.(E)) return;
         try {
-            u.Ge = false;
-            recompute(u);
+            E.Ae = false;
+            recompute(E);
         } finally {}
     };
-    const u = computed(() => {
-        const t = u.st;
-        u.st = undefined;
-        t?.();
-        const E = staleValues(e);
-        u.st = E;
+    const E = computed(() => {
+        const e = E.Je;
+        E.Je = undefined;
+        e?.();
+        const u = staleValues(t);
+        E.Je = u;
     }, {
-        ...t,
+        ...e,
         lazy: true
     });
-    u.st = undefined;
-    u.i = u.i & ~CONFIG_AUTO_DISPOSE | CONFIG_CHILDREN_FORBIDDEN;
-    u.Ge = true;
-    u.u = EFFECT_TRACKED;
+    E.Je = undefined;
+    E.l = E.l & ~CONFIG_AUTO_DISPOSE | CONFIG_CHILDREN_FORBIDDEN;
+    E.Ae = true;
+    E.i = 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.
-        u.M = run;
+        E.M = 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(u);
+        enqueueSub(E);
     schedule();
 }
 

package/dist/prod/core/error.js

@@ -23,7 +23,6 @@
  * ```
  */
 class NotReadyError extends Error {
-    source;
     constructor(r) {
         // Control-flow throw: it happens on every read of a pending source, so in
         // production skip V8's eager stack capture (proportional to stack depth —
@@ -40,9 +39,12 @@ class NotReadyError extends Error {
 }
 
 class StatusError extends Error {
-    source;
     constructor(r, o) {
-        super(o instanceof Error ? o.message : String(o), {
+        // Best-effort message: formatting must never replace the original (#4112).
+        try {
+            var t = String(o instanceof Error ? o.message : o);
+        } catch {}
+        super(t, {
             cause: o
         });
         this.source = r;

package/dist/prod/core/external.js

@@ -2,7 +2,7 @@ import { signal, setSignal, read } from "./core.js";
 
 import { cleanup } from "./owner.js";
 
-import { GlobalQueue } from "./scheduler.js";
+import { setExternalHooks } from "./scheduler.js";
 
 let externalSourceConfig = null;
 
@@ -37,7 +37,7 @@ let externalSourceConfig = null;
  * ```
  */
 // Wires a freshly created computed through the active external-source bridge.
-// Lives here (installed on GlobalQueue while a config is active) rather than
+// Lives here (installed as a scheduler hook while a config is active) rather than
 // inline in core: esbuild cannot literal-track the mutable config binding the
 // way rollup does, so an inline `if (externalSourceConfig)` block ships in
 // every bundle even though only enableExternalSource() can make it reachable.
@@ -46,11 +46,11 @@ function wireExternalSource(e) {
         equals: false,
         ownedWrite: true
     });
-    const r = externalSourceConfig.factory(e.ee, () => {
+    const r = externalSourceConfig.factory(e.X, () => {
         setSignal(n, undefined);
     });
     cleanup(() => r.dispose());
-    e.ee = e => {
+    e.X = e => {
         read(n);
         return r.track(e);
     };
@@ -64,8 +64,7 @@ function externalUntrack(e) {
 // removed on reset) so core's presence checks stay equivalent to the old
 // `externalSourceConfig` truthiness checks.
 function syncExternalHooks() {
-    GlobalQueue.it = externalSourceConfig ? wireExternalSource : undefined;
-    GlobalQueue._t = externalSourceConfig ? externalUntrack : undefined;
+    if (externalSourceConfig) setExternalHooks(wireExternalSource, externalUntrack); else setExternalHooks(undefined, undefined);
 }
 
 function enableExternalSource(e) {

package/dist/prod/core/graph.js

@@ -1,8 +1,8 @@
-import { CONFIG_AUTO_DISPOSE, STATUS_PENDING, REACTIVE_DISPOSED, REACTIVE_ZOMBIE, REACTIVE_RECOMPUTING_DEPS, CONFIG_SLOT_NODE } from "./constants.js";
+import { REACTIVE_RECOMPUTING_DEPS, CONFIG_AUTO_DISPOSE, STATUS_PENDING, REACTIVE_DISPOSED, REACTIVE_ZOMBIE, CONFIG_SLOT_NODE } from "./constants.js";
 
 import { deleteFromHeap } from "./heap.js";
 
-import { disposeChildren } from "./owner.js";
+import { disposeChildren, runCleanup } from "./owner.js";
 
 import { bumpNotifyEpoch, dirtyQueue } from "./scheduler.js";
 
@@ -17,38 +17,42 @@ function setSlotUnobserved(e) {
 
 // https://github.com/stackblitz/alien-signals/blob/v2.0.3/src/system.ts#L100
 function unlinkSubs(e) {
-    const n = e.I;
-    const o = e._;
-    const l = e.o;
-    const t = e.en;
-    if (l !== null) l.en = t; else n.Ye = t;
-    if (t !== null) t.o = l; else {
-        n.t = l;
-        if (l === null) {
+    const n = e.S;
+    const l = e.G;
+    const o = e.t;
+    const s = e.Xe;
+    if (o !== null) o.Xe = s; else n.ve = s;
+    if (s !== null) s.t = o; else {
+        n.o = o;
+        if (o === null) {
             // Store slot nodes dispatch to the ONE shared hook — no per-node
             // unobserved closure, no NodeExtension to hold it.
-            if (n.i & CONFIG_SLOT_NODE) slotUnobservedHook(n); else n.m?.Je?.();
+            // A user hook that throws is collected like a cleanup (owner.ts): the
+            // unlink and the teardown around it carry on.
+            if (n.l & CONFIG_SLOT_NODE) slotUnobservedHook(n); else if (n.T?.we) runCleanup(n.T.we);
             // No more subscribers; only tear down if CONFIG_AUTO_DISPOSE is set.
             // A pending node is exempt: its in-flight async work 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 dormancy sweep guards on
             // pending identically).
+            // During a pass's teardown of its unfinished frame, the release waits
+            // for the pass to end (`deferredReleases`, #4142).
                         const e = n;
-            e.ee && e.i & CONFIG_AUTO_DISPOSE && !(e.R & REACTIVE_ZOMBIE) && !(e.S & STATUS_PENDING) && unobserved(e);
+            e.X && e.l & CONFIG_AUTO_DISPOSE && !(e.R & REACTIVE_ZOMBIE) && !(e.m & STATUS_PENDING) && (deferredReleases ? deferredReleases.push(e) : unobserved(e));
         }
     }
-    return o;
+    return l;
 }
 
 function trimStaleDeps(e) {
-    const n = e.G;
-    let o = n !== null ? n._ : e.p;
-    if (o !== null) {
+    const n = e._;
+    let l = n !== null ? n.G : e.C;
+    if (l !== null) {
         do {
-            o = unlinkSubs(o);
-        } while (o !== null);
-        if (n !== null) n._ = null; else e.p = null;
+            l = unlinkSubs(l);
+        } while (l !== null);
+        if (n !== null) n.G = null; else e.C = null;
     }
 }
 
@@ -57,15 +61,27 @@ function trimStaleDeps(e) {
 // and skipping early also avoids adding one (hidden-class churn) via the
 // null-out below.
 function clearDeps(e) {
-    let n = e.p;
+    let n = e.C;
     if (!n) return;
     do {
         n = unlinkSubs(n);
     } while (n !== null);
-    e.p = null;
-    e.G = null;
+    e.C = null;
+    e._ = null;
 }
 
+/**
+ * Last-one-out releases held back while a pass tears down the frame of an
+ * earlier pass that never committed (#4142). The pass is about to rebuild
+ * the same children, which read the same lazy nodes again. Released on the
+ * spot, a lazy async memo whose only reader was the old frame's child memo
+ * was torn down, re-ran on the new child's read, went pending, and the cycle
+ * repeated forever. `recompute` collects them around that teardown and
+ * releases what is still unobserved when the pass ends.
+ */ let deferredReleases = null;
+
+const deferReleases = e => deferredReleases = e;
+
 function unobserved(e) {
     deleteFromHeap(e, dirtyQueue);
     clearDeps(e);
@@ -101,7 +117,7 @@ function sweepDormant() {
         // 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.t && e.i & CONFIG_AUTO_DISPOSE && !(e.S & STATUS_PENDING) && !(e.R & (REACTIVE_DISPOSED | REACTIVE_ZOMBIE))) {
+        if (!e.o && e.l & CONFIG_AUTO_DISPOSE && !(e.m & STATUS_PENDING) && !(e.R & (REACTIVE_DISPOSED | REACTIVE_ZOMBIE))) {
             unobserved(e);
         }
     }
@@ -110,15 +126,15 @@ function sweepDormant() {
 
 // https://github.com/stackblitz/alien-signals/blob/v2.0.3/src/system.ts#L52
 function link(e, n) {
-    const o = n.G;
-    if (o !== null && o.I === e) return;
-    let l = null;
-    const t = n.R & REACTIVE_RECOMPUTING_DEPS;
-    if (t) {
-        l = o !== null ? o._ : n.p;
-        if (l !== null && l.I === e) {
-            l.Pe = n.pe;
-            n.G = l;
+    const l = n._;
+    if (l !== null && l.S === e) return;
+    let o = null;
+    const s = n.R & REACTIVE_RECOMPUTING_DEPS;
+    if (s) {
+        o = l !== null ? l.G : n.C;
+        if (o !== null && o.S === e) {
+            o.Te = n.Ne;
+            n._ = o;
             return;
         }
     }
@@ -127,20 +143,20 @@ function link(e, n) {
     // [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 s = e.Ye;
-    if (s !== null && s.l === n && (!t || s.Pe === n.pe)) return;
-    const u = n.G = e.Ye = {
-        I: e,
-        l: n,
-        _: l,
-        en: s,
-        o: null,
-        Pe: n.pe
+        const r = e.ve;
+    if (r !== null && r.u === n && (!s || r.Te === n.Ne)) return;
+    const t = n._ = e.ve = {
+        S: e,
+        u: n,
+        G: o,
+        Xe: r,
+        t: null,
+        Te: n.Ne
     };
-    if (o !== null) o._ = u; else n.p = u;
-    if (s !== null) s.o = u; else e.t = u;
+    if (l !== null) l.G = t; else n.C = t;
+    if (r !== null) r.t = t; else e.o = t;
     // New subscriber edge: staged-rewrite skips (§12d) must not miss it.
         bumpNotifyEpoch();
 }
 
-export { clearDeps, dormantNodes, link, setSlotUnobserved, slotUnobservedHook, sweepDormant, trimStaleDeps, unlinkSubs, unobserved };
+export { clearDeps, deferReleases, deferredReleases, dormantNodes, link, setSlotUnobserved, slotUnobservedHook, sweepDormant, trimStaleDeps, unlinkSubs, unobserved };

package/dist/prod/core/heap.js

@@ -11,22 +11,22 @@ import { dirtyQueue } from "./scheduler.js";
  * callback to the user queue once the pass has committed (see
  * GlobalQueue._update, #3291).
  */ function enqueueSub(e) {
-    if (dirtyQueue.Ue > e.me) dirtyQueue.Ue = e.me;
+    if (dirtyQueue.Ge > e.Fe) dirtyQueue.Ge = e.Fe;
     insertIntoHeap(e, dirtyQueue);
 }
 
 function actualInsertIntoHeap(e, t) {
-    const E = (e._parent?.$e ? e._parent.et?.me : e._parent?.me) ?? -1;
-    if (E >= e.me) e.me = E + 1;
-    const n = e.me;
-    const I = t.Ht[n];
-    if (I === undefined) t.Ht[n] = e; else {
-        const t = I.we;
-        t.je = e;
-        e.we = t;
-        I.we = e;
+    const E = (e._parent?.Qe ? e._parent.Ye?.Fe : e._parent?.Fe) ?? -1;
+    if (E >= e.Fe) e.Fe = E + 1;
+    const n = e.Fe;
+    const I = t.$e[n];
+    if (I === undefined) t.$e[n] = e; else {
+        const t = I.We;
+        t.be = e;
+        e.We = t;
+        I.We = e;
     }
-    if (n > t.ft) t.ft = n;
+    if (n > t.et) t.et = n;
 }
 
 function insertIntoHeap(e, t) {
@@ -49,7 +49,7 @@ function insertIntoHeap(e, t) {
         // parked in the heap for a synchronous mount (each row writing a ref
         // signal its effect subscribes to), mounting N rows was O(N²) (#3350).
         // markNode's own guard skips an already-DIRTY node.
-                if (t.N) markNode(e);
+                if (t.p) markNode(e);
     }
     if (!(E & REACTIVE_IN_HEAP_HEIGHT)) actualInsertIntoHeap(e, t);
 }
@@ -65,23 +65,23 @@ function deleteFromHeap(e, t) {
     const E = e.R;
     if (!(E & (REACTIVE_IN_HEAP | REACTIVE_IN_HEAP_HEIGHT))) return;
     e.R = E & -25;
-    const n = e.me;
-    if (e.we === e) t.Ht[n] = undefined; else {
-        const E = e.je;
-        const I = t.Ht[n];
+    const n = e.Fe;
+    if (e.We === e) t.$e[n] = undefined; else {
+        const E = e.be;
+        const I = t.$e[n];
         const i = E ?? I;
-        if (e === I) t.Ht[n] = E; else e.we.je = E;
-        i.we = e.we;
+        if (e === I) t.$e[n] = E; else e.We.be = E;
+        i.We = e.We;
     }
-    e.we = e;
-    e.je = undefined;
+    e.We = e;
+    e.be = undefined;
 }
 
 function markHeap(e) {
-    if (e.N) return;
-    e.N = true;
-    for (let t = 0; t <= e.ft; t++) {
-        for (let E = e.Ht[t]; E !== undefined; E = E.je) {
+    if (e.p) return;
+    e.p = true;
+    for (let t = 0; t <= e.et; t++) {
+        for (let E = e.$e[t]; E !== undefined; E = E.be) {
             if (E.R & REACTIVE_IN_HEAP) markNode(E);
         }
     }
@@ -91,33 +91,33 @@ function markNode(e, t = REACTIVE_DIRTY) {
     const E = e.R;
     if ((E & (REACTIVE_CHECK | REACTIVE_DIRTY)) >= t) return;
     e.R = E & -4 | t;
-    for (let t = e.t; t !== null; t = t.o) {
-        markNode(t.l, REACTIVE_CHECK);
+    for (let t = e.o; t !== null; t = t.t) {
+        markNode(t.u, REACTIVE_CHECK);
     }
 }
 
 function runHeap(e, t) {
-    e.N = false;
-    for (e.Ue = 0; e.Ue <= e.ft; e.Ue++) {
-        let E = e.Ht[e.Ue];
+    e.p = false;
+    for (e.Ge = 0; e.Ge <= e.et; e.Ge++) {
+        let E = e.$e[e.Ge];
         while (E !== undefined) {
             if (E.R & REACTIVE_IN_HEAP) t(E); else adjustHeight(E, e);
-            E = e.Ht[e.Ue];
+            E = e.$e[e.Ge];
         }
     }
-    e.ft = 0;
+    e.et = 0;
 }
 
 function adjustHeight(e, t) {
     deleteFromHeap(e, t);
-    let E = e.me;
-    for (let t = e.p; t; t = t._) {
-        const e = t.I;
-        if (e.ee && e.me >= E) E = e.me + 1;
+    let E = e.Fe;
+    for (let t = e.C; t; t = t.G) {
+        const e = t.S;
+        if (e.X && e.Fe >= E) E = e.Fe + 1;
     }
-    if (e.me !== E) {
-        e.me = E;
-        for (let E = e.t; E !== null; E = E.o) insertIntoHeapHeight(E.l, t);
+    if (e.Fe !== E) {
+        e.Fe = E;
+        for (let E = e.o; E !== null; E = E.t) insertIntoHeapHeight(E.u, t);
     }
 }
 

package/dist/prod/core/identities.js

@@ -0,0 +1,62 @@
+import { CONFIG_TRANSPARENT } from "./constants.js";
+
+import "./core.js";
+
+import { getOwner } from "./owner.js";
+
+// Deferred hydration, dependency edges: plain-signal identities.
+// While on (`setSignalIdentities`; the server-components client turns it on
+// before hydrating), a plain signal created under an id-bearing owner is
+// named `<owner id>~<n>`, n counting the plain signals (and plain store
+// roots: `createStore` over an object, store/edges.ts) created under that
+// owner in its current pass (transparent owners defer to the nearest
+// id-bearing one, as child ids do). The server names the same signal the
+// same way and restarts the count on every re-run, so an edge it shipped (a
+// slot fill read it) matches the client node; the write hook receives the
+// node and looks its name up (`signalName`). The count restarts when the owner's pass
+// generation (`_depGen`, bumped by every recompute) moves on. Only the
+// frames client imports this module, so nothing here ships without it.
+// Names live in a side table, not on the node: frames reads them across the
+// package boundary, where a mangled field would not survive.
+let counts = null;
+
+const names = new WeakMap;
+
+/** @internal The identity of a plain signal named while identities were on. */ function signalName(n) {
+    return n === undefined ? undefined : names.get(n);
+}
+
+function identify(n) {
+    let e = getOwner();
+    if (!e) return;
+    while (e.l & CONFIG_TRANSPARENT && e._parent) e = e._parent;
+    if (e.id == null) return;
+    const t = e.Ne;
+    let i = counts.get(e);
+    if (i === undefined || i[0] !== t) counts.set(e, i = [ t, 0 ]);
+    const s = e.id + "~" + i[1]++;
+    // A store root named twice (one object made into two stores, or a store
+    // handed to `createStore`) is one target under two server names: its
+    // writes cannot be attributed (an empty name).
+        names.set(n, names.has(n) ? "" : s);
+}
+
+/** @internal Name plain signals from now on (`on`), or stop. */ function setSignalIdentities(n) {
+    counts = n ? counts || new WeakMap : null;
+    signalHook = n ? identify : null;
+}
+
+/**
+ * @internal Called with every plain signal `createSignal` makes, and every
+ * plain store root `createStore` makes, while set (the namer above). Never
+ * set unless `setSignalIdentities` is imported, so a bundle without it keeps
+ * only a null check.
+ */ let signalHook = null;
+
+/**
+ * @internal Dev only: `watch` is called with every node read while set (the
+ * dev hook `onRead`) — the frames client's identity-drift check watches the
+ * named signals a deferred occurrence reads as it mounts. A no-op in prod.
+ */ function setReadWatch(n) {}
+
+export { setReadWatch, setSignalIdentities, signalHook, signalName };