@solidjs/signals 2.0.0-rc.8 → 2.0.0-rc.9

package/dist/prod/core/dev.js

@@ -2,4 +2,20 @@ import "./core.js";
 
 const DEV = undefined;
 
-export { DEV };
+/**
+ * Root-first names of the owners enclosing `subject` (inclusive when the
+ * subject is itself a named owner). Signals hop to their registering owner
+ * (`_owner`, set by registerGraph). Unnamed owners are skipped so the path
+ * reads as the component tree plus the scope: `<App> › <TodoRow> › effect`.
+ */ function ownerPath(n) {
+    if (!n) return undefined;
+    let e = "_parent" in n ? n : n.se ?? null;
+    const t = [];
+    for (;e !== null; e = e._parent) {
+        const n = e._name;
+        if (typeof n === "string" && n.length) t.push(n);
+    }
+    return t.length ? t.reverse() : undefined;
+}
+
+export { DEV, ownerPath };

package/dist/prod/core/effect.js

@@ -1,9 +1,11 @@
-import { REACTIVE_DISPOSED, LANE_RUN, STATUS_ERROR, EFFECT_USER, CONFIG_AUTO_DISPOSE, CONFIG_CHILDREN_FORBIDDEN, EFFECT_TRACKED, EFFECT_RENDER, STATUS_PENDING } 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 { setEffectStatusNotify, ext, createEffectNode, recompute, computed, staleValues } from "./core.js";
 
 import { unwrapStatusError, StatusError } from "./error.js";
 
+import { trimStaleDeps } from "./graph.js";
+
 import { enqueueSub } from "./heap.js";
 
 import { GlobalQueue, currentTransition, activeTransition, haltReactivity, schedule } from "./scheduler.js";
@@ -14,9 +16,12 @@ import { GlobalQueue, currentTransition, activeTransition, haltReactivity, sched
  * sources and recompute
  */ function effect(t, e, E, r) {
     const n = !!r?.user;
-    const f = createEffectNode(t, e, E, n ? EFFECT_USER : EFFECT_RENDER, r);
-    recompute(f, true);
-    !r?.defer && (f.Ce === EFFECT_USER || r?.schedule ? f.C.enqueue(f.Ce, runEffect.bind(null, f)) : runEffect(f, LANE_RUN));
+    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.ve === NOT_PENDING && (i.Le === EFFECT_USER || r?.schedule ? i.C.enqueue(i.Le, runEffect.bind(null, i)) : runEffect(i, LANE_RUN));
 }
 
 function notifyEffectStatus(t, e) {
@@ -25,7 +30,7 @@ function notifyEffectStatus(t, e) {
     const r = e !== undefined ? e : this.o?._;
     if (E & STATUS_ERROR) {
         this.C.notify(this, STATUS_PENDING, 0);
-        if (this.Ce === EFFECT_USER) {
+        if (this.Le === 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
@@ -36,8 +41,8 @@ function notifyEffectStatus(t, e) {
             // `status` arg without node-state writes) don't queue: the status
             // re-propagates unblocked at commit.
             if (this.S & STATUS_ERROR) {
-                this.He = true;
-                this.C.enqueue(this.Ce, this.rt ??= runEffect.bind(null, this));
+                this.Ye = true;
+                this.C.enqueue(this.Le, this.dt ??= runEffect.bind(null, this));
             }
             return;
         }
@@ -45,13 +50,13 @@ function notifyEffectStatus(t, e) {
             haltReactivity(unwrapStatusError(r));
             throw r;
         }
-    } else if (this.Ce === EFFECT_RENDER) {
+    } else if (this.Le === EFFECT_RENDER) {
         this.C.notify(this, STATUS_PENDING | STATUS_ERROR, E, r);
     }
 }
 
 function runEffect(t, e) {
-    if (!t.He || t.ie & REACTIVE_DISPOSED) return;
+    if (!t.Ye || t.ue & 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
@@ -68,8 +73,8 @@ function runEffect(t, e) {
     // 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._t !== null && !currentTransition(t._t).ft && (e & LANE_RUN ? !t.o?.Oe : activeTransition !== null)) {
-        t.C.enqueue(t.Ce, t.rt);
+        if (t.It !== null && !currentTransition(t.It).Tt && (e & LANE_RUN ? !t.o?.Ue : activeTransition !== null)) {
+        t.C.enqueue(t.Le, t.dt);
         return;
     }
     // Error arm (#2840), user effects only: a compute-phase error that is still
@@ -82,14 +87,14 @@ function runEffect(t, e) {
     // 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.Ce === EFFECT_USER) {
+        if (t.S & STATUS_ERROR && t.Le === EFFECT_USER) {
         const e = unwrapStatusError(t.o?._);
-        t.Ft = t.me;
-        t.He = false;
+        t.Ut = t.Qe;
+        t.Ye = false;
         try {
-            t.vt ? t.vt(e, () => {
-                const e = t.Ht;
-                t.Ht = undefined;
+            t.Vt ? t.Vt(e, () => {
+                const e = t.yt;
+                t.yt = undefined;
                 e?.();
             }) : console.error(e);
         } catch (e) {
@@ -100,14 +105,17 @@ function runEffect(t, e) {
         }
         return;
     }
-    const E = t.Ht;
-    t.Ht = 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.yt;
+    t.yt = undefined;
     try {
-        E?.();
-        const e = t.ht(t.me, t.Ft);
+        r?.();
+        const e = t.Lt(t.Qe, t.Ut);
         if (false && e !== undefined && typeof e !== "function") ;
         // The final cleanup is invoked by disposeChildren at true disposal.
-                t.Ht = e;
+                t.yt = e;
     } catch (e) {
         ext(t)._ = new StatusError(t, e);
         t.S |= STATUS_ERROR;
@@ -116,12 +124,18 @@ function runEffect(t, e) {
             throw e;
         }
     } finally {
-        t.Ft = t.me;
-        t.He = false;
+        t.Ut = t.Qe;
+        t.Ye = 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.ct = runEffect;
+GlobalQueue.Et = runEffect;
 
 /**
  * Internal tracked effect - bypasses heap, goes directly to effect queue.
@@ -132,30 +146,30 @@ GlobalQueue.ct = runEffect;
         // `_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.He || E.ie & REACTIVE_DISPOSED) return;
+        if (!E.Ye || E.ue & REACTIVE_DISPOSED) return;
         try {
-            E.He = false;
+            E.Ye = false;
             recompute(E);
         } finally {}
     };
     const E = computed(() => {
-        const e = E.Ht;
-        E.Ht = undefined;
+        const e = E.yt;
+        E.yt = undefined;
         e?.();
         const r = staleValues(t);
-        E.Ht = r;
+        E.yt = r;
     }, {
         ...e,
         lazy: true
     });
-    E.Ht = undefined;
+    E.yt = undefined;
     E.T = E.T & ~CONFIG_AUTO_DISPOSE | CONFIG_CHILDREN_FORBIDDEN;
-    E.He = true;
-    E.Ce = EFFECT_TRACKED;
+    E.Ye = true;
+    E.Le = 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.Ve = run;
+        E.Ke = 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.

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/external.js

@@ -46,11 +46,11 @@ function wireExternalSource(e) {
         equals: false,
         ownedWrite: true
     });
-    const r = externalSourceConfig.factory(e.oe, () => {
+    const r = externalSourceConfig.factory(e.ce, () => {
         setSignal(n, undefined);
     });
     cleanup(() => r.dispose());
-    e.oe = e => {
+    e.ce = 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.kt = externalSourceConfig ? wireExternalSource : null;
-    GlobalQueue.Lt = externalSourceConfig ? externalUntrack : null;
+    GlobalQueue.wt = externalSourceConfig ? wireExternalSource : null;
+    GlobalQueue.Yt = externalSourceConfig ? externalUntrack : null;
 }
 
 function enableExternalSource(e) {

package/dist/prod/core/graph.js

@@ -10,17 +10,17 @@ import { bumpNotifyEpoch } from "./scheduler.js";
 
 // https://github.com/stackblitz/alien-signals/blob/v2.0.3/src/system.ts#L100
 function unlinkSubs(e) {
-    const n = e.Se;
-    const l = e.ae;
-    const o = e.Te;
-    const s = e.en;
-    if (o !== null) o.en = s; else n.dt = s;
-    if (s !== null) s.Te = o; else {
+    const n = e.Ee;
+    const l = e.de;
+    const o = e.Ne;
+    const s = e.rn;
+    if (o !== null) o.rn = s; else n.Gt = s;
+    if (s !== null) s.Ne = 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.T & CONFIG_SLOT_NODE) slotUnobservedHook(n); else n.o?.Ct?.();
+            if (n.T & CONFIG_SLOT_NODE) slotUnobservedHook(n); else n.o?.Pt?.();
             // 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
@@ -28,20 +28,20 @@ function unlinkSubs(e) {
             // this same last-one-out check when that observer releases (the
             // untracked-read dormancy sweep guards on pending identically).
                         const e = n;
-            e.oe && e.T & CONFIG_AUTO_DISPOSE && !(e.ie & REACTIVE_ZOMBIE) && !(e.S & STATUS_PENDING) && unobserved(e);
+            e.ce && e.T & CONFIG_AUTO_DISPOSE && !(e.ue & REACTIVE_ZOMBIE) && !(e.S & STATUS_PENDING) && unobserved(e);
         }
     }
     return l;
 }
 
 function trimStaleDeps(e) {
-    const n = e.et;
-    let l = n !== null ? n.ae : e.fe;
+    const n = e.ot;
+    let l = n !== null ? n.de : e.Se;
     if (l !== null) {
         do {
             l = unlinkSubs(l);
         } while (l !== null);
-        if (n !== null) n.ae = null; else e.fe = null;
+        if (n !== null) n.de = null; else e.Se = null;
     }
 }
 
@@ -50,13 +50,13 @@ function trimStaleDeps(e) {
 // and skipping early also avoids adding one (hidden-class churn) via the
 // null-out below.
 function clearDeps(e) {
-    let n = e.fe;
+    let n = e.Se;
     if (!n) return;
     do {
         n = unlinkSubs(n);
     } while (n !== null);
-    e.fe = null;
-    e.et = null;
+    e.Se = null;
+    e.ot = null;
 }
 
 function unobserved(e) {
@@ -94,7 +94,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.u && e.T & CONFIG_AUTO_DISPOSE && !(e.S & STATUS_PENDING) && !(e.ie & (REACTIVE_DISPOSED | REACTIVE_ZOMBIE))) {
+        if (!e.u && e.T & CONFIG_AUTO_DISPOSE && !(e.S & STATUS_PENDING) && !(e.ue & (REACTIVE_DISPOSED | REACTIVE_ZOMBIE))) {
             unobserved(e);
         }
     }
@@ -108,20 +108,20 @@ function link(e, n, l = false) {
     // 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 o = n.et;
-    if (o !== null && o.Se === e) {
-        o.je &&= l;
+    const o = n.ot;
+    if (o !== null && o.Ee === e) {
+        o.He &&= l;
         return;
     }
     let s = null;
-    const t = n.ie & REACTIVE_RECOMPUTING_DEPS;
+    const t = n.ue & REACTIVE_RECOMPUTING_DEPS;
     if (t) {
-        s = o !== null ? o.ae : n.fe;
-        if (s !== null && s.Se === e) {
-            s.yt = n.tt;
-            n.et = s;
+        s = o !== null ? o.de : n.Se;
+        if (s !== null && s.Ee === e) {
+            s.qe = n.Ze;
+            n.ot = s;
             // First touch of this pass: the previous pass's label is stale.
-                        s.je = l;
+                        s.He = l;
             return;
         }
     }
@@ -130,24 +130,24 @@ function link(e, n, l = 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 r = e.dt;
-    if (r !== null && r.Ie === n && (!t || r.yt === n.tt)) {
+        const r = e.Gt;
+    if (r !== null && r._e === n && (!t || r.qe === n.Ze)) {
         // 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) r.je &&= l; else r.je = l;
+        if (t) r.He &&= l; else r.He = l;
         return;
     }
-    const u = n.et = e.dt = {
-        Se: e,
-        Ie: n,
-        ae: s,
-        en: r,
-        Te: null,
-        yt: n.tt,
-        je: l
+    const u = n.ot = e.Gt = {
+        Ee: e,
+        _e: n,
+        de: s,
+        rn: r,
+        Ne: null,
+        qe: n.Ze,
+        He: l
     };
-    if (o !== null) o.ae = u; else n.fe = u;
-    if (r !== null) r.Te = u; else e.u = u;
+    if (o !== null) o.de = u; else n.Se = u;
+    if (r !== null) r.Ne = u; else e.u = u;
     // New subscriber edge: staged-rewrite skips (§12d) must not miss it.
         bumpNotifyEpoch();
 }

package/dist/prod/core/heap.js

@@ -5,7 +5,7 @@ import { REACTIVE_IN_HEAP, REACTIVE_IN_HEAP_HEIGHT, REACTIVE_ZOMBIE, REACTIVE_RE
 import { zombieQueue, dirtyQueue } from "./scheduler.js";
 
 /** The queue a node belongs to, picked from its own zombie flag. */ function queueFor(e) {
-    return e.ie & REACTIVE_ZOMBIE ? zombieQueue : dirtyQueue;
+    return e.ue & REACTIVE_ZOMBIE ? zombieQueue : dirtyQueue;
 }
 
 /**
@@ -16,34 +16,34 @@ import { zombieQueue, dirtyQueue } from "./scheduler.js";
  * (see GlobalQueue._update, #3291).
  */ function enqueueSub(e) {
     const E = queueFor(e);
-    if (E.Ke > e.Be) E.Ke = e.Be;
+    if (E.et > e.tt) E.et = e.tt;
     insertIntoHeap(e, E);
 }
 
 function actualInsertIntoHeap(e, E) {
-    const t = (e.qe?.gt ? e.qe.bt?.Be : e.qe?.Be) ?? -1;
-    if (t >= e.Be) e.Be = t + 1;
-    const n = e.Be;
+    const t = (e._parent?.xt ? e._parent.Qt?.tt : e._parent?.tt) ?? -1;
+    if (t >= e.tt) e.tt = t + 1;
+    const n = e.tt;
     const I = E.eE[n];
     if (I === undefined) E.eE[n] = e; else {
-        const E = I.Tt;
-        E.Nt = e;
-        e.Tt = E;
-        I.Tt = e;
+        const E = I.Rt;
+        E.At = e;
+        e.Rt = E;
+        I.Rt = e;
     }
     if (n > E.EE) E.EE = n;
 }
 
 function insertIntoHeap(e, E) {
-    let t = e.ie;
+    let t = e.ue;
     // RECOMPUTING refusals are not always losses: a genuinely missed wake (a
     // write to a link this pass already validated) is latched link-side in
     // insertSubs as REACTIVE_MISSED_WAKE for recompute's tail (#3037).
         if (t & (REACTIVE_IN_HEAP | REACTIVE_RECOMPUTING_DEPS | REACTIVE_MANUAL_WRITE)) return;
     if (t & REACTIVE_CHECK) {
-        e.ie = t & -4 | REACTIVE_DIRTY | REACTIVE_IN_HEAP;
+        e.ue = t & -4 | REACTIVE_DIRTY | REACTIVE_IN_HEAP;
     } else {
-        e.ie = t | REACTIVE_IN_HEAP;
+        e.ue = t | REACTIVE_IN_HEAP;
         // An unmarked node entering an already-marked heap is marked on the
         // spot, keeping the markHeap memo valid. `_marked` is only reset by
         // runHeap, so a write between two mid-tick pulls (read-time markHeap +
@@ -60,52 +60,52 @@ function insertIntoHeap(e, E) {
 }
 
 function insertIntoHeapHeight(e, E) {
-    let t = e.ie;
+    let t = e.ue;
     if (t & (REACTIVE_IN_HEAP | REACTIVE_RECOMPUTING_DEPS | REACTIVE_IN_HEAP_HEIGHT | REACTIVE_MANUAL_WRITE)) return;
-    e.ie = t | REACTIVE_IN_HEAP_HEIGHT;
+    e.ue = t | REACTIVE_IN_HEAP_HEIGHT;
     actualInsertIntoHeap(e, E);
 }
 
 function deleteFromHeap(e, E) {
-    const t = e.ie;
+    const t = e.ue;
     if (!(t & (REACTIVE_IN_HEAP | REACTIVE_IN_HEAP_HEIGHT))) return;
-    e.ie = t & -25;
-    const n = e.Be;
-    if (e.Tt === e) E.eE[n] = undefined; else {
-        const t = e.Nt;
+    e.ue = t & -25;
+    const n = e.tt;
+    if (e.Rt === e) E.eE[n] = undefined; else {
+        const t = e.At;
         const I = E.eE[n];
         const o = t ?? I;
-        if (e === I) E.eE[n] = t; else e.Tt.Nt = t;
-        o.Tt = e.Tt;
+        if (e === I) E.eE[n] = t; else e.Rt.At = t;
+        o.Rt = e.Rt;
     }
-    e.Tt = e;
-    e.Nt = undefined;
+    e.Rt = e;
+    e.At = undefined;
 }
 
 function markHeap(e) {
     if (e.tE) return;
     e.tE = true;
     for (let E = 0; E <= e.EE; E++) {
-        for (let t = e.eE[E]; t !== undefined; t = t.Nt) {
-            if (t.ie & REACTIVE_IN_HEAP) markNode(t);
+        for (let t = e.eE[E]; t !== undefined; t = t.At) {
+            if (t.ue & REACTIVE_IN_HEAP) markNode(t);
         }
     }
 }
 
 function markNode(e, E = REACTIVE_DIRTY) {
-    const t = e.ie;
+    const t = e.ue;
     if ((t & (REACTIVE_CHECK | REACTIVE_DIRTY)) >= E) return;
-    e.ie = t & -4 | E;
-    for (let E = e.u; E !== null; E = E.Te) {
-        markNode(E.Ie, REACTIVE_CHECK);
+    e.ue = t & -4 | E;
+    for (let E = e.u; E !== null; E = E.Ne) {
+        markNode(E._e, REACTIVE_CHECK);
     }
     // Firewall children (projection machinery only): gate the cold-extension
     // deref on the config bit — markNode runs per sub edge per write, and an
     // unconditional _x chase here taxed every propagation (diamond -22%).
         if (e.T & CONFIG_FW_CHILDREN) {
-        for (let E = e.o.i; E !== null; E = E.Ee) {
-            for (let e = E.u; e !== null; e = e.Te) {
-                markNode(e.Ie, REACTIVE_CHECK);
+        for (let E = e.o.i; E !== null; E = E.De) {
+            for (let e = E.u; e !== null; e = e.Ne) {
+                markNode(e._e, REACTIVE_CHECK);
             }
         }
     }
@@ -113,11 +113,11 @@ function markNode(e, E = REACTIVE_DIRTY) {
 
 function runHeap(e, E) {
     e.tE = false;
-    for (e.Ke = 0; e.Ke <= e.EE; e.Ke++) {
-        let t = e.eE[e.Ke];
+    for (e.et = 0; e.et <= e.EE; e.et++) {
+        let t = e.eE[e.et];
         while (t !== undefined) {
-            if (t.ie & REACTIVE_IN_HEAP) E(t); else adjustHeight(t, e);
-            t = e.eE[e.Ke];
+            if (t.ue & REACTIVE_IN_HEAP) E(t); else adjustHeight(t, e);
+            t = e.eE[e.et];
         }
     }
     e.EE = 0;
@@ -125,21 +125,21 @@ function runHeap(e, E) {
 
 function adjustHeight(e, E) {
     deleteFromHeap(e, E);
-    let t = e.Be;
-    for (let E = e.fe; E; E = E.ae) {
-        const e = E.Se;
-        const n = e.ce || e;
-        if (n.oe && n.Be >= t) t = n.Be + 1;
+    let t = e.tt;
+    for (let E = e.Se; E; E = E.de) {
+        const e = E.Ee;
+        const n = e.Te || e;
+        if (n.ce && n.tt >= t) t = n.tt + 1;
     }
-    if (e.Be !== t) {
-        e.Be = t;
-        for (let E = e.u; E !== null; E = E.Te) {
+    if (e.tt !== t) {
+        e.tt = t;
+        for (let E = e.u; E !== null; E = E.Ne) {
             // Route each subscriber by its own zombie flag, mirroring the
             // post-recompute height-adjust path. Inserting into the running `heap`
             // unconditionally can park a zombie in `dirtyQueue` (or a live node in
             // `zombieQueue`), breaking the flag/queue invariant `deleteFromHeap`
             // relies on — the same corruption class as #2759.
-            insertIntoHeapHeight(E.Ie, queueFor(E.Ie));
+            insertIntoHeapHeight(E._e, queueFor(E._e));
         }
     }
 }