@solidjs/signals 2.0.0-rc.5 → 2.0.0-rc.6

package/dist/prod/core/optimistic.js

@@ -24,8 +24,8 @@ import { GlobalQueue, activeTransition, globalQueue, clock, insertSubs, schedule
  * once the gate holds — the same late-binding contract as verdict.ts.
  */
 /** The optimistic half of setSignal, fired when `_overrideValue !== undefined`. */ function optimisticWrite(e, n) {
-    const t = e.o?.Oe !== NOT_PENDING;
-    const i = t ? unwrapOverride(e.o?.Oe) : e.be;
+    const t = e.o?.Pe !== NOT_PENDING;
+    const i = t ? unwrapOverride(e.o?.Pe) : e.be;
     if (typeof n === "function") n = n(i);
     const u = !!(e.S & STATUS_UNINITIALIZED) || 
     // A dirty node's _value is stale (its queued recompute hasn't run — e.g.
@@ -34,7 +34,7 @@ import { GlobalQueue, activeTransition, globalQueue, clock, insertSubs, schedule
     // push returning the shadow to that stale value was dropped, the snap
     // recompute then committed the parent's old value, and the banner showed
     // the previous transition's target (#3041 follow-up).
-    !!((e.ie ?? 0) & (REACTIVE_DIRTY | REACTIVE_CHECK)) || !e.ge || !e.ge(i, n);
+    !!((e.ie ?? 0) & (REACTIVE_DIRTY | REACTIVE_CHECK)) || !e.pe || !e.pe(i, n);
     if (!u) {
         // Same-value write with an active override still entangles the current
         // action's transition — the hold must outlast all overlapping actions.
@@ -59,10 +59,10 @@ import { GlobalQueue, activeTransition, globalQueue, clock, insertSubs, schedule
     // Literal undefined must not land raw: the slot doubles as the optimistic
     // brand, and erasing it makes the write invisible and routes follow-up
     // writes off the optimistic path into permanent commits (#2898).
-        ext(e).Oe = n === undefined ? OVERRIDE_UNDEFINED : n;
+        ext(e).Pe = n === undefined ? OVERRIDE_UNDEFINED : n;
     // syncCompanions only pokes _pendingSignal/_latestValueComputed — with
     // neither companion present the call is a guaranteed no-op.
-        (e.o?.ye !== undefined || e.o?.Ce !== undefined) && GlobalQueue.Re !== null && GlobalQueue.Re(e, n);
+        (e.o?.ye !== undefined || e.o?.Ce !== undefined) && GlobalQueue.Ue !== null && GlobalQueue.Ue(e, n);
     if (e.oe !== undefined) e.Te = clock;
  // §12e: computed-only slot
         insertSubs(e, true);
@@ -96,8 +96,8 @@ function resolveOptimisticNodes(e) {
         // override-covered authoritative values hold in _pendingValue and
         // elevate on their OWN transition's schedule (A18 as re-ruled 2026-07-07).
                 if (!(n.S & STATUS_PENDING)) n.S &= ~STATUS_UNINITIALIZED;
-        const i = n.o?.Oe;
-        ext(n).Oe = NOT_PENDING;
+        const i = n.o?.Pe;
+        ext(n).Pe = NOT_PENDING;
         if (i !== NOT_PENDING && n.be !== unwrapOverride(i)) insertSubs(n, true);
         n.Ae = null;
         if (n.o !== null) n.o.Nt = null;
@@ -122,7 +122,7 @@ function runQueue(e, n) {
  * Run effects from all lanes that are ready (no pending async).
  */ function runLaneEffects(e) {
     for (const n of activeLanes) {
-        if (n.rn || n.De.size > 0) continue;
+        if (n.rn || n.Oe.size > 0) continue;
         const t = n.tn[e - 1];
         if (t.length) {
             n.tn[e - 1] = [];
@@ -143,7 +143,7 @@ function cleanupCompletedLanes(e) {
             if (n.tn[1].length) runQueue(n.tn[1], EFFECT_USER);
         }
         if (n.nn.o?.Je === n) if (n.nn.o !== null) n.nn.o.Je = undefined;
-        n.De.clear();
+        n.Oe.clear();
         n.tn[0].length = 0;
         n.tn[1].length = 0;
         activeLanes.delete(n);
@@ -165,7 +165,7 @@ function cleanupCompletedLanes(e) {
  * that reads a pending mid-transition write sees the committed value; the sub
  * is recorded for replay at commit.
  */ function gatedRead(e, n, t) {
-    if (latestReadActive || e.Pe === NOT_PENDING || e.oe || n !== e && !(n.ie & REACTIVE_MANUAL_WRITE)) {
+    if (latestReadActive || e.Re === NOT_PENDING || e.oe || n !== e && !(n.ie & REACTIVE_MANUAL_WRITE)) {
         return false;
     }
     activeTransition.cn.add(t);
@@ -176,7 +176,7 @@ function cleanupCompletedLanes(e) {
  * read()'s value selection under a lane: return the committed `_value` for
  * optimistic/lane-assigned signals, stale-mode reads, and pending owners.
  */ function laneReadsCommitted(e, n, t) {
-    if (e.o?.Oe !== undefined || !!e.o?.Je || !!(n.S & STATUS_PENDING)) {
+    if (e.o?.Pe !== undefined || !!e.o?.Je || !!(n.S & STATUS_PENDING)) {
         // The committed view hides a staged in-flight value that will promote
         // silently (commitPendingNode never re-notifies). gatedRead records plain
         // signals for replay at commit; async memos are excluded from it by the
@@ -185,7 +185,7 @@ function cleanupCompletedLanes(e) {
         // committed value to a reader that never re-ran after the landing, so a
         // pending-gated branch stayed one value behind permanently (#3041
         // follow-up). Record the reader under the same replay contract.
-        if (e.Pe !== NOT_PENDING) (activeTransition ?? globalQueue.m).cn.add(t);
+        if (e.Re !== NOT_PENDING) (activeTransition ?? globalQueue.m).cn.add(t);
         return true;
     }
     if (n === e && stale && t.o?.Tt !== e) {
@@ -200,7 +200,7 @@ function cleanupCompletedLanes(e) {
         // into the transaction (#3041 follow-up: a pending-gated branch that
         // first read its async source during the landing flush stayed one value
         // behind permanently); with none, into the ambient batch.
-        if (e.Pe !== NOT_PENDING) (activeTransition ?? globalQueue.m).cn.add(t);
+        if (e.Re !== NOT_PENDING) (activeTransition ?? globalQueue.m).cn.add(t);
         return true;
     }
     return false;
@@ -223,7 +223,7 @@ function cleanupCompletedLanes(e) {
         // recompute() runs plain: the value stages and commits with the flush.
         // (el's own override slot excludes companions themselves; a lane merged
         // into a real optimistic lane resolves to a non-companion source.)
-                if (!globalQueue.fn && !activeTransition && !n.Ae && n.nn.o?.Tt !== undefined && e.o?.Oe === undefined) {
+                if (!globalQueue.fn && !activeTransition && !n.Ae && n.nn.o?.Tt !== undefined && e.o?.Pe === undefined) {
             if (e.o !== null) e.o.Je = undefined;
             return false;
         }
@@ -246,7 +246,7 @@ function cleanupCompletedLanes(e) {
 /** recompute()'s catch path: track pending async in the current lane. */ function laneAsyncPending(e) {
     const n = findLane(currentOptimisticLane);
     if (n.nn !== e) {
-        n.De.add(e);
+        n.Oe.add(e);
         ext(e).Je = n;
         e.T |= CONFIG_HAS_LANE;
         GlobalQueue.de !== null && GlobalQueue.de(n.nn);
@@ -256,7 +256,7 @@ function cleanupCompletedLanes(e) {
 /** recompute()'s success path: the node's async settled, clear it from its lane. */ function laneAsyncSettled(e) {
     const n = resolveLane(e);
     if (n) {
-        n.De.delete(e);
+        n.Oe.delete(e);
         GlobalQueue.de !== null && GlobalQueue.de(n.nn);
     }
 }

package/dist/prod/core/owner.js

@@ -107,7 +107,7 @@ function disposeChildren(e, t = false, n) {
 }
 
 function runDisposal(e, t) {
-    let n = t ? e.o?.qe : e.pe;
+    let n = t ? e.o?.qe : e.Ge;
     if (!n) return;
     if (Array.isArray(n)) {
         for (let e = 0; e < n.length; e++) {
@@ -119,7 +119,7 @@ function runDisposal(e, t) {
     }
     if (t) {
         if (e.o !== null) e.o.qe = null;
-    } else e.pe = null;
+    } else e.Ge = null;
 }
 
 function childId(e, t) {
@@ -206,7 +206,7 @@ function formatId(e, t) {
  * checks. `cleanup()` is the unchecked primitive used by internals.
  */ function cleanup(e) {
     if (!context) return e;
-    if (!context.pe) context.pe = e; else if (Array.isArray(context.pe)) context.pe.push(e); else context.pe = [ context.pe, e ];
+    if (!context.Ge) context.Ge = e; else if (Array.isArray(context.Ge)) context.Ge.push(e); else context.Ge = [ context.Ge, e ];
     return e;
 }
 
@@ -251,7 +251,7 @@ function disposeRootSelf(e = true) {
         xe: null,
         Le: null,
         ft: null,
-        pe: null,
+        Ge: null,
         C: t?.C ?? globalQueue,
         we: t?.we || defaultContext,
         Ze: 0,

package/dist/prod/core/scheduler.js

@@ -73,8 +73,8 @@ function sweepTransientStoreNodes() {
             transientStoreNodes.delete(e);
             continue;
         }
-        if (e.Pe !== NOT_PENDING) continue;
-        if (e.o?.Oe !== undefined && e.o?.Oe !== NOT_PENDING) continue;
+        if (e.Re !== NOT_PENDING) continue;
+        if (e.o?.Pe !== undefined && e.o?.Pe !== NOT_PENDING) continue;
         // A live affects() mark keeps the node addressable: sweeping it would
         // detach the refcount from the slot (a fresh probe would upsert a new,
         // unmarked node for the same property).
@@ -202,9 +202,9 @@ function mergeTransitionState(e, t) {
     // reporter deadlocked exactly that way).
         let i = false;
     for (let n = e.ut; n !== null; n = n.lt) {
-        const s = n.ot;
-        if (s.Pe !== NOT_PENDING) {
-            const e = s.Ae;
+        const r = n.ot;
+        if (r.Re !== NOT_PENDING) {
+            const e = r.Ae;
             const n = e != null ? currentTransition(e) : null;
             // Skip the awaiting transaction's own cargo (t === target: a
             // fold-staged landing or a write the action itself issued — hold and
@@ -212,8 +212,8 @@ function mergeTransitionState(e, t) {
             // (t === null) must leave the batch NOW — it commits at this flush's
             // end, which would reveal the confirmation under the live optimism
             // it just confirmed.
-                        const r = n === null ? currentBatch.Lt : n !== t && n.sn !== true ? n.Lt : null;
-            if (r !== null) i = stealEntangledCargo(r, t) || i;
+                        const s = n === null ? currentBatch.Lt : n !== t && n.sn !== true ? n.Lt : null;
+            if (s !== null) i = stealEntangledCargo(s, t) || i;
         }
         if (n === e.je) break;
     }
@@ -257,7 +257,7 @@ function mergeTransitionState(e, t) {
             n.T |= CONFIG_HELD_TRUTH;
             for (let e = n.u; e !== null; e = e.ae) {
                 const t = e.ce;
-                if (t.he && !(t.T & CONFIG_AUTHORITATIVE_READ)) enqueueSub(t);
+                if (t.ge && !(t.T & CONFIG_AUTHORITATIVE_READ)) enqueueSub(t);
             }
         }
     }
@@ -343,11 +343,11 @@ class Queue {
                 const t = this.Qt;
         const i = ++queueRunToken;
         for (let n = 0; n < t.length; ) {
-            const s = t[n];
-            if (s.jt !== i) {
-                s.jt = i;
-                s.run?.(e);
-                if (t[n] !== s) {
+            const r = t[n];
+            if (r.jt !== i) {
+                r.jt = i;
+                r.run?.(e);
+                if (t[n] !== r) {
                     n = 0;
                     continue;
                 }
@@ -425,7 +425,7 @@ class GlobalQueue extends Queue {
     // there: `_pendingSignal`/`_latestValueComputed` are only ever assigned by
     // verdict.ts, and `pendingCheckActive`/`latestReadActive` only flip inside
     // isPending()/latest()).
-    static Re=null;
+    static Ue=null;
     static de=null;
     static me=null;
     static un=null;
@@ -462,7 +462,7 @@ class GlobalQueue extends Queue {
     /** Authoritative-view reader wakeup (until()): installed at first until() call.
      * Call sites are gated by CONFIG_AUTHORITATIVE_OBSERVED, which only until()'s
      * carve-out read can set, so `!` invocations are safe once the gate holds. */
-    static Ue=null;
+    static he=null;
     static Xe=null;
     static _n=null;
     flush() {
@@ -591,9 +591,9 @@ class GlobalQueue extends Queue {
                     const i = t.source;
                     let n = activeTransition._e.get(i);
                     if (!n) activeTransition._e.set(i, n = new Set);
-                    const s = n.size;
+                    const r = n.size;
                     n.add(e);
-                    if (n.size !== s) {
+                    if (n.size !== r) {
                         schedule();
                         GlobalQueue.zt?.(activeTransition);
                     }
@@ -704,13 +704,13 @@ function insertSubs(e, t = false) {
     // stays authoritative when a bit is set.
         const i = e.T;
     const n = (i & CONFIG_HAS_LANE ? e.o?.Je : undefined) || currentOptimisticLane;
-    const s = (i & CONFIG_HAS_SNAPSHOT) !== 0 && e.o?.We !== undefined;
-    const r = reaskArmed;
+    const r = (i & CONFIG_HAS_SNAPSHOT) !== 0 && e.o?.We !== undefined;
+    const s = reaskArmed;
     for (let i = e.u; i !== null; i = i.ae) {
         const e = i.ce;
         // A value-change notification is a new question for the subscriber: any
         // pending re-ask mark (refresh) it carried is superseded.
-                if (r) e.ie &= ~REACTIVE_REASK;
+                if (s) e.ie &= ~REACTIVE_REASK;
         // Missed-wake latch (#3037): this write is landing while the subscriber
         // is mid-recompute (a nested pull committing beneath its reads), and the
         // heap refuses RECOMPUTING nodes. A gen-current link means the pass
@@ -720,7 +720,7 @@ function insertSubs(e, t = false) {
         // tail link: it is the read IN FLIGHT — read() links before it pulls, so
         // this very commit is what that read returns.
                 if (e.ie & REACTIVE_RECOMPUTING_DEPS && i.Ft === e.Ke && i !== e.je) e.ie |= REACTIVE_MISSED_WAKE;
-        if (s && e.T & CONFIG_IN_SNAPSHOT_SCOPE) {
+        if (r && e.T & CONFIG_IN_SNAPSHOT_SCOPE) {
             e.ie |= REACTIVE_SNAPSHOT_STALE;
             continue;
         }
@@ -739,18 +739,24 @@ function insertSubs(e, t = false) {
 function commitPendingNode(e) {
     const t = e;
     if (!t.oe) {
-        if (e.Pe !== NOT_PENDING) {
-            e.be = e.Pe;
-            e.Pe = NOT_PENDING;
+        if (e.Re !== NOT_PENDING) {
+            e.be = e.Re;
+            e.Re = NOT_PENDING;
         }
         if (e.T & CONFIG_HAS_COMPANIONS) GlobalQueue.un(e);
         return;
     }
-    if (e.Pe !== NOT_PENDING) {
-        e.be = e.Pe;
-        e.Pe = NOT_PENDING;
+    if (e.Re !== NOT_PENDING) {
+        e.be = e.Re;
+        e.Re = NOT_PENDING;
         // Set _modified for effects, but not for tracked effects (they handle their own scheduling)
-                if (e.he && e.he !== EFFECT_TRACKED) e.tt = true;
+                if (e.ge && e.ge !== EFFECT_TRACKED) e.tt = true;
+        // A quiet re-ask classification preserved through a held landing dies
+        // with the value commit — the commit IS the reveal (#3178). Gated on the
+        // staged value: status propagation queues pending nodes whose windows
+        // are still OPEN (no staged value), and their live classification must
+        // survive this sweep.
+                if (e.o) e.o.De = false;
     }
     // The committed hold is the first observable answer for a loading-window
     // node — the window closes here, not at compute time (#2990). Unconditional
@@ -971,15 +977,15 @@ function transitionComplete(e) {
     if (e.ue.length) return false;
     let t = true;
     for (const [i, n] of e._e) {
-        let s = false;
+        let r = false;
         for (const e of n) {
             if (reporterBlocksSource(e, i)) {
-                s = true;
+                r = true;
                 break;
             }
             n.delete(e);
         }
-        if (!s) e._e.delete(i); else if (i.S & STATUS_PENDING && i.o?._?.source === i) {
+        if (!r) e._e.delete(i); else if (i.S & STATUS_PENDING && i.o?._?.source === i) {
             t = false;
             break;
         }
@@ -992,6 +998,13 @@ function transitionComplete(e) {
     return t;
 }
 
+/** A fresh, unentered transaction (#3146): the optimistic store's truth
+ * flight DECLARES an owned transaction instead of relying on whatever the
+ * ambient adoption machinery stamped on its firewall. Activate it with
+ * initTransition; it is a plain batch until then. */ function createTransition() {
+    return createBatch();
+}
+
 function currentTransition(e) {
     while (e.sn && typeof e.sn === "object") e = e.sn;
     return e;
@@ -1030,4 +1043,4 @@ function runInTransition(e, t) {
     }
 }
 
-export { GlobalQueue, Queue, activeAffectsMarks, activeLanes, activeTransition, armReaskClear, assignOrMergeLane, bumpNotifyEpoch, clock, currentTransition, dirtyQueue, enforceLoadingBoundary, entangleConfirmingTransitions, finalizePureQueue, findLane, flush, globalQueue, haltReactivity, hasActiveOverride, insertSubs, notifyEpoch, patchCommitHook, projectionWriteActive, queuePendingNode, reaskArmed, resetErrorHalt, runAsTransitionBatch, runInTransition, schedule, setPatchCommitHook, setProjectionWriteActive, setStoreCommitHook, shiftAffectsMarks, storeCommitHook, zombieQueue };
+export { GlobalQueue, Queue, activeAffectsMarks, activeLanes, activeTransition, armReaskClear, assignOrMergeLane, bumpNotifyEpoch, clock, createTransition, currentTransition, dirtyQueue, enforceLoadingBoundary, entangleConfirmingTransitions, finalizePureQueue, findLane, flush, globalQueue, haltReactivity, hasActiveOverride, insertSubs, notifyEpoch, patchCommitHook, projectionWriteActive, queuePendingNode, reaskArmed, resetErrorHalt, runAsTransitionBatch, runInTransition, schedule, setPatchCommitHook, setProjectionWriteActive, setStoreCommitHook, shiftAffectsMarks, storeCommitHook, zombieQueue };

package/dist/prod/core/verdict.js

@@ -128,10 +128,10 @@ function collectPendingSources(e) {
 
 function quietPending(e) {
     if (e.o?.le) {
-        for (const t of e.o.le) if (!t.o?.Ge) return false;
+        for (const t of e.o.le) if (!t.o?.De) return false;
         return true;
     }
-    return e.o?.Ge ?? false;
+    return e.o?.De ?? false;
 }
 
 // NOTE: a loadingValue node's open loading window (_loading) is verdict-quiet
@@ -158,16 +158,20 @@ function computePendingState(e) {
         const n = t.st || t;
         return newQuestionInFlight(n);
     }
-    if (n && e.Pe !== NOT_PENDING && !hasActiveOverride(e)) {
+    if (n && e.Re !== NOT_PENDING && !hasActiveOverride(e)) {
         return !!(n.ie & REACTIVE_MANUAL_WRITE) || !n.o?.Ie && !(n.S & STATUS_PENDING) || !!(n.S & STATUS_PENDING) && quietPending(n);
     }
     // `!comp._loading`: a hold created while the loading window is still open is
     // the window's own landing in flight to its commit — verdict-quiet like the
     // rest of the window (the UNINITIALIZED check suppresses exactly this frame
     // for windowless first loads; born-committed nodes need their own gate, #2990).
-        if (e.Pe !== NOT_PENDING && !(t.S & STATUS_UNINITIALIZED) && !t.Ne) {
-        if (hasActiveOverride(e)) return !e.ge || !e.ge(e.Pe, unwrapOverride(e.o?.Oe));
-        return true;
+        if (e.Re !== NOT_PENDING && !(t.S & STATUS_UNINITIALIZED) && !t.Ne) {
+        if (hasActiveOverride(e)) return !e.pe || !e.pe(e.Re, unwrapOverride(e.o?.Pe));
+        // A quiet re-ask's held landing still answers the same question: the
+        // classification survives the landing (asyncWrite) and dies with the
+        // commit (commitPendingNode) — verdict-quiet through the reveal, like
+        // the loading window above (#3178).
+                if (!t.o?.De) return true;
     }
     return newQuestionInFlight(t);
 }
@@ -250,18 +254,18 @@ function updateChildCompanions(e) {
 function snapCompanionsToState(e) {
     suppressedProbes.size !== 0 && suppressedProbes.delete(e);
     const t = e.o?.ye;
-    if (t && (t.o?.Oe === undefined || t.o?.Oe === NOT_PENDING)) {
+    if (t && (t.o?.Pe === undefined || t.o?.Pe === NOT_PENDING)) {
         const n = computePendingState(e);
-        if (t.be !== n || t.Pe !== NOT_PENDING) {
+        if (t.be !== n || t.Re !== NOT_PENDING) {
             t.be = n;
-            t.Pe = NOT_PENDING;
+            t.Re = NOT_PENDING;
             insertSubs(t);
             schedule();
         }
     }
     const n = e.o?.Ce;
     if (n && !(n.ie & REACTIVE_DISPOSED)) {
-        if ((n.o?.Oe === undefined || n.o?.Oe === NOT_PENDING) && n.Pe === NOT_PENDING && !Object.is(n.be, e.be) && !(n.ie & (REACTIVE_DIRTY | REACTIVE_CHECK))) {
+        if ((n.o?.Pe === undefined || n.o?.Pe === NOT_PENDING) && n.Re === NOT_PENDING && !Object.is(n.be, e.be) && !(n.ie & (REACTIVE_DIRTY | REACTIVE_CHECK))) {
             n.ie |= REACTIVE_DIRTY;
             insertIntoHeap(n, queueFor(n));
             insertSubs(n);
@@ -298,7 +302,7 @@ function getLatestValueComputed(e) {
         // created lazily, possibly after the write was processed — syncCompanions
         // only pushes into companions that already exist, so the first latest()
         // read inside a held transition showed the committed value (#3041).
-                if (e.Pe !== NOT_PENDING && !hasActiveOverride(e)) setSignal(t, e.Pe);
+                if (e.Re !== NOT_PENDING && !hasActiveOverride(e)) setSignal(t, e.Re);
         setContextInternal(r);
         setPendingCheckActive(i);
         setLatestReadActive(n);
@@ -310,7 +314,7 @@ function getLatestValueComputed(e) {
     const t = getLatestValueComputed(e);
     const n = latestReadActive;
     setLatestReadActive(false);
-    const i = e.o?.Oe !== undefined && e.o?.Oe !== NOT_PENDING ? unwrapOverride(e.o?.Oe) : e.be;
+    const i = e.o?.Pe !== undefined && e.o?.Pe !== NOT_PENDING ? unwrapOverride(e.o?.Pe) : e.be;
     let r;
     try {
         // An untracked latest() read has no reading context, so read() never
@@ -349,7 +353,7 @@ function getLatestValueComputed(e) {
     if (stale && currentOptimisticLane && t.o?.Je) {
         const e = findLane(t.o?.Je);
         const n = findLane(currentOptimisticLane);
-        if (e !== n && e.De.size > 0) {
+        if (e !== n && e.Oe.size > 0) {
             return i;
         }
     }
@@ -357,7 +361,7 @@ function getLatestValueComputed(e) {
     // speculative value in _pendingValue; a contextless read() only surfaces
     // _value. Overrides stay authoritative (A17), and stale readers keep the
     // other transition's committed view, matching read()'s own selection.
-        if (t.Pe !== NOT_PENDING && !hasActiveOverride(t) && !(stale && t.Ae && activeTransition !== t.Ae)) return t.Pe;
+        if (t.Re !== NOT_PENDING && !hasActiveOverride(t) && !(stale && t.Ae && activeTransition !== t.Ae)) return t.Re;
     return r;
 }
 
@@ -433,7 +437,7 @@ function getLatestValueComputed(e) {
 }
 
 function recordFreshRead(e, t) {
-    if (pendingProbe !== null && e.Pe !== NOT_PENDING && t === e.Pe) {
+    if (pendingProbe !== null && e.Re !== NOT_PENDING && t === e.Re) {
         if (heldAwaitingAsync(e)) return;
         pendingProbe.freshReads.add(e);
     }
@@ -441,10 +445,10 @@ function recordFreshRead(e, t) {
 
 function applyReask(e, t) {
     const n = !!(e.S & STATUS_PENDING);
-    const i = t && !(n && !e.o?.Ge);
-    const r = n && (e.o?.Ge ?? false) !== i;
+    const i = t && !(n && !e.o?.De);
+    const r = n && (e.o?.De ?? false) !== i;
     // Allocation-free for the quiet case: false is the extension default.
-        if (i) ext(e).Ge = true; else if (e.o !== null) e.o.Ge = false;
+        if (i) ext(e).De = true; else if (e.o !== null) e.o.De = false;
     return r;
 }
 
@@ -525,7 +529,7 @@ function isPending(e) {
 // Hook installation (same late-binding pattern as GlobalQueue._update /
 // _propagateAffects): core call sites fire these behind the same guards the
 // direct calls used, so behavior is identical once this module loads.
-GlobalQueue.Re = syncCompanions;
+GlobalQueue.Ue = syncCompanions;
 
 GlobalQueue.de = updatePendingSignal;
 

package/dist/prod/signals.js

@@ -78,7 +78,74 @@ function createMemo(e, t) {
     return accessor(computed(e, t));
 }
 
-function createEffect(e, t, n) {
+/**
+ * Creates a reactive effect with **separate compute and effect phases**.
+ *
+ * - `compute(prev)` runs reactively — *put all reactive reads here*. The
+ *   returned value is passed to `effect` and is also the new "previous" value
+ *   for the next run.
+ * - `effect(next, prev?)` runs imperatively (untracked) after the queue
+ *   flushes. *Put DOM writes / fetch / logging / subscriptions here.* It may
+ *   return a cleanup function which runs before the next effect or on
+ *   disposal.
+ *
+ * Reactive reads inside `effect` will *not* re-trigger this effect — that's
+ * intentional. If you need a single-phase tracked effect, use
+ * `createTrackedEffect` (with the tradeoffs noted there).
+ *
+ * Pass an `EffectBundle` (`{ effect, error }`) instead of a plain function to
+ * intercept **compute-phase** errors — errors thrown by `compute` or arriving
+ * from upstream reactive sources (including async rejections), which your own
+ * code has no frame to `try/catch`. The `error` handler is the error arm of
+ * the effect phase: it runs on the same schedule and in the same imperative,
+ * writable scope as `effect` (setting error state via signals is fine), and
+ * only for *settled* errors — a transient error that recovers before the
+ * effect phase runs `effect` with the recovered value instead, and a held
+ * transition defers it exactly as it defers `effect`. Without an `error`
+ * handler a compute-phase error is logged and the effect simply skips that
+ * run — a non-render effect's reactivity failing does not crash the app.
+ * Rethrowing from `error` escalates it to the nearest error boundary
+ * (halting the system if none exists).
+ *
+ * The **effect phase is different**: it is your own imperative code, so handle
+ * failures with `try/catch` where they occur. An uncaught effect-phase throw
+ * is treated as an unhandled application error — caught by the nearest
+ * `createErrorBoundary`/`<Errored>`, and permanently halting the reactive
+ * system if there is none. It is *not* routed to the bundle's `error` handler.
+ *
+ * ```typescript
+ * createEffect<T>(compute, effectFn | { effect, error }, options?: EffectOptions);
+ * ```
+ * @param compute a function that receives its previous value and returns a new value used to react on a computation
+ * @param effectFn a function that receives the new value and is used to perform side effects (return a cleanup function), or an `EffectBundle` with `effect` and `error` handlers
+ * @param options `EffectOptions` -- name, defer, schedule, transparent
+ *
+ * @example
+ * ```ts
+ * const [count, setCount] = createSignal(0);
+ *
+ * createEffect(
+ *   () => count(),                  // compute: tracks `count`
+ *   value => console.log(value)     // effect: side effect
+ * );
+ *
+ * setCount(1); // logs 1 after the next flush
+ * ```
+ *
+ * @example
+ * ```ts
+ * createEffect(
+ *   () => userId(),
+ *   id => {
+ *     const ctrl = new AbortController();
+ *     fetch(`/users/${id}`, { signal: ctrl.signal });
+ *     return () => ctrl.abort(); // cleanup before next run / disposal
+ *   }
+ * );
+ * ```
+ *
+ * @description https://docs.solidjs.com/reference/basic-reactivity/create-effect
+ */ function createEffect(e, t, n) {
     effect(e, t.effect || t, t.error, {
         user: true,
         ...n