@solidjs/signals 2.0.0-beta.26 → 2.0.0-beta.27

package/dist/prod/core/owner.js

@@ -51,7 +51,7 @@ function disposeChildren(e, n = false, t) {
         // edge). Snap runs after the DISPOSED flag is set so the oracle reads
         // false, and notifies subscribers still watching the companion.
                 const n = e;
-        if (n.he || n.Ge) GlobalQueue.un(n);
+        if (n.he || n.pe) GlobalQueue.un(n);
     }
     if (n && e.ae) e.Te = null;
     let l = t ? e.Qe : e.ke;

package/dist/prod/core/scheduler.js

@@ -66,7 +66,7 @@ function sweepTransientStoreNodes() {
             transientStoreNodes.delete(e);
             continue;
         }
-        if (e._e !== NOT_PENDING) continue;
+        if (e.De !== NOT_PENDING) continue;
         if (e.Ae !== undefined && e.Ae !== 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,
@@ -179,10 +179,15 @@ function notifyHalted() {
     haltNotified = false;
 }
 
+// Identifies one child-traversal pass in `Queue.run` so a rescan after the
+// child list shifts can tell "already run this pass" from "still pending".
+let queueRunToken = 0;
+
 class Queue {
     ve=null;
     gt=[ [], [] ];
     vt=[];
+    kt=0;
     created=clock;
     addChild(e) {
         this.vt.push(e);
@@ -205,7 +210,27 @@ class Queue {
             this.gt[e - 1] = [];
             runQueue(t, e);
         }
-        for (let t = 0; t < this.vt.length; t++) this.vt[t].run?.(e);
+        // Effects run here can dispose owners, and disposal removes queues from
+        // this list — the running child itself, an earlier sibling, or several at
+        // once. A plain index walk then skips whatever shifted into the cursor.
+        // Stamping each child before it runs makes the pass idempotent, so a shift
+        // can be recovered by rescanning from the front and every child still runs
+        // exactly once. Children appended mid-pass carry a stale stamp and run,
+        // matching the previous live-array behaviour.
+                const t = this.vt;
+        const i = ++queueRunToken;
+        for (let n = 0; n < t.length; ) {
+            const s = t[n];
+            if (s.kt !== i) {
+                s.kt = i;
+                s.run?.(e);
+                if (t[n] !== s) {
+                    n = 0;
+                    continue;
+                }
+            }
+            n++;
+        }
     }
     enqueue(e, t) {
         if (e) {
@@ -252,10 +277,10 @@ class GlobalQueue extends Queue {
     // The current transaction-shaped batch: a plain ambient batch while no
     // transition is active, the active transition itself after initTransition.
     m=createBatch();
-    static pe;
     static Ce;
+    static me;
     static Xe;
-    static kt=null;
+    static Dt=null;
     // Store-side hook: drops a keyless affects() mark's identity scope when the
     // carrier node's last registration releases (wired by store.ts, mirroring
     // _clearOptimisticStore).
@@ -269,24 +294,24 @@ class GlobalQueue extends Queue {
     static h=null;
     // External-source bridge (wired by enableExternalSource(); null while no
     // config is active — including after _resetExternalSourceConfig()).
-    static It=null;
     static dt=null;
+    static It=null;
     // Verdict-layer hooks (wired by verdict.ts when isPending()/latest() are
     // imported; null in apps that never use them). Call sites either guard for
     // null or sit behind state only the verdict layer can create (`!` is safe
     // there: `_pendingSignal`/`_latestValueComputed` are only ever assigned by
     // verdict.ts, and `pendingCheckActive`/`latestReadActive` only flip inside
     // isPending()/latest()).
-    static De=null;
+    static _e=null;
     static ce=null;
-    static Oe=null;
+    static Ge=null;
     static un=null;
     static St=null;
     static At=null;
     static Pt=null;
     static $e=null;
     static k=null;
-    static Dt=null;
+    static Lt=null;
     // Optimistic-engine hooks (wired by core/optimistic.ts via
     // installOptimisticEngine(), called from verdict.ts / createOptimistic /
     // createOptimisticStore — every module that can create optimistic state).
@@ -311,12 +336,12 @@ class GlobalQueue extends Queue {
         this.bt = true;
         try {
             if (false) ;
-            runHeap(dirtyQueue, GlobalQueue.pe);
+            runHeap(dirtyQueue, GlobalQueue.Ce);
             if (activeTransition) {
                 const e = transitionComplete(activeTransition);
                 if (!e) {
                     const e = activeTransition;
-                    runHeap(zombieQueue, GlobalQueue.pe);
+                    runHeap(zombieQueue, GlobalQueue.Ce);
                     // Detach: the stashed transition keeps its batch; ambient work that
                     // follows lands in a fresh one. If the batch is already a separate
                     // ambient one — action done() restored activeTransition without
@@ -363,11 +388,11 @@ class GlobalQueue extends Queue {
                 if (canUseSimpleSyncFlush(this)) {
                     commitPendingNodes();
                     if (dirtyQueue.EE >= dirtyQueue.He) {
-                        runHeap(dirtyQueue, GlobalQueue.pe);
+                        runHeap(dirtyQueue, GlobalQueue.Ce);
                         commitPendingNodes();
                     }
                 } else {
-                    if (transitions.size) runHeap(zombieQueue, GlobalQueue.pe);
+                    if (transitions.size) runHeap(zombieQueue, GlobalQueue.Ce);
                     finalizePureQueue();
                 }
             }
@@ -494,23 +519,23 @@ function insertSubs(e, t = false) {
 function commitPendingNode(e) {
     const t = e;
     if (!t.ae) {
-        if (e._e !== NOT_PENDING) {
-            e.Ue = e._e;
-            e._e = NOT_PENDING;
+        if (e.De !== NOT_PENDING) {
+            e.Ue = e.De;
+            e.De = NOT_PENDING;
         }
-        if (e.he || e.Ge) GlobalQueue.un(e);
+        if (e.he || e.pe) GlobalQueue.un(e);
         return;
     }
-    if (e._e !== NOT_PENDING) {
-        e.Ue = e._e;
-        e._e = NOT_PENDING;
+    if (e.De !== NOT_PENDING) {
+        e.Ue = e.De;
+        e.De = NOT_PENDING;
         // Set _modified for effects, but not for tracked effects (they handle their own scheduling)
                 if (e.Pe && e.Pe !== EFFECT_TRACKED) e.Be = true;
     }
     t.se &= ~REACTIVE_MANUAL_WRITE;
     if (!(t.S & STATUS_PENDING)) t.S &= ~STATUS_UNINITIALIZED;
-    if (t.Qe !== null || t.ye !== null) GlobalQueue.Ce(t, false, true);
-    if (e.he || e.Ge) GlobalQueue.un(e);
+    if (t.Qe !== null || t.ye !== null) GlobalQueue.me(t, false, true);
+    if (e.he || e.pe) GlobalQueue.un(e);
 }
 
 function commitPendingNodes() {
@@ -528,7 +553,7 @@ function finalizePureQueue(e = null, t = false) {
     if (i) commitPendingNodes();
     if (!t && globalQueue.vt.length) checkBoundaryChildren(globalQueue);
     const n = dirtyQueue.EE >= dirtyQueue.He;
-    if (n) runHeap(dirtyQueue, GlobalQueue.pe);
+    if (n) runHeap(dirtyQueue, GlobalQueue.Ce);
     if (i) {
         if (n) commitPendingNodes();
         // The settling batch: the completing transaction's, or the ambient one.
@@ -559,7 +584,7 @@ function finalizePureQueue(e = null, t = false) {
         // hook; the hook iterates, clears, and schedules (keeping the loop out of
         // core lets esbuild shake it — rollup already folds the null guard). The
         // completing transition scopes the clear to its own layer keys (#2899).
-                if (t.cn.size) GlobalQueue.kt(t.cn, e);
+                if (t.cn.size) GlobalQueue.Dt(t.cn, e);
         sweepTransientStoreNodes();
         // Lanes only enter activeLanes through the engine's getOrCreateLane.
                 if (activeLanes.size) GlobalQueue.Tn(e);
@@ -665,10 +690,10 @@ function transitionComplete(e) {
             break;
         }
     }
-    // Override blockage lives with the engine. Absent hook = "no optimistic
-    // blockage", which is exact: only _optimisticWrite (engine) pushes to
-    // _optimisticNodes, so without the engine the loop was vacuous anyway.
-        if (t && e.je.length && GlobalQueue.dn(e)) t = false;
+    // Override blockage lives with the engine (absent hook = "no optimistic
+    // blockage"); the hook's loops over _optimisticNodes/_optimisticStores are
+    // no-ops when the transition holds neither, so no pre-check is needed.
+        if (t && GlobalQueue.dn?.(e)) t = false;
     t && (e.fn = true);
     return t;
 }
@@ -678,10 +703,6 @@ function currentTransition(e) {
     return e;
 }
 
-function setActiveTransition(e) {
-    activeTransition = e;
-}
-
 function runInTransition(e, t) {
     const i = activeTransition;
     try {
@@ -692,4 +713,4 @@ function runInTransition(e, t) {
     }
 }
 
-export { GlobalQueue, Queue, activeAffectsMarks, activeLanes, activeTransition, armReaskClear, assignOrMergeLane, clock, currentTransition, dirtyQueue, enforceLoadingBoundary, finalizePureQueue, findLane, flush, globalQueue, haltReactivity, insertSubs, projectionWriteActive, queuePendingNode, registerTransientStoreNode, resetErrorHalt, runInTransition, schedule, setActiveTransition, setProjectionWriteActive, shiftAffectsMarks, zombieQueue };
+export { GlobalQueue, Queue, activeAffectsMarks, activeLanes, activeTransition, armReaskClear, assignOrMergeLane, clock, currentTransition, dirtyQueue, enforceLoadingBoundary, finalizePureQueue, findLane, flush, globalQueue, haltReactivity, insertSubs, projectionWriteActive, queuePendingNode, registerTransientStoreNode, resetErrorHalt, runInTransition, schedule, setProjectionWriteActive, shiftAffectsMarks, zombieQueue };

package/dist/prod/core/verdict.js

@@ -89,7 +89,7 @@ function collectPendingSources(e) {
     const r = i.se & REACTIVE_RECOMPUTING_DEPS ? i.We : undefined;
     if (r !== null) {
         for (let e = i.et ?? null; e !== null; e = e.tt) {
-            if (!e.ge && markWalk(e.nt, t)) return true;
+            if (!e.Oe && markWalk(e.nt, t)) return true;
             if (e === r) break;
         }
     }
@@ -102,10 +102,10 @@ function collectPendingSources(e) {
 
 function quietPending(e) {
     if (e.oe) {
-        for (const t of e.oe) if (!t.be) return false;
+        for (const t of e.oe) if (!t.Re) return false;
         return true;
     }
-    return e.be;
+    return e.Re;
 }
 
 function newQuestionInFlight(e) {
@@ -125,11 +125,11 @@ function computePendingState(e) {
         const n = t.it || t;
         return newQuestionInFlight(n);
     }
-    if (n && e._e !== NOT_PENDING && !hasActiveOverride(e)) {
+    if (n && e.De !== NOT_PENDING && !hasActiveOverride(e)) {
         return !!(n.se & REACTIVE_MANUAL_WRITE) || !n.Te && !(n.S & STATUS_PENDING) || !!(n.S & STATUS_PENDING) && quietPending(n);
     }
-    if (e._e !== NOT_PENDING && !(t.S & STATUS_UNINITIALIZED)) {
-        if (hasActiveOverride(e)) return !e.Re || !e.Re(e._e, unwrapOverride(e.Ae));
+    if (e.De !== NOT_PENDING && !(t.S & STATUS_UNINITIALIZED)) {
+        if (hasActiveOverride(e)) return !e.be || !e.be(e.De, unwrapOverride(e.Ae));
         return true;
     }
     return newQuestionInFlight(t);
@@ -137,19 +137,19 @@ function computePendingState(e) {
 
 function syncCompanions(e, t) {
     if (e.he) updatePendingSignal(e);
-    if (e.Ge) setSignal(e.Ge, t);
+    if (e.pe) setSignal(e.pe, t);
 }
 
 function updatePendingSignal(e) {
     if (e.he) {
         setSignal(e.he, computePendingState(e));
     }
-    if (e.Ge) updatePendingSignal(e.Ge);
+    if (e.pe) updatePendingSignal(e.pe);
 }
 
 function updateChildCompanions(e) {
     for (let t = e.u; t !== null; t = t.fe) {
-        if (t.he || t.Ge) updatePendingSignal(t);
+        if (t.he || t.pe) updatePendingSignal(t);
     }
 }
 
@@ -167,7 +167,7 @@ function updateChildCompanions(e) {
     const visit = e => {
         if (i.has(e)) return;
         i.add(e);
-        if (e.he || e.Ge) n(e);
+        if (e.he || e.pe) n(e);
         for (let t = e.o; t !== null; t = t.ue) visit(t.le);
         for (let t = e.u ?? null; t !== null; t = t.fe) {
             visit(t);
@@ -180,17 +180,17 @@ function snapCompanionsToState(e) {
     const t = e.he;
     if (t && (t.Ae === undefined || t.Ae === NOT_PENDING)) {
         const n = computePendingState(e);
-        if (t.Ue !== n || t._e !== NOT_PENDING) {
+        if (t.Ue !== n || t.De !== NOT_PENDING) {
             t.Ue = n;
-            t._e = NOT_PENDING;
+            t.De = NOT_PENDING;
             t.Se = clock;
             insertSubs(t);
             schedule();
         }
     }
-    const n = e.Ge;
+    const n = e.pe;
     if (n && !(n.se & REACTIVE_DISPOSED)) {
-        if ((n.Ae === undefined || n.Ae === NOT_PENDING) && n._e === NOT_PENDING && !Object.is(n.Ue, e.Ue) && !(n.se & (REACTIVE_DIRTY | REACTIVE_CHECK))) {
+        if ((n.Ae === undefined || n.Ae === NOT_PENDING) && n.De === NOT_PENDING && !Object.is(n.Ue, e.Ue) && !(n.se & (REACTIVE_DIRTY | REACTIVE_CHECK))) {
             n.se |= REACTIVE_DIRTY;
             insertIntoHeap(n, queueFor(n));
             insertSubs(n);
@@ -201,7 +201,7 @@ function snapCompanionsToState(e) {
 }
 
 function getLatestValueComputed(e) {
-    if (!e.Ge) {
+    if (!e.pe) {
         const t = latestReadActive;
         setLatestReadActive(false);
         const n = pendingCheckActive;
@@ -209,14 +209,14 @@ function getLatestValueComputed(e) {
         const i = context;
         setContextInternal(null);
  // Detach from owner so it isn't disposed with effects
-                e.Ge = optimisticComputed(() => read(e));
-        e.Ge.nn = e;
+                e.pe = optimisticComputed(() => read(e));
+        e.pe.nn = e;
  // Parent-child lane relationship
                 setContextInternal(i);
         setPendingCheckActive(n);
         setLatestReadActive(t);
     }
-    return e.Ge;
+    return e.pe;
 }
 
 /** The latest()-mode read path, installed as GlobalQueue._latestRead. */ function latestRead(e) {
@@ -255,7 +255,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._e !== NOT_PENDING && !hasActiveOverride(t) && !(stale && t.Ie && activeTransition !== t.Ie)) return t._e;
+        if (t.De !== NOT_PENDING && !hasActiveOverride(t) && !(stale && t.Ie && activeTransition !== t.Ie)) return t.De;
     return r;
 }
 
@@ -274,14 +274,14 @@ function getLatestValueComputed(e) {
 }
 
 function recordFreshRead(e, t) {
-    if (pendingProbe !== null && e._e !== NOT_PENDING && t === e._e) pendingProbe.freshReads.add(e);
+    if (pendingProbe !== null && e.De !== NOT_PENDING && t === e.De) pendingProbe.freshReads.add(e);
 }
 
 function applyReask(e, t) {
     const n = !!(e.S & STATUS_PENDING);
-    const i = t && !(n && !e.be);
-    const r = n && e.be !== i;
-    e.be = i;
+    const i = t && !(n && !e.Re);
+    const r = n && e.Re !== i;
+    e.Re = i;
     return r;
 }
 
@@ -335,11 +335,11 @@ 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.De = syncCompanions;
+GlobalQueue._e = syncCompanions;
 
 GlobalQueue.ce = updatePendingSignal;
 
-GlobalQueue.Oe = updateChildCompanions;
+GlobalQueue.Ge = updateChildCompanions;
 
 GlobalQueue.un = snapCompanionsToState;
 
@@ -353,6 +353,6 @@ GlobalQueue.$e = applyReask;
 
 GlobalQueue.k = repollDownstreamVerdicts;
 
-GlobalQueue.Dt = witnessAffects;
+GlobalQueue.Lt = witnessAffects;
 
 export { isPending, latest };

package/dist/prod/map.js

@@ -239,7 +239,7 @@ function updateKeyedMap() {
         Kt: e,
         Gt: [],
         xt: [],
-        Lt: i?.from,
+        Vt: i?.from,
         Bt: i?.fallback
     };
     const n = computed(updateRepeat.bind(r));
@@ -260,7 +260,7 @@ function updateKeyedMap() {
 // disjoint-window/front-clear/end-clear/shift special cases.
 function updateRepeat() {
     const t = this.Jt();
-    const s = this.Lt?.() || 0;
+    const s = this.Vt?.() || 0;
     runWithOwner(this.wt, () => {
         if (t === 0) {
             if (this.jt !== 0) {

package/dist/prod/store/optimistic.js

@@ -1,6 +1,6 @@
-import { computed } from "../core/core.js";
+import { STATUS_PENDING, CONFIG_AUTO_DISPOSE, NOT_PENDING } from "../core/constants.js";
 
-import { CONFIG_AUTO_DISPOSE, NOT_PENDING } from "../core/constants.js";
+import { computed } from "../core/core.js";
 
 import { GlobalQueue, schedule, currentTransition, insertSubs, setProjectionWriteActive, projectionWriteActive } from "../core/scheduler.js";
 
@@ -14,21 +14,40 @@ import { installOptimisticEngine } from "../core/optimistic.js";
 
 import { runProjectionComputed } from "./projection.js";
 
-import { storeSetter, $TARGET, STORE_OPTIMISTIC_OVERRIDE, STORE_NODE, STORE_OPTIMISTIC_OWNERS, getOverlayLayer, STORE_VALUE, $DELETED, isWrappable, wrap, visibleNodeValue, $TRACK, notifySelf, STORE_WRAP, createStoreProxy, storeTraps, STORE_LOOKUP, STORE_SHALLOW, markRawIngest, STORE_OPTIMISTIC, STORE_FIREWALL } from "./store.js";
+import { $TARGET, STORE_FIREWALL, storeSetter, STORE_OPTIMISTIC_OVERRIDE, STORE_NODE, STORE_OPTIMISTIC_OWNERS, getOverlayLayer, STORE_VALUE, $DELETED, isWrappable, wrap, visibleNodeValue, $TRACK, notifySelf, STORE_WRAP, createStoreProxy, storeTraps, STORE_LOOKUP, STORE_SHALLOW, markRawIngest, STORE_OPTIMISTIC } from "./store.js";
 
-function createOptimisticStore(e, t, i) {
+function createOptimisticStore(e, t, r) {
     // Register clear function with scheduler; store nodes marked
     // STORE_OPTIMISTIC take the engine's write path, so install it before any
     // node can be created.
     installOptimisticEngine();
-    GlobalQueue.kt ||= clearOptimisticStores;
-    const r = typeof e === "function";
+    if (!GlobalQueue.Dt) {
+        GlobalQueue.Dt = clearOptimisticStores;
+        // Store half of the engine's override blockage (#2951): signal-form
+        // createOptimistic carries the pending async and the override on ONE node,
+        // so transitionBlocked sees both; a derived optimistic STORE splits them —
+        // the layer sits on store targets while the in-flight truth lives on the
+        // firewall computed. Without this, the transition adopting a bare store
+        // write settled in the same flush that started the refetch and its settle
+        // consumed the layer mid-flight (follow-up writes then drafted from base,
+        // clobbering instead of composing). Optimistic state clears when truth
+        // lands or its transaction ends — never mid-refetch. Wrapped here (engine
+        // is already installed above) so store-free apps never carry the check.
+                const e = GlobalQueue.dn;
+        GlobalQueue.dn = t => {
+            for (const e of t.cn) {
+                if ((e[$TARGET]?.[STORE_FIREWALL]?.S ?? 0) & STATUS_PENDING) return true;
+            }
+            return e(t);
+        };
+    }
+    const i = typeof e === "function";
     // Plain form: the second slot carries options.
-        if (!r && i === undefined) i = t;
-    const o = r ? t : e;
-    const n = r ? e : undefined;
+        if (!i && r === undefined) r = t;
+    const o = i ? t : e;
+    const n = i ? e : undefined;
     // Create optimistic projection store
-        const {store: c} = createOptimisticProjectionInternal(n, o, i);
+        const {store: c} = createOptimisticProjectionInternal(n, o, r);
     return [ c, e => storeSetter(c, e) ];
 }
 
@@ -37,8 +56,8 @@ function createOptimisticStore(e, t, i) {
 // scheduler's flush tail carries only a size-guarded hook call. The
 // completing transition scopes each clear to its own layer keys (#2899).
 function clearOptimisticStores(e, t) {
-    for (const i of e) {
-        const e = i[$TARGET];
+    for (const r of e) {
+        const e = r[$TARGET];
         if (e?.[STORE_OPTIMISTIC_OVERRIDE]) clearOptimisticOverride(e, t);
     }
     e.clear();
@@ -56,9 +75,9 @@ function clearOptimisticStores(e, t) {
  * fresh authoritative data) consumes everything — the correction supersedes
  * every tentative layer.
  */ function clearOptimisticOverride(e, t) {
-    const i = e[STORE_OPTIMISTIC_OVERRIDE];
-    if (!i) return;
-    const r = e[STORE_NODE];
+    const r = e[STORE_OPTIMISTIC_OVERRIDE];
+    if (!r) return;
+    const i = e[STORE_NODE];
     const o = e[STORE_OPTIMISTIC_OWNERS];
     const n = t !== undefined;
     let c = false;
@@ -68,7 +87,7 @@ function clearOptimisticStores(e, t) {
         const O = projectionWriteActive;
     setProjectionWriteActive(true);
     try {
-        for (const O of Reflect.ownKeys(i)) {
+        for (const O of Reflect.ownKeys(r)) {
             if (n) {
                 let e = o?.[O] ?? null;
                 // Resolve merge chains (entangled actions settle as one); path-compress
@@ -85,25 +104,25 @@ function clearOptimisticStores(e, t) {
                     }
                 }
             }
-            delete i[O];
+            delete r[O];
             if (o) delete o[O];
             c = true;
-            const T = r?.[O];
+            const T = i?.[O];
             if (T) {
                 // Clear lane association so effects go to regular queue
                 T.Me = undefined;
                 // Re-read from base — this key left the optimistic layer above, so the
                 // overlay resolves to STORE_OVERRIDE or STORE_VALUE.
                                 const t = getOverlayLayer(e, O);
-                const i = t ? t[O] : e[STORE_VALUE][O];
-                const r = i === $DELETED ? undefined : i;
-                const o = isWrappable(r) ? wrap(r, e) : r;
+                const r = t ? t[O] : e[STORE_VALUE][O];
+                const i = r === $DELETED ? undefined : r;
+                const o = isWrappable(i) ? wrap(i, e) : i;
                 const n = visibleNodeValue(T);
                 T.Ae = NOT_PENDING;
                 T.sn = null;
-                T._e = NOT_PENDING;
+                T.De = NOT_PENDING;
                 T.Ue = o;
-                if (!T.Re || !T.Re(n, o)) {
+                if (!T.be || !T.be(n, o)) {
                     insertSubs(T, true);
                     schedule();
                 }
@@ -116,8 +135,8 @@ function clearOptimisticStores(e, t) {
             e[STORE_OPTIMISTIC_OWNERS] = undefined;
         }
         // Notify $TRACK
-                if (c && r?.[$TRACK]) {
-            r[$TRACK].Me = undefined;
+                if (c && i?.[$TRACK]) {
+            i[$TRACK].Me = undefined;
             notifySelf(e);
         }
     } finally {
@@ -125,10 +144,10 @@ function clearOptimisticStores(e, t) {
     }
 }
 
-function createOptimisticProjectionInternal(e, t, i) {
-    let r;
+function createOptimisticProjectionInternal(e, t, r) {
+    let i;
     const o = new WeakMap;
-    const n = !!i?.shallow;
+    const n = !!r?.shallow;
     const wrapper = e => {
         e[STORE_WRAP] = wrapProjection;
         e[STORE_LOOKUP] = o;
@@ -140,7 +159,7 @@ function createOptimisticProjectionInternal(e, t, i) {
  // Mark as optimistic store
                 Object.defineProperty(e, STORE_FIREWALL, {
             get() {
-                return r;
+                return i;
             },
             configurable: true
         });
@@ -174,19 +193,19 @@ function createOptimisticProjectionInternal(e, t, i) {
                 setProjectionWriteActive(t);
             }
         };
-        r = computed(() => {
+        i = computed(() => {
             setProjectionWriteActive(true);
             try {
-                runProjectionComputed(c, e, i?.key || "id", wrapCommit, clearProjectionOverride);
+                runProjectionComputed(c, e, r?.key === undefined ? "id" : r.key, wrapCommit, clearProjectionOverride);
             } finally {
                 setProjectionWriteActive(false);
             }
         }, undefined);
-        r.T &= ~CONFIG_AUTO_DISPOSE;
+        i.T &= ~CONFIG_AUTO_DISPOSE;
     }
     return {
         store: c,
-        node: r
+        node: i
     };
 }