@solidjs/signals 2.0.0-rc.14 → 2.0.0-rc.16

package/dist/observe/core/dev.js

@@ -53,13 +53,22 @@ const diagnostics = {
     }
 };
 
+// Flight identity → earliest declared start (see `AttributionSlot.markFlight`).
+// Weak: a stamp must not keep a settled promise alive.
+const flightOrigins = new WeakMap;
+
 const attributionSlot = {
     get installed() {
         return attrHooks;
     },
     withInteraction: withInteraction,
     withOrigin: withOrigin,
-    currentOrigin: currentOrigin
+    currentOrigin: currentOrigin,
+    markFlight(e, n = performance.now()) {
+        // Earliest wins (`undefined <= n` is false: the first mark always lands).
+        if (!(flightOrigins.get(e) <= n)) flightOrigins.set(e, n);
+    },
+    flightOrigin: e => flightOrigins.get(e)
 };
 
 const RECORDS = Symbol.for("@solidjs/signals/observe/records");
@@ -70,38 +79,38 @@ function recordsChannel() {
     const n = new Map;
     const t = new Map;
     return e[RECORDS] = {
-        subscribe(e, o, r) {
-            const i = n.get(e);
+        subscribe(e, i, o) {
+            const r = n.get(e);
             // Set semantics: one entry per function, however often it is passed —
             // the first subscription's options stand for it.
-                        if (i === undefined || !i.includes(o)) {
-                n.set(e, i === undefined ? [ o ] : [ ...i, o ]);
-                if (r !== undefined && r.bodies) {
+                        if (r === undefined || !r.includes(i)) {
+                n.set(e, r === undefined ? [ i ] : [ ...r, i ]);
+                if (o !== undefined && o.bodies) {
                     let n = t.get(e);
                     if (n === undefined) t.set(e, n = new Set);
-                    n.add(o);
+                    n.add(i);
                 }
             }
             return () => {
-                const r = n.get(e);
-                if (r === undefined || !r.includes(o)) return;
-                const i = r.filter(e => e !== o);
-                if (i.length > 0) n.set(e, i); else n.delete(e);
+                const o = n.get(e);
+                if (o === undefined || !o.includes(i)) return;
+                const r = o.filter(e => e !== i);
+                if (r.length > 0) n.set(e, r); else n.delete(e);
                 const s = t.get(e);
-                if (s !== undefined && s.delete(o) && s.size === 0) t.delete(e);
+                if (s !== undefined && s.delete(i) && s.size === 0) t.delete(e);
             };
         },
-        observed(e, o) {
-            return o === "bodies" ? t.has(e) : n.has(e);
+        observed(e, i) {
+            return i === "bodies" ? t.has(e) : n.has(e);
         },
-        emit(e, t, o) {
-            const r = n.get(e);
-            if (r === undefined) return;
+        emit(e, t, i) {
+            const o = n.get(e);
+            if (o === undefined) return;
             // A throwing listener is reported and the rest still hear the record.
             // The try/catch per call allocates nothing unless something throws.
-                        for (let e = 0; e < r.length; e++) {
+                        for (let e = 0; e < o.length; e++) {
                 try {
-                    r[e](t, o);
+                    o[e](t, i);
                 } catch (e) {
                     console.error(e);
                 }
@@ -184,15 +193,28 @@ const DEV = undefined;
     return t.length ? t.reverse() : undefined;
 }
 
+/**
+ * The innermost source location on the subject's chain: the subject's own
+ * `_loc` (a signal or computation created with `{ loc }`), else the first
+ * `_loc` up the owners — a signal hops to its registering owner, then
+ * `_parent` upward (a component root carries its JSX site). The same walk
+ * `ownerPath` makes; `undefined` when nothing on the chain was located.
+ */ function locationOf(e) {
+    // Owners have a `_parent` key (null on a root); a signal has none and hops
+    // to its registering `_owner` instead.
+    for (let n = e; n; n = n._parent !== undefined ? n._parent : n.H) if (n._loc) return n._loc;
+    return undefined;
+}
+
 /**
  * Records a diagnostic on the structured channel (listeners, captures) and
  * returns the entry. `subject` locates it: the current reactive `context` by
  * default (right for the synchronous rule checks — they fire inside the
  * scope that misbehaved); pass the node for scheduler-time findings whose
  * ambient context is the flush, or `null` for events that have no location
- * by nature. An `ownerPath` already on the event wins over the subject walk
- * (hosts whose owners are not signals' owners compute their own). Console
- * output is a separate, dev-tier step — see `reportDiagnostic`.
+ * by nature. An `ownerPath` (or `loc`) already on the event wins over the
+ * subject walk (hosts whose owners are not signals' owners compute their
+ * own). Console output is a separate, dev-tier step — see `reportDiagnostic`.
  */ function emitDiagnostic(e, n = context) {
     const t = {
         sequence: ++diagnosticSequence,
@@ -208,9 +230,13 @@ const DEV = undefined;
         const e = ownerPath(n);
         if (e) t.ownerPath = e;
     }
-    const o = n ?? undefined;
-    if (o !== undefined) eventSubjects.set(t, o);
-    for (const e of diagnosticListeners) e(t, o);
+    if (t.loc === undefined) {
+        const e = locationOf(n);
+        if (e !== undefined) t.loc = e;
+    }
+    const i = n ?? undefined;
+    if (i !== undefined) eventSubjects.set(t, i);
+    for (const e of diagnosticListeners) e(t, i);
     for (const e of diagnosticCaptures) e.push(t);
     return t;
 }
@@ -229,9 +255,11 @@ const DEV = undefined;
 /**
  * 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
- * once-per-code footer as trailing lines, and — when the subject is a
- * binding effect the rendering runtime tagged — the element it writes, as a
- * second console argument (hover highlights it, click jumps to Elements).
+ * source location (`at src/App.tsx:18:3` — see `locationLine`) when a node on
+ * the chain was compiled with one, the once-per-code footer as trailing
+ * lines, and — when the subject is a binding effect the rendering runtime
+ * tagged — the element it writes, as a second console argument (hover
+ * highlights it, click jumps to Elements).
  * Severity picks the console method. Call sites report the entry
  * `emitDiagnostic` returned so the structured and console channels never
  * disagree. Dev-tier: in an observe build this is a no-op, so wiring paths
@@ -322,16 +350,16 @@ function shouldWarnGraphSize(e, n) {
  * node, re-warning only once the count has grown by GRAPH_SIZE_WARN_EVERY.
  */ function noteFanOut(e, n, t) {
     if (!shouldWarnGraphSize(e, n)) return;
-    const o = e._name;
-    const r = `[HUGE_FAN_OUT] ${o ? `Signal "${o}"` : "A signal"} changed with ${n} 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 i = e._name;
+    const o = `[HUGE_FAN_OUT] ${i ? `Signal "${i}"` : "A signal"} changed with ${n} 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: r,
-        nodeName: o,
+        message: o,
+        nodeName: i,
         ownerId: e.id,
-        ownerName: o,
+        ownerName: i,
         data: t === undefined ? {
             count: n
         } : {
@@ -348,12 +376,12 @@ function shouldWarnGraphSize(e, n) {
  */ function noteFanIn(e, n) {
     if (!shouldWarnGraphSize(e, n)) return;
     const t = e._name;
-    const o = `[HUGE_FAN_IN] ${t ? `Computation "${t}"` : "A computation"} tracked ${n} 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 i = `[HUGE_FAN_IN] ${t ? `Computation "${t}"` : "A computation"} tracked ${n} 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: o,
+        message: i,
         nodeName: t,
         ownerId: e.id,
         ownerName: t,

package/dist/observe/core/effect.js

@@ -12,28 +12,28 @@ 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(t, e, u, o) {
-    const E = !!o?.user;
-    const r = createEffectNode(t, e, u, E ? EFFECT_USER : EFFECT_RENDER, o);
+ */ function effect(t, e, o, u) {
+    const E = !!u?.user;
+    const r = createEffectNode(t, e, o, E ? 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).
-        !o?.defer && r.Ae === NOT_PENDING && !r.m?._t?.Z && (r.i === EFFECT_USER || o?.schedule ? globalQueue.enqueue(r.i, runEffect.bind(null, r)) : runEffect(r, r.i));
+        !u?.defer && r.ue === NOT_PENDING && !r.T?.Je?.V && (r.i === EFFECT_USER || u?.schedule ? globalQueue.enqueue(r.i, runEffect.bind(null, r)) : runEffect(r, r.i));
 }
 
 function notifyEffectStatus(t, e) {
     // Use passed values if provided, otherwise read from node
-    const u = t !== undefined ? t : this.G;
-    const o = e !== undefined ? e : this.m?.v;
-    if (u & STATUS_ERROR) {
+    const o = t !== undefined ? t : this.m;
+    const u = e !== undefined ? e : this.T?.F;
+    if (o & STATUS_ERROR) {
         globalQueue.notify(this, STATUS_PENDING, 0);
         if (this.i === EFFECT_USER) {
             // The error handler is the error arm of the effect phase (#2840 ruling):
@@ -43,23 +43,23 @@ 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.G & STATUS_ERROR) {
-                this.lt = true;
-                globalQueue.enqueue(this.i, this.J ??= runEffect.bind(null, this));
+            if (this.m & STATUS_ERROR) {
+                this.Qe = true;
+                globalQueue.enqueue(this.i, this.W ??= runEffect.bind(null, this));
             }
             return;
         }
         if (!globalQueue.notify(this, STATUS_ERROR, STATUS_ERROR)) {
-            haltReactivity(unwrapStatusError(o));
-            throw o;
+            haltReactivity(unwrapStatusError(u));
+            throw u;
         }
     } else if (this.i === EFFECT_RENDER) {
-        globalQueue.notify(this, STATUS_PENDING | STATUS_ERROR, u, o);
+        globalQueue.notify(this, STATUS_PENDING | STATUS_ERROR, o, u);
     }
 }
 
 function runEffect(t, e) {
-    if (!t.lt || t.R & REACTIVE_DISPOSED) return;
+    if (!t.Qe || 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
@@ -68,7 +68,7 @@ function runEffect(t, e) {
     // 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.de && GlobalQueue.de(t)) 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
@@ -79,12 +79,12 @@ 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.G & STATUS_ERROR && t.i === EFFECT_USER) {
-        const e = unwrapStatusError(t.m?.v);
-        t.Nt = t.pe;
-        t.lt = false;
+        if (t.m & STATUS_ERROR && t.i === EFFECT_USER) {
+        const e = unwrapStatusError(t.T?.F);
+        t._t = t.Ie;
+        t.Qe = false;
         try {
-            t.Lt ? t.Lt(e, () => {
+            t.ht ? t.ht(e, () => {
                 const e = t.kt;
                 t.kt = undefined;
                 e?.();
@@ -99,43 +99,43 @@ function runEffect(t, e) {
     }
     // 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 = t.m?.v == null;
+        const o = t.T?.F == null;
     // Observe tier, like its `effectRunEnd` twin below: the frame the engine
     // opens here is what stamps the callback's writes as the effect's (the
     // cascade an observer reports) and what times the callback (the `effect`
     // record) — facts a production observer needs, not only a dev console.
         if (attrHooks !== null) attrHooks.effectRunStart(t);
-    const o = t.kt;
+    const u = t.kt;
     t.kt = undefined;
     try {
-        o?.();
-        const e = t.Ut(t.pe, t.Nt);
+        u?.();
+        const e = t.Ge(t.Ie, t._t);
         if (false && e !== undefined && typeof e !== "function") ;
         // The final cleanup is invoked by disposeChildren at true disposal.
                 t.kt = e;
     } catch (e) {
-        ext(t).v = new StatusError(t, e);
-        t.G |= STATUS_ERROR;
+        ext(t).F = new StatusError(t, e);
+        t.m |= STATUS_ERROR;
         if (!globalQueue.notify(t, STATUS_ERROR, STATUS_ERROR)) {
             haltReactivity(e);
             throw e;
         }
     } finally {
-        t.Nt = t.pe;
-        t.lt = false;
+        t._t = t.Ie;
+        t.Qe = 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(t);
+                if (o) 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.X = runEffect;
+GlobalQueue.K = runEffect;
 
 /**
  * Internal tracked effect - bypasses heap, goes directly to effect queue.
@@ -146,38 +146,38 @@ GlobalQueue.X = runEffect;
         // `_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.lt || u.R & REACTIVE_DISPOSED) return;
-        if (GlobalQueue.de && GlobalQueue.de(u)) return;
+        if (!o.Qe || o.R & REACTIVE_DISPOSED) return;
+        if (heldRunHook?.(o)) return;
         try {
-            u.lt = false;
-            recompute(u);
+            o.Qe = false;
+            recompute(o);
         } finally {}
     };
-    const u = computed(() => {
-        const e = u.kt;
-        u.kt = undefined;
+    const o = computed(() => {
+        const e = o.kt;
+        o.kt = undefined;
         e?.();
-        const o = staleValues(t);
-        u.kt = o;
+        const u = staleValues(t);
+        o.kt = u;
     }, {
         ...e,
         lazy: true
     });
-    u.kt = undefined;
-    u.u = u.u & ~CONFIG_AUTO_DISPOSE | CONFIG_CHILDREN_FORBIDDEN;
-    u.lt = true;
-    u.i = EFFECT_TRACKED;
+    o.kt = undefined;
+    o.l = o.l & ~CONFIG_AUTO_DISPOSE | CONFIG_CHILDREN_FORBIDDEN;
+    o.Qe = true;
+    o.i = 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) u._name = "trackedEffect";
+        if (e?.name === undefined) o._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.
-        u.q = run;
+        o.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(o);
     schedule();
 }
 

package/dist/observe/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/observe/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.re, () => {
+    const r = externalSourceConfig.factory(e.X, () => {
         setSignal(n, undefined);
     });
     cleanup(() => r.dispose());
-    e.re = 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.xt = externalSourceConfig ? wireExternalSource : undefined;
-    GlobalQueue.Wt = externalSourceConfig ? externalUntrack : undefined;
+    if (externalSourceConfig) setExternalHooks(wireExternalSource, externalUntrack); else setExternalHooks(undefined, undefined);
 }
 
 function enableExternalSource(e) {

package/dist/observe/core/graph.js

@@ -1,4 +1,4 @@
-import { CONFIG_AUTO_DISPOSE, STATUS_PENDING, REACTIVE_DISPOSED, REACTIVE_ZOMBIE, CONFIG_SLOT_NODE, REACTIVE_RECOMPUTING_DEPS } 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";
 
@@ -17,38 +17,40 @@ 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.p;
-    const l = e.l;
-    const t = e.ln;
-    if (l !== null) l.ln = t; else n.Dt = t;
-    if (t !== null) t.l = l; else {
-        n.t = l;
-        if (l === null) {
+    const n = e.S;
+    const l = e.G;
+    const o = e.t;
+    const s = e.en;
+    if (o !== null) o.en = s; else n.dt = 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.u & CONFIG_SLOT_NODE) slotUnobservedHook(n); else n.m?.Ft?.();
+            if (n.l & CONFIG_SLOT_NODE) slotUnobservedHook(n); else n.T?.Dt?.();
             // 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.re && e.u & CONFIG_AUTO_DISPOSE && !(e.R & REACTIVE_ZOMBIE) && !(e.G & 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.S;
-    let o = n !== null ? n.p : e._;
-    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.p = null; else e._ = null;
+            l = unlinkSubs(l);
+        } while (l !== null);
+        if (n !== null) n.G = null; else e.C = null;
     }
 }
 
@@ -57,15 +59,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._;
+    let n = e.C;
     if (!n) return;
     do {
         n = unlinkSubs(n);
     } while (n !== null);
+    e.C = null;
     e._ = null;
-    e.S = 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 +115,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.u & CONFIG_AUTO_DISPOSE && !(e.G & 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 +124,15 @@ function sweepDormant() {
 
 // https://github.com/stackblitz/alien-signals/blob/v2.0.3/src/system.ts#L52
 function link(e, n) {
-    const o = n.S;
-    if (o !== null && o.I === e) return;
-    let l = null;
-    const t = n.R & REACTIVE_RECOMPUTING_DEPS;
-    if (t) {
-        l = o !== null ? o.p : n._;
-        if (l !== null && l.I === e) {
-            l.Ue = n.he;
-            n.S = 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 +141,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.Dt;
-    if (s !== null && s.o === n && (!t || s.Ue === n.he)) return;
-    const u = n.S = e.Dt = {
-        I: e,
-        o: n,
-        p: l,
-        ln: s,
-        l: null,
-        Ue: n.he
+        const t = e.dt;
+    if (t !== null && t.u === n && (!s || t.Te === n.Ne)) return;
+    const r = n._ = e.dt = {
+        S: e,
+        u: n,
+        G: o,
+        en: t,
+        t: null,
+        Te: n.Ne
     };
-    if (o !== null) o.p = u; else n._ = u;
-    if (s !== null) s.l = u; else e.t = u;
+    if (l !== null) l.G = r; else n.C = r;
+    if (t !== null) t.t = r; else e.o = r;
     // 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 };