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

package/dist/observe/core/dev.js

@@ -1,4 +1,4 @@
-import { withOrigin, withInteraction, setAttributionHooks, attrHooks } from "./attribution-hooks.js";
+import { currentOrigin, withOrigin, withInteraction, setAttributionHooks, attrHooks } from "./attribution-hooks.js";
 
 import { context } from "./core.js";
 
@@ -44,12 +44,60 @@ const attributionSlot = {
         return attrHooks;
     },
     withInteraction: withInteraction,
-    withOrigin: withOrigin
+    withOrigin: withOrigin,
+    currentOrigin: currentOrigin
 };
 
+// The records channel is process-wide (see `Records`): a host that bundles
+// the core into its server build beside an instrumented `--import`ed copy
+// holds two of this module, and a listener installed through one must hear
+// the records the render emits through the other. The registered key makes
+// every copy find the one listener set; the object is generic — a Map of
+// type to listener set — and carries no knowledge of the records.
+const RECORDS = Symbol.for("@solidjs/signals/observe/records");
+
+function recordsChannel() {
+    const e = globalThis;
+    if (e[RECORDS]) return e[RECORDS];
+    const t = new Map;
+    return e[RECORDS] = {
+        subscribe(e, n) {
+            let r = t.get(e);
+            if (!r) t.set(e, r = new Set);
+            r.add(n);
+            return () => {
+                r.delete(n);
+            };
+        },
+        observed(e) {
+            const n = t.get(e);
+            return n !== undefined && n.size > 0;
+        },
+        emit(e, n, r) {
+            const s = t.get(e);
+            if (s === undefined || s.size === 0) return;
+            // Snapshot: a listener unsubscribing (itself or another) mid-delivery
+            // must not skip or double-call anyone this round. A throwing listener
+            // is reported; the others, and what was observed, are unaffected.
+                        for (const e of [ ...s ]) {
+                try {
+                    e(n, r);
+                } catch (e) {
+                    console.error(e);
+                }
+            }
+        }
+    };
+}
+
 const OBSERVE = {
     diagnostics: diagnostics,
+    records: recordsChannel(),
     attribution: attributionSlot,
+    // Replaced by solid-js's server entry (see `ServerObserve`); on the
+    // client the slot stays this placeholder. The cast: the interface is
+    // empty HERE and gains its members by augmentation downstream.
+    server: {},
     subjectOf(e) {
         return eventSubjects.get(e);
     },
@@ -74,8 +122,8 @@ let hasExclusions = false;
 
 function isExcluded(e) {
     if (!hasExclusions || !e) return false;
-    let t = "Nt" in e ? e : e.an ?? null;
-    for (;t !== null; t = t.Nt) if (excludedOwners.has(t)) return true;
+    let t = "_parent" in e ? e : e.nt ?? null;
+    for (;t !== null; t = t._parent) if (excludedOwners.has(t)) return true;
     return false;
 }
 
@@ -96,9 +144,9 @@ const DEV = undefined;
  * reads as the component tree plus the scope: `<App> › <TodoRow> › effect`.
  */ function ownerPath(e) {
     if (!e) return undefined;
-    let t = "Nt" in e ? e : e.an ?? null;
+    let t = "_parent" in e ? e : e.nt ?? null;
     const n = [];
-    for (;t !== null; t = t.Nt) {
+    for (;t !== null; t = t._parent) {
         const e = t._name;
         if (typeof e === "string" && e.length) n.push(e);
     }
@@ -136,13 +184,26 @@ const DEV = undefined;
 }
 
 /**
- * The subject each emitted event was about, for the console step: events are
- * serializable records and cannot carry the node, but the console can show
- * what the node knows — a rendering runtime may stamp a binding effect with
- * the DOM element it writes (`_devElement`), and a live element reference
- * beside the message is the most addressable pointer a console can print.
+ * The subject each emitted event was about: events are serializable records
+ * and cannot carry the node, so the node is kept beside the record for the
+ * in-process consumers that want it — the console step, which can show what
+ * the node knows (a rendering runtime may stamp a binding effect with the DOM
+ * element it writes, `_devElement`, and a live element reference beside the
+ * message is the most addressable pointer a console can print), and devtools
+ * that go from a re-run record back to the scope that ran. Keyed by the
+ * record object, so the subject lives exactly as long as some consumer holds
+ * the record (a ring buffer, a captured artifact) — the same lifetime the
+ * node had when records carried it directly.
  */ const eventSubjects = new WeakMap;
 
+/** Register `subject` as what `record` was about — see `Observe.subjectOf`. */ function recordSubject(e, t) {
+    eventSubjects.set(e, t);
+}
+
+/** The live subject `record` was about, if its emitter registered one. */ function subjectOf(e) {
+    return eventSubjects.get(e);
+}
+
 /**
  * The console face of a diagnostic — ONE entry per finding: the message, the
  * owner path (`in <App> › <TodoRow> › effect`) so a human can locate it, the
@@ -163,7 +224,7 @@ const DEV = undefined;
  * locate signal subjects. The per-owner `_signals` list and the devtools
  * `onGraph` hook are dev-tier — the observe build pays one property write.
  */ function registerGraph(e, t) {
-    e.an = t;
+    e.nt = t;
 }
 
 /**
@@ -192,12 +253,12 @@ function shouldWarnGraphSize(e, t) {
  */ function noteFanOut(e, t) {
     if (!shouldWarnGraphSize(e, t)) return;
     const n = e._name;
-    const i = `[HUGE_FAN_OUT] ${n ? `Signal "${n}"` : "A signal"} changed with ${t} subscribers — ` + `every one re-runs this flush. If many independent computations read the same value ` + `(for example every row of a list comparing against one selected id), prefer a per-key ` + `store or projection so only the items whose result flipped update.`;
+    const r = `[HUGE_FAN_OUT] ${n ? `Signal "${n}"` : "A signal"} changed with ${t} subscribers — ` + `every one re-runs this flush. If many independent computations read the same value ` + `(for example every row of a list comparing against one selected id), prefer a per-key ` + `store or projection so only the items whose result flipped update.`;
     reportDiagnostic(emitDiagnostic({
         code: "HUGE_FAN_OUT",
         kind: "graph",
         severity: "warn",
-        message: i,
+        message: r,
         nodeName: n,
         ownerId: e.id,
         ownerName: n,
@@ -214,12 +275,12 @@ function shouldWarnGraphSize(e, t) {
  */ function noteFanIn(e, t) {
     if (!shouldWarnGraphSize(e, t)) return;
     const n = e._name;
-    const i = `[HUGE_FAN_IN] ${n ? `Computation "${n}"` : "A computation"} tracked ${t} sources. ` + `It will re-run when any of them change. Narrow the read or split the derivation so each ` + `computation tracks only what it needs.`;
+    const r = `[HUGE_FAN_IN] ${n ? `Computation "${n}"` : "A computation"} tracked ${t} sources. ` + `It will re-run when any of them change. Narrow the read or split the derivation so each ` + `computation tracks only what it needs.`;
     reportDiagnostic(emitDiagnostic({
         code: "HUGE_FAN_IN",
         kind: "graph",
         severity: "warn",
-        message: i,
+        message: r,
         nodeName: n,
         ownerId: e.id,
         ownerName: n,
@@ -229,4 +290,4 @@ function shouldWarnGraphSize(e, t) {
     }, e));
 }
 
-export { DEV, GRAPH_SIZE_WARN_AT, GRAPH_SIZE_WARN_EVERY, OBSERVE, anyExcluded, emitDiagnostic, isExcluded, isSuppressed, noteFanIn, noteFanOut, ownerPath, registerGraph, reportDiagnostic };
+export { DEV, GRAPH_SIZE_WARN_AT, GRAPH_SIZE_WARN_EVERY, OBSERVE, anyExcluded, emitDiagnostic, isExcluded, isSuppressed, noteFanIn, noteFanOut, ownerPath, recordSubject, registerGraph, reportDiagnostic, subjectOf };

package/dist/observe/core/effect.js

@@ -1,11 +1,15 @@
-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 { attrHooks } from "./attribution-hooks.js";
 
+import "./dev.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,20 +18,23 @@ import { GlobalQueue, currentTransition, activeTransition, haltReactivity, sched
  * 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 n = !!r?.user;
-    const f = createEffectNode(t, e, E, n ? EFFECT_USER : EFFECT_RENDER, r);
-    recompute(f, true);
-    !r?.defer && (f.Re === EFFECT_USER || r?.schedule ? f.C.enqueue(f.Re, runEffect.bind(null, f)) : runEffect(f, LANE_RUN));
+ */ function effect(t, e, r, E) {
+    const i = !!E?.user;
+    const n = createEffectNode(t, e, r, i ? EFFECT_USER : EFFECT_RENDER, E);
+    recompute(n, 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).
+        !E?.defer && n._e === NOT_PENDING && (n.Pe === EFFECT_USER || E?.schedule ? n.T.enqueue(n.Pe, runEffect.bind(null, n)) : runEffect(n, LANE_RUN));
 }
 
 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.o?._;
-    if (E & STATUS_ERROR) {
-        this.C.notify(this, STATUS_PENDING, 0);
-        if (this.Re === EFFECT_USER) {
+    const r = t !== undefined ? t : this.S;
+    const E = e !== undefined ? e : this.o?._;
+    if (r & STATUS_ERROR) {
+        this.T.notify(this, STATUS_PENDING, 0);
+        if (this.Pe === 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
@@ -38,22 +45,22 @@ 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._t = true;
-                this.C.enqueue(this.Re, this.kt ??= runEffect.bind(null, this));
+                this.Nt = true;
+                this.T.enqueue(this.Pe, this.Ut ??= 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(E));
+            throw E;
         }
-    } else if (this.Re === EFFECT_RENDER) {
-        this.C.notify(this, STATUS_PENDING | STATUS_ERROR, E, r);
+    } else if (this.Pe === EFFECT_RENDER) {
+        this.T.notify(this, STATUS_PENDING | STATUS_ERROR, r, E);
     }
 }
 
 function runEffect(t, e) {
-    if (!t._t || t.it & REACTIVE_DISPOSED) return;
+    if (!t.Nt || t.ft & 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
@@ -70,8 +77,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.Vt !== null && !currentTransition(t.Vt).Ut && (e & LANE_RUN ? !t.o?.Te : activeTransition !== null)) {
-        t.C.enqueue(t.Re, t.kt);
+        if (t.Vt !== null && !currentTransition(t.Vt).yt && (e & LANE_RUN ? !t.o?.de : activeTransition !== null)) {
+        t.T.enqueue(t.Pe, t.Ut);
         return;
     }
     // Error arm (#2840), user effects only: a compute-phase error that is still
@@ -84,49 +91,58 @@ 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.Re === EFFECT_USER) {
+        if (t.S & STATUS_ERROR && t.Pe === EFFECT_USER) {
         const e = unwrapStatusError(t.o?._);
-        t.Bt = t.ge;
-        t._t = false;
+        t.$t = t.Ae;
+        t.Nt = false;
         try {
-            t.Jt ? t.Jt(e, () => {
-                const e = t.Xt;
-                t.Xt = undefined;
+            t.un ? t.un(e, () => {
+                const e = t.an;
+                t.an = undefined;
                 e?.();
             }) : console.error(e);
         } catch (e) {
-            if (!t.C.notify(t, STATUS_ERROR, STATUS_ERROR)) {
+            if (!t.T.notify(t, STATUS_ERROR, STATUS_ERROR)) {
                 haltReactivity(e);
                 throw e;
             }
         }
         return;
     }
-    const E = t.Xt;
-    t.Xt = 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 r = t.o?._ == null;
+    const E = t.an;
+    t.an = undefined;
     try {
         E?.();
-        const e = t.zt(t.ge, t.Bt);
+        const e = t.ln(t.Ae, t.$t);
         if (false && e !== undefined && typeof e !== "function") ;
         // The final cleanup is invoked by disposeChildren at true disposal.
-                t.Xt = e;
+                t.an = e;
     } catch (e) {
         ext(t)._ = new StatusError(t, e);
         t.S |= STATUS_ERROR;
-        if (!t.C.notify(t, STATUS_ERROR, STATUS_ERROR)) {
+        if (!t.T.notify(t, STATUS_ERROR, STATUS_ERROR)) {
             haltReactivity(e);
             throw e;
         }
     } finally {
-        t.Bt = t.ge;
-        t._t = false;
+        t.$t = t.Ae;
+        t.Nt = 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 (r) trimStaleDeps(t);
     }
     // Outside the try (see the rule in attribution-hooks.ts). Reached whether or
     // not the callback threw — a throw that escapes the catch above halts.
         if (attrHooks !== null) attrHooks.effectRunEnd(t);
 }
 
-GlobalQueue.bt = runEffect;
+GlobalQueue.Lt = runEffect;
 
 /**
  * Internal tracked effect - bypasses heap, goes directly to effect queue.
@@ -137,37 +153,37 @@ GlobalQueue.bt = 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._t || E.it & REACTIVE_DISPOSED) return;
+        if (!r.Nt || r.ft & REACTIVE_DISPOSED) return;
         try {
-            E._t = false;
-            recompute(E);
+            r.Nt = false;
+            recompute(r);
         } finally {}
     };
-    const E = computed(() => {
-        const e = E.Xt;
-        E.Xt = undefined;
+    const r = computed(() => {
+        const e = r.an;
+        r.an = undefined;
         e?.();
-        const r = staleValues(t);
-        E.Xt = r;
+        const E = staleValues(t);
+        r.an = E;
     }, {
         ...e,
         lazy: true
     });
-    E.Xt = undefined;
-    E.T = E.T & ~CONFIG_AUTO_DISPOSE | CONFIG_CHILDREN_FORBIDDEN;
-    E._t = true;
-    E.Re = EFFECT_TRACKED;
+    r.an = undefined;
+    r.C = r.C & ~CONFIG_AUTO_DISPOSE | CONFIG_CHILDREN_FORBIDDEN;
+    r.Nt = true;
+    r.Pe = EFFECT_TRACKED;
     // Observe-tier label: the computed literal defaulted its `_name` slot to
     // "computed"; relabel by kind (a store into the slot, not a new field).
-        if (e?.name === undefined) E._name = "trackedEffect";
+        if (e?.name === undefined) r._name = "trackedEffect";
     // 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.ct = run;
+        r.Et = 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);
+        enqueueSub(r);
     schedule();
 }
 

package/dist/observe/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/observe/core/external.js

@@ -46,11 +46,11 @@ function wireExternalSource(e) {
         equals: false,
         ownedWrite: true
     });
-    const r = externalSourceConfig.factory(e.ot, () => {
+    const r = externalSourceConfig.factory(e.ht, () => {
         setSignal(n, undefined);
     });
     cleanup(() => r.dispose());
-    e.ot = e => {
+    e.ht = 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.un = externalSourceConfig ? wireExternalSource : null;
-    GlobalQueue.cn = externalSourceConfig ? externalUntrack : null;
+    GlobalQueue._n = externalSourceConfig ? wireExternalSource : null;
+    GlobalQueue.In = externalSourceConfig ? externalUntrack : null;
 }
 
 function enableExternalSource(e) {

package/dist/observe/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.oe;
-    const l = e.ne;
-    const o = e.se;
-    const s = e.mn;
-    if (o !== null) o.mn = s; else n.Wt = s;
-    if (s !== null) s.se = o; else {
+    const n = e.re;
+    const l = e.te;
+    const o = e.ie;
+    const s = e.bn;
+    if (o !== null) o.bn = s; else n.qt = s;
+    if (s !== null) s.ie = 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?.qt?.();
+            if (n.C & CONFIG_SLOT_NODE) slotUnobservedHook(n); else n.o?.Kt?.();
             // 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.ot && e.T & CONFIG_AUTO_DISPOSE && !(e.it & REACTIVE_ZOMBIE) && !(e.S & STATUS_PENDING) && unobserved(e);
+            e.ht && e.C & CONFIG_AUTO_DISPOSE && !(e.ft & REACTIVE_ZOMBIE) && !(e.S & STATUS_PENDING) && unobserved(e);
         }
     }
     return l;
 }
 
 function trimStaleDeps(e) {
-    const n = e.Dt;
-    let l = n !== null ? n.ne : e.te;
+    const n = e.Fe;
+    let l = n !== null ? n.te : e.ee;
     if (l !== null) {
         do {
             l = unlinkSubs(l);
         } while (l !== null);
-        if (n !== null) n.ne = null; else e.te = null;
+        if (n !== null) n.te = null; else e.ee = 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.te;
+    let n = e.ee;
     if (!n) return;
     do {
         n = unlinkSubs(n);
     } while (n !== null);
-    e.te = null;
-    e.Dt = null;
+    e.ee = null;
+    e.Fe = 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.it & (REACTIVE_DISPOSED | REACTIVE_ZOMBIE))) {
+        if (!e.u && e.C & CONFIG_AUTO_DISPOSE && !(e.S & STATUS_PENDING) && !(e.ft & (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.Dt;
-    if (o !== null && o.oe === e) {
-        o.ye &&= l;
+    const o = n.Fe;
+    if (o !== null && o.re === e) {
+        o.Ce &&= l;
         return;
     }
     let s = null;
-    const t = n.it & REACTIVE_RECOMPUTING_DEPS;
+    const t = n.ft & REACTIVE_RECOMPUTING_DEPS;
     if (t) {
-        s = o !== null ? o.ne : n.te;
-        if (s !== null && s.oe === e) {
-            s.fn = n.Pt;
-            n.Dt = s;
+        s = o !== null ? o.te : n.ee;
+        if (s !== null && s.re === e) {
+            s.pe = n.ye;
+            n.Fe = s;
             // First touch of this pass: the previous pass's label is stale.
-                        s.ye = l;
+                        s.Ce = 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.Wt;
-    if (r !== null && r.le === n && (!t || r.fn === n.Pt)) {
+        const r = e.qt;
+    if (r !== null && r.se === n && (!t || r.pe === 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) r.ye &&= l; else r.ye = l;
+        if (t) r.Ce &&= l; else r.Ce = l;
         return;
     }
-    const u = n.Dt = e.Wt = {
-        oe: e,
-        le: n,
-        ne: s,
-        mn: r,
-        se: null,
-        fn: n.Pt,
-        ye: l
+    const u = n.Fe = e.qt = {
+        re: e,
+        se: n,
+        te: s,
+        bn: r,
+        ie: null,
+        pe: n.ye,
+        Ce: l
     };
-    if (o !== null) o.ne = u; else n.te = u;
-    if (r !== null) r.se = u; else e.u = u;
+    if (o !== null) o.te = u; else n.ee = u;
+    if (r !== null) r.ie = u; else e.u = u;
     // New subscriber edge: staged-rewrite skips (§12d) must not miss it.
         bumpNotifyEpoch();
 }