@solidjs/signals 2.0.0-rc.2 → 2.0.0-rc.4

package/dist/prod/core/core.js

@@ -4,7 +4,7 @@ import { EFFECT_TRACKED, REACTIVE_OPTIMISTIC_DIRTY, CONFIG_OPTIMISTIC, NOT_PENDI
 
 import { NotReadyError } from "./error.js";
 
-import { trimStaleDeps, link, unobserved } from "./graph.js";
+import { trimStaleDeps, link, dormantNodes } from "./graph.js";
 
 import { deleteFromHeap, queueFor, insertIntoHeapHeight, enqueueSub, markNode, markHeap, insertIntoHeap } from "./heap.js";
 
@@ -49,7 +49,7 @@ let snapshotSources = null;
 function ownerInSnapshotScope(e) {
     while (e) {
         if (e.He) return true;
-        e = e.ve;
+        e = e.ke;
     }
     return false;
 }
@@ -70,13 +70,13 @@ function releaseSnapshotScope(e) {
 }
 
 function releaseSubtree(e) {
-    let t = e.ke;
+    let t = e.ve;
     while (t) {
         if (t.He) {
             t = t.Ve;
             continue;
         }
-        if (t.Se) {
+        if (t.oe) {
             const e = t;
             e.T &= ~CONFIG_IN_SNAPSHOT_SCOPE;
             if (e.ie & REACTIVE_SNAPSHOT_STALE) {
@@ -114,13 +114,13 @@ function recompute(e, t = false) {
         deleteFromHeap(e, queueFor(e));
         if (e.o !== null) e.o.Ee = null;
         // Tracked effects run after finalizePureQueue, so dispose immediately instead of deferring
-                if (e._e || n === EFFECT_TRACKED) disposeChildren(e); else if (e.ke !== null || e.he !== null) {
+                if (e._e || n === EFFECT_TRACKED) disposeChildren(e); else if (e.ve !== null || e.he !== null) {
             markDisposal(e);
             const t = ext(e);
             t.We = e.he;
-            t.qe = e.ke;
+            t.qe = e.ve;
             e.he = null;
-            e.ke = null;
+            e.ve = null;
             e.Me = 0;
         } else ;
     }
@@ -148,8 +148,8 @@ function recompute(e, t = false) {
     let c = e.Pe === NOT_PENDING ? e.be : e.Pe;
     let _ = e.Le;
     let f = false;
-    let E = tracking;
-    let I = currentOptimisticLane;
+    let N = tracking;
+    let E = currentOptimisticLane;
     tracking = true;
     // A computed's fn establishes its OWN dependencies, so it must never run
     // inside a latest() read window: read() short-circuits through the
@@ -157,7 +157,7 @@ function recompute(e, t = false) {
     // computed) inside latest(fn) came out permanently dependency-less (#2926).
     // latestRead() already suspends the flag for its pull-recomputes; this
     // covers creation-time computes and flushes that run inside the window.
-        const N = latestReadActive;
+        const I = latestReadActive;
     latestReadActive = false;
     // Lane posture lives with the engine: OPTIMISTIC_DIRTY is only ever set by
     // engine-driven paths, and _optimisticNodes is only pushed by
@@ -179,12 +179,12 @@ function recompute(e, t = false) {
             currentOptimisticLane = t;
         }
     }
-    const T = n && n !== EFFECT_USER;
-    const d = stale;
-    if (T) stale = true;
+    const d = n && n !== EFFECT_USER;
+    const T = stale;
+    if (d) stale = true;
     try {
         if (!false && e.T & CONFIG_SYNC) {
-            c = e.Se(c);
+            c = e.oe(c);
             if (e.o !== null) e.o.Ee = null;
             e.Ie = false;
         } else {
@@ -194,7 +194,7 @@ function recompute(e, t = false) {
             // clobber the fresh subscription, so we skip it and let the internally-registered
             // iteration drive updates.
             const t = e.o?.Ee;
-            const n = e.Se(c);
+            const n = e.oe(c);
             const i = typeof n === "object" && n !== null;
             const u = e.o?.Ee !== t;
             c = u || !i ? n : handleAsync(e, n);
@@ -232,16 +232,16 @@ function recompute(e, t = false) {
             if (n && currentOptimisticLane) GlobalQueue.$e(e);
             let i = false;
             if (n) {
-                ext(e).ue = true;
+                ext(e).fe = true;
                 if (GlobalQueue.Je !== null) i = GlobalQueue.Je(e, s);
             }
             notifyStatus(e, n ? STATUS_PENDING : STATUS_ERROR, t, undefined, n ? e.o?.Be : undefined);
-            if (i) GlobalQueue.p(e);
+            if (i) GlobalQueue.k(e);
         }
     } finally {
-        tracking = E;
-        latestReadActive = N;
-        if (T) stale = d;
+        tracking = N;
+        latestReadActive = I;
+        if (d) stale = T;
         // Consume the missed-wake latch (#3037, set by insertSubs): a dep write
         // landed beneath this pass on a link it had already validated. The wipe
         // below must not key off DIRTY/CHECK — the read-time pull protocol
@@ -316,8 +316,8 @@ function recompute(e, t = false) {
             if (a) e.Ie = true;
  // see the held branch above (#2990)
                 } else if (e.Le != _) {
-            for (let t = e.u; t !== null; t = t.fe) {
-                insertIntoHeapHeight(t.ae, queueFor(t.ae));
+            for (let t = e.u; t !== null; t = t.ae) {
+                insertIntoHeapHeight(t.ce, queueFor(t.ce));
             }
         }
         // Silent recovery: errored → unchanged value fires no notification, but
@@ -327,7 +327,7 @@ function recompute(e, t = false) {
         // (el._x?._error re-set), so this only runs on a genuinely clean recovery.
                 if (o !== undefined && !r && !e.o?._) settleErroredDependents(e, o);
     }
-    currentOptimisticLane = I;
+    currentOptimisticLane = E;
     const S = e.Pe !== NOT_PENDING || e.o !== null && (e.o.qe !== null || e.o.We !== null) || (e.S & (STATUS_PENDING | STATUS_UNINITIALIZED)) !== 0;
     // Override-covered holds (hasOverride) always queue: their commit belongs
     // to their own transition's schedule (A18 re-rule) and is unobservable
@@ -357,7 +357,7 @@ function updateIfNecessary(e) {
         for (let t = e.nt; t; t = t.it) {
             const n = t.ut;
             const i = n.lt || n;
-            if (i.Se) {
+            if (i.oe) {
                 updateIfNecessary(i);
             }
             if (e.ie & REACTIVE_DIRTY) {
@@ -385,7 +385,7 @@ function computed(e, t) {
         C: context?.C ?? globalQueue,
         we: context?.we ?? defaultContext,
         Me: 0,
-        Se: e,
+        oe: e,
         be: i ? t.loadingValue : undefined,
         Le: 0,
         ot: undefined,
@@ -395,10 +395,10 @@ function computed(e, t) {
         Ze: 0,
         u: null,
         rt: null,
-        ve: context,
+        ke: context,
         Ve: null,
         ct: null,
-        ke: null,
+        ve: null,
         ie: t?.lazy ? REACTIVE_LAZY : REACTIVE_NONE,
         // A loadingValue node is born committed: commit #0 is already in _value.
         S: i ? 0 : STATUS_UNINITIALIZED,
@@ -424,24 +424,24 @@ function computed(e, t) {
  * Never call ext() just to store a field's default. */ function ext(e) {
     return e.o ??= {
         De: undefined,
-        Et: undefined,
+        Nt: undefined,
         Be: undefined,
         Ge: undefined,
         ge: undefined,
-        It: undefined,
+        Et: undefined,
         t: 0,
         Ee: null,
         _: undefined,
-        ue: undefined,
+        fe: undefined,
         le: undefined,
-        A: undefined,
+        h: undefined,
         pe: false,
-        l: null,
+        i: null,
         ft: undefined,
         Qe: undefined,
         We: null,
         qe: null,
-        Nt: undefined
+        It: undefined
     };
 }
 
@@ -450,17 +450,17 @@ function computed(e, t) {
  * so V8 sees the full hidden class shape at construction time. Effects always run in lazy
  * mode (recompute is called explicitly by `effect()`), so we hardcode the lazy bits and skip
  * the auto-dispose CONFIG bit (effect() previously cleared it post-construction).
- */ function createEffectNode(e, t, n, i, u, l) {
-    const o = l?.transparent ?? false;
-    const s = {
-        id: inheritId(l, o, context),
-        T: (o ? CONFIG_TRANSPARENT : 0) | (l?.ownedWrite ? CONFIG_OWNED_WRITE : 0) | (l?.sync ? CONFIG_SYNC : 0) | (snapshotCaptureActive && ownerInSnapshotScope(context) ? CONFIG_IN_SNAPSHOT_SCOPE : 0),
+ */ function createEffectNode(e, t, n, i, u) {
+    const l = u?.transparent ?? false;
+    const o = {
+        id: inheritId(u, l, context),
+        T: (l ? CONFIG_TRANSPARENT : 0) | (u?.ownedWrite ? CONFIG_OWNED_WRITE : 0) | (u?.sync ? CONFIG_SYNC : 0) | (snapshotCaptureActive && ownerInSnapshotScope(context) ? CONFIG_IN_SNAPSHOT_SCOPE : 0),
         Ue: false,
         he: null,
         C: context?.C ?? globalQueue,
         we: context?.we ?? defaultContext,
         Me: 0,
-        Se: e,
+        oe: e,
         be: undefined,
         Le: 0,
         ot: undefined,
@@ -470,10 +470,10 @@ function computed(e, t) {
         Ze: 0,
         u: null,
         rt: null,
-        ve: context,
+        ke: context,
         Ve: null,
         ct: null,
-        ke: null,
+        ve: null,
         ie: REACTIVE_LAZY,
         S: STATUS_UNINITIALIZED,
         Te: clock,
@@ -482,18 +482,43 @@ function computed(e, t) {
         _t: -1,
         Ie: false,
         Xe: false,
-        Tt: undefined,
-        dt: t,
+        dt: undefined,
+        Tt: t,
         St: n,
         At: undefined,
         Re: i,
         o: null
     };
-    // Boundary effects carry a status channel; most effects never touch _x.
-        if (u !== undefined) ext(s).A = u;
-    if (l?.unobserved) ext(s).ft = l.unobserved;
-    setupComputedNode(s, lazyOptions);
-    return s;
+    // Effects dispatch status through the SHARED notifier (statusNotifierOf,
+    // keyed off _type) — storing it per node forced a full NodeExtension
+    // allocation on EVERY effect at creation (an alloc + 19 field stores,
+    // +23% effect creation, caught by the creation benches). Only genuinely
+    // per-node channels (boundaries) live on _x.
+        if (u?.unobserved) ext(o).ft = u.unobserved;
+    setupComputedNode(o, lazyOptions);
+    return o;
+}
+
+/**
+ * The shared status notifier for effect nodes, installed once by effect.ts
+ * at module evaluation (`this`-dispatched — one function serves every
+ * effect, so nodes never store it). Boundary computeds keep their own
+ * per-node channel on `_x._notifyStatus`, which takes precedence.
+ */ let effectStatusNotify = null;
+
+function setEffectStatusNotify(e) {
+    effectStatusNotify = e;
+}
+
+/** Resolve a node's status notifier: an own `_x` channel (boundaries) wins;
+ * effect nodes (`_type` — EFFECT_PURE is 0, and only effect literals carry
+ * the field) fall back to the shared notifier. Presence doubles as the
+ * "display consumer" membership test in the status walks, exactly as the
+ * per-node field did when every effect carried one. */ function statusNotifierOf(e) {
+    const t = e.o;
+    const n = t !== null && t !== undefined ? t.h : undefined;
+    if (n !== undefined) return n;
+    return e.Re ? effectStatusNotify ?? undefined : undefined;
 }
 
 const lazyOptions = {
@@ -504,13 +529,13 @@ function setupComputedNode(e, t) {
     e.st = e;
     const n = context?.Ct ? context.Ot : context;
     if (context) {
-        const t = context.ke;
+        const t = context.ve;
         if (t === null) {
-            context.ke = e;
+            context.ve = e;
         } else {
             e.Ve = t;
             t.ct = e;
-            context.ke = e;
+            context.ve = e;
         }
     }
     if (n) e.Le = n.Le + 1;
@@ -534,7 +559,7 @@ function signal(e, t, n = null) {
         rt: null,
         Te: clock,
         lt: n,
-        ce: n?.o?.l || null,
+        Se: n?.o?.i || null,
         Pe: NOT_PENDING,
         // Signal-literal diet (§12e): NO _time/_fn/_statusFlags slots. Stores
         // materialize one signal per touched leaf, so signal bytes are store
@@ -547,7 +572,7 @@ function signal(e, t, n = null) {
     };
     if (t?.unobserved) ext(i).ft = t.unobserved;
     if (n) {
-        ext(n).l = i;
+        ext(n).i = i;
         n.T |= CONFIG_FW_CHILDREN;
     }
     if (snapshotCaptureActive && !(i.T & CONFIG_NO_SNAPSHOT) && !((n?.S ?? 0) & STATUS_PENDING)) {
@@ -644,7 +669,7 @@ function isEqual(e, t) {
  * snapshot / transition / lane / dev-strictRead state all take the full
  * resolution. Anything slow returns READ_SLOW; the caller then calls read().
  */ function readNodeFast(e) {
-    if (latestReadActive || pendingCheckActive || e.Se || e.lt || e.o?.De !== undefined || e.o?.Qe !== undefined || activeTransition !== null || currentOptimisticLane !== null || snapshotCaptureActive || false) return READ_SLOW;
+    if (latestReadActive || pendingCheckActive || e.oe || e.lt || e.o?.De !== undefined || e.o?.Qe !== undefined || activeTransition !== null || currentOptimisticLane !== null || snapshotCaptureActive || false) return READ_SLOW;
     let t = context;
     if (t?.Ct) t = t.Ot;
     if (t && tracking) link(e, t);
@@ -671,17 +696,17 @@ function read(e) {
     // recompute don't collect into the probe.
         if (pendingCheckActive) {
         GlobalQueue.Dt(e, t, u, i);
-    } else if (typeof n.Se === "function") {
+    } else if (typeof n.oe === "function") {
         prepareComputed(e, false);
     }
-    if (!n.Se && u === e && e.o?.De === undefined && e.o?.Qe === undefined && activeTransition === null && currentOptimisticLane === null && !snapshotCaptureActive && true) {
+    if (!n.oe && u === e && e.o?.De === undefined && e.o?.Qe === undefined && activeTransition === null && currentOptimisticLane === null && !snapshotCaptureActive && true) {
         if (t && tracking) link(e, t);
         // Committed visibility for children-forbidden readers — see readNodeFast.
                 return !t || e.Pe === NOT_PENDING || t.T & CONFIG_CHILDREN_FORBIDDEN ? e.be : e.Pe;
     }
     if (t && tracking) {
         link(e, t, pendingCheckActive);
-        if (u.Se) {
+        if (u.oe) {
             const n = queueFor(e);
             if (u.Le >= n.xe) {
                 markNode(t);
@@ -690,7 +715,7 @@ function read(e) {
             }
             const i = u.Le;
             // parent check is shallow, might need to be recursive
-                        if (i >= t.Le && e.ve !== t) {
+                        if (i >= t.Le && e.ke !== t) {
                 t.Le = i + 1;
             }
         }
@@ -725,7 +750,7 @@ function read(e) {
     // firewall-backed reads follow the same rules (memo parity, #2897 ruling):
     // an errored derive throws for every late reader instead of silently
     // serving node values (the seed, or last-good data after a failed refetch).
-        if (u.Se && u.S & STATUS_ERROR) {
+        if (u.oe && u.S & STATUS_ERROR) {
         // Only a genuine reactive re-read may retry an errored async source:
         // - tracking: owned/tracked scope only (never events / `untrack` / effect side-effect phase)
         // - !pendingCheckActive: an `isPending` probe observes the error, never refetches
@@ -768,8 +793,15 @@ function read(e) {
     // Record that this isPending() probe observed the fresh pending value, so
     // the probe doesn't pair "pending" with the new value (#2831).
         if (pendingCheckActive) GlobalQueue.Ht(e, l);
-    if (!t && u === e && typeof n.Se === "function" && e.T & CONFIG_AUTO_DISPOSE && !(u.S & STATUS_PENDING) && !e.u) {
-        unobserved(e);
+    if (!t && u === e && typeof n.oe === "function" && e.T & CONFIG_AUTO_DISPOSE && !(u.S & STATUS_PENDING) && !e.u) {
+        // Deferred, not inline (#3078): an inline unobserved() here made untracked
+        // reads destructive — dispose on this read, full revival recompute on the
+        // next — so consecutive reads could answer differently with no write in
+        // between (the revival samples the ambient transition/lane context).
+        // The sweep at flush finalization re-validates and reclaims; schedule()
+        // guarantees that flush happens even if nothing else is queued.
+        dormantNodes.add(e);
+        schedule();
     }
     return l;
 }
@@ -781,7 +813,7 @@ function setSignal(e, t) {
     // _overrideValue slot (flagged by CONFIG_OPTIMISTIC — a masked read of the
     // always-present config instead of a missing-property probe), and every
     // module that installs one installs the engine first.
-        if (e.T & CONFIG_OPTIMISTIC && !projectionWriteActive) return GlobalQueue.vt(e, t);
+        if (e.T & CONFIG_OPTIMISTIC && !projectionWriteActive) return GlobalQueue.kt(e, t);
     const n = e.Pe === NOT_PENDING ? e.be : e.Pe;
     if (typeof t === "function") t = t(n);
     // Uninitialized check first: the first commit has no previous value, so the
@@ -799,7 +831,7 @@ function setSignal(e, t) {
         e.T & CONFIG_HAS_COMPANIONS && GlobalQueue.Oe !== null && GlobalQueue.Oe(e, t);
     // _time is a computed-only slot (§12e): writing it on a signal would fork
     // the lean shape. Every read site is computed-typed.
-        if (e.Se !== undefined) e.Te = clock;
+        if (e.oe !== undefined) e.Te = clock;
     // Staged-rewrite fast path (§12d): a re-write to a node whose subscribers
     // were already walked — and where nothing has recomputed or linked since
     // (epoch) — re-stages the value and stops. The walk is idempotent (subs
@@ -824,7 +856,7 @@ function setSignal(e, t) {
         schedule();
     }
     e.ie = e.ie & -4 | REACTIVE_MANUAL_WRITE;
-    e.kt = clock;
+    e.vt = clock;
 }
 
 /**
@@ -903,7 +935,7 @@ function staleValues(e, t = true) {
     if (!t) {
         return;
     }
-    if (typeof t.Se === "function" && !(t.ie & REACTIVE_DISPOSED)) {
+    if (typeof t.oe === "function" && !(t.ie & REACTIVE_DISPOSED)) {
         if (t.ie & REACTIVE_MANUAL_WRITE) {
             // A manual write in the CURRENT tick wins over the refresh (#2692).
             // A mask stamped in an earlier tick only survives because a
@@ -911,7 +943,7 @@ function staleValues(e, t = true) {
             // refresh is a later, explicit re-ask and lifts the mask — otherwise
             // any setStore early in an action silently swallows every refresh()
             // for the rest of the transaction (#3026).
-            if (t.kt === clock) return;
+            if (t.vt === clock) return;
             t.ie &= ~REACTIVE_MANUAL_WRITE;
             // No REASK below: the batch carries a manual value change, so the
             // recompute is not a quiet re-ask of an unchanged question.
@@ -933,4 +965,4 @@ function staleValues(e, t = true) {
     }
 }
 
-export { READ_SLOW, clearSnapshots, computed, context, createEffectNode, currentOptimisticLane, ext, isEqual, latestReadActive, markSnapshotScope, optimisticComputed, optimisticSignal, pendingCheckActive, prepareComputed, read, readNodeFast, recompute, refresh, releaseSnapshotScope, runWithOwner, setContextInternal, setLatestReadActive, setMemo, setPendingCheckActive, setSignal, setSnapshotCapture, signal, snapshotCaptureActive, snapshotSources, stale, staleValues, suppressComputedRecompute, tracking, untrack };
+export { READ_SLOW, clearSnapshots, computed, context, createEffectNode, currentOptimisticLane, effectStatusNotify, ext, isEqual, latestReadActive, markSnapshotScope, optimisticComputed, optimisticSignal, pendingCheckActive, prepareComputed, read, readNodeFast, recompute, refresh, releaseSnapshotScope, runWithOwner, setContextInternal, setEffectStatusNotify, setLatestReadActive, setMemo, setPendingCheckActive, setSignal, setSnapshotCapture, signal, snapshotCaptureActive, snapshotSources, stale, staleValues, statusNotifierOf, suppressComputedRecompute, tracking, untrack };

package/dist/prod/core/effect.js

@@ -1,6 +1,6 @@
-import { REACTIVE_DISPOSED, STATUS_ERROR, EFFECT_USER, CONFIG_AUTO_DISPOSE, CONFIG_CHILDREN_FORBIDDEN, EFFECT_TRACKED, STATUS_PENDING, EFFECT_RENDER } from "./constants.js";
+import { REACTIVE_DISPOSED, STATUS_ERROR, EFFECT_USER, CONFIG_AUTO_DISPOSE, CONFIG_CHILDREN_FORBIDDEN, EFFECT_TRACKED, EFFECT_RENDER, STATUS_PENDING } from "./constants.js";
 
-import { ext, createEffectNode, recompute, computed, staleValues } from "./core.js";
+import { setEffectStatusNotify, ext, createEffectNode, recompute, computed, staleValues } from "./core.js";
 
 import { unwrapStatusError, StatusError } from "./error.js";
 
@@ -10,17 +10,17 @@ import { GlobalQueue, haltReactivity } from "./scheduler.js";
  * Effects are the leaf nodes of our reactive graph. When their sources change, they are
  * automatically added to the queue of effects to re-execute, which will cause them to fetch their
  * sources and recompute
- */ function effect(t, e, E, R) {
-    const r = !!R?.user;
-    const f = createEffectNode(t, e, E, r ? EFFECT_USER : EFFECT_RENDER, notifyEffectStatus, R);
-    recompute(f, true);
-    !R?.defer && (f.Re === EFFECT_USER || R?.schedule ? f.C.enqueue(f.Re, runEffect.bind(null, f)) : runEffect(f));
+ */ function effect(t, e, E, f) {
+    const r = !!f?.user;
+    const R = createEffectNode(t, e, E, r ? EFFECT_USER : EFFECT_RENDER, f);
+    recompute(R, true);
+    !f?.defer && (R.Re === EFFECT_USER || f?.schedule ? R.C.enqueue(R.Re, runEffect.bind(null, R)) : runEffect(R));
 }
 
 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?._;
+    const f = e !== undefined ? e : this.o?._;
     if (E & STATUS_ERROR) {
         this.C.notify(this, STATUS_PENDING, 0);
         if (this.Re === EFFECT_USER) {
@@ -40,11 +40,11 @@ function notifyEffectStatus(t, e) {
             return;
         }
         if (!this.C.notify(this, STATUS_ERROR, STATUS_ERROR)) {
-            haltReactivity(unwrapStatusError(R));
-            throw R;
+            haltReactivity(unwrapStatusError(f));
+            throw f;
         }
     } else if (this.Re === EFFECT_RENDER) {
-        this.C.notify(this, STATUS_PENDING | STATUS_ERROR, E, R);
+        this.C.notify(this, STATUS_PENDING | STATUS_ERROR, E, f);
     }
 }
 
@@ -62,7 +62,7 @@ function runEffect(t) {
     // same flush must not be hijacked by a later-arriving error status.
         if (t.S & STATUS_ERROR && t.Re === EFFECT_USER) {
         const e = unwrapStatusError(t.o?._);
-        t.Tt = t.be;
+        t.dt = t.be;
         t.Xe = false;
         try {
             t.St ? t.St(e, () => {
@@ -82,7 +82,7 @@ function runEffect(t) {
     t.At = undefined;
     try {
         e?.();
-        const E = t.dt(t.be, t.Tt);
+        const E = t.Tt(t.be, t.dt);
         if (false && E !== undefined && typeof E !== "function") ;
         // The final cleanup is invoked by disposeChildren at true disposal.
                 t.At = E;
@@ -94,7 +94,7 @@ function runEffect(t) {
             throw e;
         }
     } finally {
-        t.Tt = t.be;
+        t.dt = t.be;
         t.Xe = false;
     }
 }
@@ -117,8 +117,8 @@ GlobalQueue.tt = runEffect;
         const e = E.At;
         E.At = undefined;
         e?.();
-        const R = staleValues(t);
-        E.At = R;
+        const f = staleValues(t);
+        E.At = f;
     }, {
         ...e,
         lazy: true
@@ -127,19 +127,16 @@ GlobalQueue.tt = runEffect;
     E.T = E.T & ~CONFIG_AUTO_DISPOSE | CONFIG_CHILDREN_FORBIDDEN;
     E.Xe = true;
     E.Re = EFFECT_TRACKED;
-    ext(E).A = (t, e) => {
-        const R = t !== undefined ? t : E.S;
-        if (R & STATUS_ERROR) {
-            E.C.notify(E, STATUS_PENDING, 0);
-            const t = e !== undefined ? e : E.o?._;
-            if (!E.C.notify(E, STATUS_ERROR, STATUS_ERROR)) {
-                haltReactivity(unwrapStatusError(t));
-                throw t;
-            }
-        }
-    };
-    E.Ut = run;
+    // 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.Ut = run;
     E.C.enqueue(EFFECT_USER, run);
 }
 
+// Install the shared effect status notifier (statusNotifierOf serves it to
+// every effect node) — module-scope: any bundle that creates effects
+// evaluates this module.
+setEffectStatusNotify(notifyEffectStatus);
+
 export { effect, trackedEffect };

package/dist/prod/core/external.js

@@ -46,11 +46,11 @@ function wireExternalSource(e) {
         equals: false,
         ownedWrite: true
     });
-    const r = externalSourceConfig.factory(e.Se, () => {
+    const r = externalSourceConfig.factory(e.oe, () => {
         setSignal(n, undefined);
     });
     cleanup(() => r.dispose());
-    e.Se = e => {
+    e.oe = e => {
         read(n);
         return r.track(e);
     };