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

package/dist/node.cjs

@@ -675,8 +675,8 @@ class GlobalQueue extends Queue {
     static Te=null;
     static Ne=null;
     static Ae=null;
-    static he=null;
     static Oe=null;
+    static he=null;
     static Ie=null;
     static Re=null;
     static Ce=null;
@@ -691,8 +691,8 @@ class GlobalQueue extends Queue {
     // entry, or a non-null `currentOptimisticLane`, so `!` invocations are safe
     // once the gate holds.
     static ye=null;
-    static be=null;
     static ve=null;
+    static be=null;
     static Pe=null;
     static we=null;
     static De=null;
@@ -1007,7 +1007,7 @@ function finalizePureQueue(e = null, t = false) {
                 const t = e ?? globalQueue.L;
         // Optimistic reversion: a non-empty batch means _optimisticWrite ran,
         // which installed the engine's hooks.
-                if (t.H.length) GlobalQueue.be(t.H);
+                if (t.H.length) GlobalQueue.ve(t.H);
         // Replay entanglement: subs recorded by the read-time gate get rescheduled
         // so they re-run with the now-committed values visible. The ambient batch
         // replays too — laneReadsCommitted records readers whose committed-view
@@ -1146,7 +1146,7 @@ function transitionComplete(e) {
     // 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.ve?.(e)) t = false;
+        if (t && GlobalQueue.be?.(e)) t = false;
     t && (e.R = true);
     return t;
 }
@@ -1353,7 +1353,7 @@ function disposeChildren(e, t = false, n) {
                 const t = e;
         if (t.i?.A || t.i?.O) GlobalQueue.Ne(t);
     }
-    if (t && e.Ke && e.i !== null) e.i.ht = null;
+    if (t && e.Ke && e.i !== null) e.i.Ot = null;
     let r = n ? e.i?.Je ?? null : e.Nt;
     while (r) {
         const e = r.At;
@@ -1382,7 +1382,7 @@ function disposeChildren(e, t = false, n) {
         if (e.i !== null) e.i.Je = null;
     } else {
         e.Nt = null;
-        e.Ot = 0;
+        e.ht = 0;
     }
     // O(1) splice out of parent's chain on individual dispose. Skipped during
     // batch dispose (parent already disposed) and zombie disposal (node sits on
@@ -1424,7 +1424,7 @@ function runDisposal(e, t) {
 function childId(e, t) {
     let n = e;
     while (n.P & CONFIG_TRANSPARENT && n.ie) n = n.ie;
-    if (n.id != null) return formatId(n.id, t ? n.Ot++ : n.Ot);
+    if (n.id != null) return formatId(n.id, t ? n.ht++ : n.ht);
     throw new Error("");
 }
 
@@ -1553,7 +1553,7 @@ function disposeRootSelf(e = true) {
         Ct: null,
         ut: t?.ut ?? globalQueue,
         gt: t?.gt || defaultContext,
-        Ot: 0,
+        ht: 0,
         i: null,
         ie: t,
         dispose: disposeRootSelf
@@ -1605,7 +1605,7 @@ function unlinkSubs(e) {
     const n = e.rt;
     const i = e.We;
     const r = e.yt;
-    if (i !== null) i.yt = r; else t.bt = r;
+    if (i !== null) i.yt = r; else t.vt = r;
     if (r !== null) r.We = i; else {
         t.M = i;
         if (i === null) {
@@ -1663,7 +1663,7 @@ function link(e, t, n = false) {
     // read order within the computation.
     const i = t.$e;
     if (i !== null && i.ot === e) {
-        i.vt &&= n;
+        i.bt &&= n;
         return;
     }
     let r = null;
@@ -1674,7 +1674,7 @@ function link(e, t, n = false) {
             r.Me = t.qe;
             t.$e = r;
             // First touch of this pass: the previous pass's label is stale.
-                        r.vt = n;
+                        r.bt = n;
             return;
         }
     }
@@ -1683,21 +1683,21 @@ function link(e, t, n = false) {
     // [deps.._depsTail] prefix — the O(1) equivalent of scanning the dep list
     // (the old alien-signals `isValidLink` walk, O(n²) when a computation
     // re-reads earlier deps non-consecutively, e.g. store leaf reads).
-        const s = e.bt;
+        const s = e.vt;
     if (s !== null && s.je === t && (!o || s.Me === t.qe)) {
         // Gen-matched during a recompute = repeat touch this pass (AND); outside
         // a recompute there is no pass boundary, so the latest read labels it.
-        if (o) s.vt &&= n; else s.vt = n;
+        if (o) s.bt &&= n; else s.bt = n;
         return;
     }
-    const u = t.$e = e.bt = {
+    const u = t.$e = e.vt = {
         ot: e,
         je: t,
         rt: r,
         yt: s,
         We: null,
         Me: t.qe,
-        vt: n
+        bt: n
     };
     if (i !== null) i.rt = u; else t.it = u;
     if (s !== null) s.We = u; else e.M = u;
@@ -1886,12 +1886,12 @@ function handleAsync(e, t, n) {
         });
     }
     if (!r && !i) {
-        if (e.i !== null) e.i.ht = null;
+        if (e.i !== null) e.i.Ot = null;
         // A sync landing is the first real answer for a loadingValue node.
                 e.ze = false;
         return t;
     }
-    ext(e).ht = t;
+    ext(e).Ot = t;
     let o;
     // Settle-time transition re-entry. The loading rail is invisible to
     // transactions (#2933): a boundary-caught first load never registers as an
@@ -1914,7 +1914,7 @@ function handleAsync(e, t, n) {
         globalQueue.initTransition(t);
     };
     const handleError = n => {
-        if (e.i?.ht !== t) return;
+        if (e.i?.Ot !== t) return;
         // NotReadyError from rejected promises should be treated as pending, not error
                 let i = n instanceof NotReadyError;
         if (i && e.ze) {
@@ -1922,7 +1922,7 @@ function handleAsync(e, t, n) {
             // serving commit #0 — same parking as recompute's catch for sync
             // dependency throws. The dead flight is released so the clock-gated
             // error-retry pull (updateIfNecessary) can also re-ask.
-            if (e.i !== null) e.i.ht = null;
+            if (e.i !== null) e.i.Ot = null;
             parkLoadingWindow(e, n);
             e.B = clock;
             return;
@@ -1936,7 +1936,7 @@ function handleAsync(e, t, n) {
                 if (!i) releaseSettledDependents(e);
     };
     const asyncWrite = (i, r) => {
-        if (e.i?.ht !== t) return;
+        if (e.i?.Ot !== t) return;
         // If the node was dirtied by a newer write (optimistic override or regular),
         // skip this stale async result — the upcoming flush will recompute the node
         // with the new value, creating a fresh Promise that supersedes this one.
@@ -2085,7 +2085,7 @@ function handleAsync(e, t, n) {
                     n = i;
                     f = true;
                     if (i.done) u = true;
-                } else if (e.i?.ht !== t) {
+                } else if (e.i?.Ot !== t) {
                     return;
                 } else if (!i.done) {
                     s = true;
@@ -2105,7 +2105,7 @@ function handleAsync(e, t, n) {
                 if (a && l) {
                     i = n;
                     c = true;
-                } else if (e.i?.ht === t) {
+                } else if (e.i?.Ot === t) {
                     u = true;
                     handleError(n);
                     settleAutodispose();
@@ -2171,7 +2171,7 @@ function handleAsync(e, t, n) {
             if (s) {
                 o = i;
                 n = true;
-            } else if (e.i?.ht === t && !(e.U & REACTIVE_DISPOSED) && flattenIfIterable(i, registerDeferredClose)) ; else {
+            } else if (e.i?.Ot === t && !(e.U & REACTIVE_DISPOSED) && flattenIfIterable(i, registerDeferredClose)) ; else {
                 asyncWrite(i);
                 settleAutodispose();
             }
@@ -2284,7 +2284,7 @@ function notifyStatus(e, t, n, i, r) {
             // not carry a real (non-NotReadyError) error — the synchronous `isPending`
             // read swallows those, and the async path must match. Re-run the observer
             // so `isPending` re-evaluates (to not-pending) instead of forwarding.
-            if (i.vt && t !== STATUS_PENDING && !(n instanceof NotReadyError)) {
+            if (i.bt && t !== STATUS_PENDING && !(n instanceof NotReadyError)) {
                 enqueueSub(e);
                 schedule();
                 return;
@@ -2393,7 +2393,7 @@ function recompute(e, t = false) {
     if (!t) {
         if (e.T && (!n || activeTransition) && activeTransition !== e.T) globalQueue.initTransition(e.T);
         deleteFromHeap(e, queueFor(e));
-        if (e.i !== null) e.i.ht = null;
+        if (e.i !== null) e.i.Ot = null;
         // Tracked effects run after finalizePureQueue, so dispose immediately instead of deferring
                 if (e.T || n === EFFECT_TRACKED) disposeChildren(e); else if (e.Nt !== null || e.Ct !== null) {
             markDisposal(e);
@@ -2402,7 +2402,7 @@ function recompute(e, t = false) {
             t.Je = e.Nt;
             e.Ct = null;
             e.Nt = null;
-            e.Ot = 0;
+            e.ht = 0;
         } else ;
     }
     let i = !!(e.U & REACTIVE_OPTIMISTIC_DIRTY);
@@ -2466,7 +2466,7 @@ function recompute(e, t = false) {
     try {
         if (!false && e.P & CONFIG_SYNC) {
             c = e.Ke(c);
-            if (e.i !== null) e.i.ht = null;
+            if (e.i !== null) e.i.Ot = null;
             e.ze = false;
         } else {
             // Snapshot `_inFlight` so we can detect whether `_fn` self-registered an async
@@ -2474,13 +2474,13 @@ function recompute(e, t = false) {
             // with a setter callback). In that case, the outer `handleAsync` call below would
             // clobber the fresh subscription, so we skip it and let the internally-registered
             // iteration drive updates.
-            const t = e.i?.ht;
+            const t = e.i?.Ot;
             const n = e.Ke(c);
             const i = typeof n === "object" && n !== null;
-            const r = e.i?.ht !== t;
+            const r = e.i?.Ot !== t;
             c = r || !i ? n : handleAsync(e, n);
             if (!r && !i) {
-                if (e.i !== null) e.i.ht = null;
+                if (e.i !== null) e.i.Ot = null;
                 // A sync (non-object) return is the first real answer; async-shaped
                 // results clear inside handleAsync at their own landing points, and a
                 // self-registered flight (inFlightChanged — projections) clears when
@@ -2646,7 +2646,7 @@ function updateIfNecessary(e) {
             }
         }
     }
-    if (e.U & (REACTIVE_DIRTY | REACTIVE_OPTIMISTIC_DIRTY) || e.i?.Le && e.B < clock && !e.i?.ht) {
+    if (e.U & (REACTIVE_DIRTY | REACTIVE_OPTIMISTIC_DIRTY) || e.i?.Le && e.B < clock && !e.i?.Ot) {
         recompute(e);
     }
     e.U = e.U & (REACTIVE_SNAPSHOT_STALE | REACTIVE_IN_HEAP | REACTIVE_IN_HEAP_HEIGHT);
@@ -2665,7 +2665,7 @@ function computed(e, t) {
         Ct: null,
         ut: context?.ut ?? globalQueue,
         gt: context?.gt ?? defaultContext,
-        Ot: 0,
+        ht: 0,
         Ke: e,
         Be: i ? t.loadingValue : undefined,
         ft: 0,
@@ -2675,7 +2675,7 @@ function computed(e, t) {
         $e: null,
         qe: 0,
         M: null,
-        bt: null,
+        vt: null,
         ie: context,
         At: null,
         It: null,
@@ -2711,7 +2711,7 @@ function computed(e, t) {
         O: undefined,
         t: undefined,
         $: 0,
-        ht: null,
+        Ot: null,
         Le: undefined,
         Pt: undefined,
         nt: undefined,
@@ -2740,7 +2740,7 @@ function computed(e, t) {
         Ct: null,
         ut: context?.ut ?? globalQueue,
         gt: context?.gt ?? defaultContext,
-        Ot: 0,
+        ht: 0,
         Ke: e,
         Be: undefined,
         ft: 0,
@@ -2750,7 +2750,7 @@ function computed(e, t) {
         $e: null,
         qe: 0,
         M: null,
-        bt: null,
+        vt: null,
         ie: context,
         At: null,
         It: null,
@@ -2812,7 +2812,7 @@ function signal(e, t, n = null) {
         P: (t?.ownedWrite ? CONFIG_OWNED_WRITE : 0) | (t?.Ft ? CONFIG_NO_SNAPSHOT : 0),
         Be: e,
         M: null,
-        bt: null,
+        vt: null,
         B: clock,
         st: n,
         Tt: n?.i?._t || null,
@@ -2951,7 +2951,7 @@ function read(e) {
     // Probe mode is suspended while preparing the node so nested reads during a
     // recompute don't collect into the probe.
         if (pendingCheckActive) {
-        GlobalQueue.he(e, t, r, i);
+        GlobalQueue.Oe(e, t, r, i);
     } else if (typeof n.Ke === "function") {
         prepareComputed(e, false);
     }
@@ -3048,7 +3048,7 @@ function read(e) {
         const o = !t || currentOptimisticLane !== null && GlobalQueue.me(e, r, t) || e.q === NOT_PENDING || t.P & CONFIG_CHILDREN_FORBIDDEN || stale && e.T && activeTransition !== e.T ? e.Be : e.q;
     // 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.Oe(e, o);
+        if (pendingCheckActive) GlobalQueue.he(e, o);
     if (!t && r === e && typeof n.Ke === "function" && e.P & CONFIG_AUTO_DISPOSE && !(r.Xe & STATUS_PENDING) && !e.M) {
         unobserved(e);
     }
@@ -3384,7 +3384,14 @@ function isUndefined(e) {
     const n = e.i?.C !== NOT_PENDING;
     const i = n ? unwrapOverride(e.i?.C) : e.Be;
     if (typeof t === "function") t = t(i);
-    const r = !!(e.Xe & STATUS_UNINITIALIZED) || !e.wt || !e.wt(i, t);
+    const r = !!(e.Xe & STATUS_UNINITIALIZED) || 
+    // A dirty node's _value is stale (its queued recompute hasn't run — e.g.
+    // a latest() shadow marked by the previous landing's companion snap), so
+    // equality against it must not swallow the write. Without this, a sync
+    // 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.U ?? 0) & (REACTIVE_DIRTY | REACTIVE_CHECK)) || !e.wt || !e.wt(i, t);
     if (!r) {
         // Same-value write with an active override still entangles the current
         // action's transition — the hold must outlast all overlapping actions.
@@ -3523,16 +3530,31 @@ 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, t, n) {
-    if (e.i?.C !== undefined || !!e.i?.o || !!(t.Xe & STATUS_PENDING)) return true;
+    if (e.i?.C !== undefined || !!e.i?.o || !!(t.Xe & 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
+        // `_fn` check and reach here instead — a lane-assigned source whose async
+        // already settled (laneAsyncSettled keeps _optimisticLane) served its
+        // 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.q !== NOT_PENDING) (activeTransition ?? globalQueue.L).te.add(n);
+        return true;
+    }
     if (t === e && stale && n.i?.t !== e) {
-        // The committed view can hide a same-tick ambient write (a lane member —
-        // even just an isPending companion flip — puts the reader "under a lane"
-        // against unrelated plain writes). With no transaction the write commits
-        // at THIS flush's end with no re-delivery, so record the reader for
-        // replay at commit — the same contract gatedRead provides when a
-        // transaction is active (#2963). If a transaction forms mid-flush,
-        // initTransition carries the recording over to it.
-        if (e.q !== NOT_PENDING && activeTransition === null) globalQueue.L.te.add(n);
+        // The committed view can hide a staged write (a lane member — even just
+        // an isPending companion flip — puts the reader "under a lane"). The
+        // staged value commits with no re-delivery (commitPendingNode never
+        // re-notifies), so record the reader for replay at commit — the same
+        // contract gatedRead provides (#2963). gatedRead itself only covers
+        // signal reads where the reading computed differs from the source; the
+        // owner === el memo/self read lands here instead. With a transaction
+        // active the staged value promotes silently at ITS landing, so record
+        // 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.q !== NOT_PENDING) (activeTransition ?? globalQueue.L).te.add(n);
         return true;
     }
     return false;
@@ -3606,8 +3628,8 @@ function trackOptimisticStore(e) {
  */ function installOptimisticEngine() {
     if (GlobalQueue.ye !== null) return;
     GlobalQueue.ye = optimisticWrite;
-    GlobalQueue.be = resolveOptimisticNodes;
-    GlobalQueue.ve = transitionBlocked;
+    GlobalQueue.ve = resolveOptimisticNodes;
+    GlobalQueue.be = transitionBlocked;
     GlobalQueue.Pe = cleanupCompletedLanes;
     GlobalQueue.we = runLaneEffects;
     GlobalQueue.De = gatedRead;
@@ -3718,7 +3740,7 @@ function collectPendingSources(e) {
     const r = i.U & REACTIVE_RECOMPUTING_DEPS ? i.$e : undefined;
     if (r !== null) {
         for (let e = i.it ?? null; e !== null; e = e.rt) {
-            if (!e.vt && markWalk(e.ot, t)) return true;
+            if (!e.bt && markWalk(e.ot, t)) return true;
             if (e === r) break;
         }
     }
@@ -3762,7 +3784,7 @@ function computePendingState(e) {
         return newQuestionInFlight(n);
     }
     if (n && e.q !== NOT_PENDING && !hasActiveOverride$1(e)) {
-        return !!(n.U & REACTIVE_MANUAL_WRITE) || !n.i?.ht && !(n.Xe & STATUS_PENDING) || !!(n.Xe & STATUS_PENDING) && quietPending(n);
+        return !!(n.U & REACTIVE_MANUAL_WRITE) || !n.i?.Ot && !(n.Xe & STATUS_PENDING) || !!(n.Xe & 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
@@ -3876,6 +3898,13 @@ function snapCompanionsToState(e) {
 
 function getLatestValueComputed(e) {
     let t = e.i?.O;
+    // A shadow disposed while unobserved (its gated reader unmounted at a
+    // landing) is a corpse: sync writes into it equality-swallow against its
+    // frozen _value, and a later read revives it via recompute — clearing
+    // DISPOSED and re-deriving from the committed view, so the banner showed
+    // the previous transition's target (#3041 follow-up). Treat it as absent;
+    // recreation backfills from the in-flight write below.
+        if (t && t.U & REACTIVE_DISPOSED) t = undefined;
     if (!t) {
         const n = latestReadActive;
         setLatestReadActive(false);
@@ -4064,9 +4093,9 @@ GlobalQueue.Ne = snapCompanionsToState;
 
 GlobalQueue.Ae = latestRead;
 
-GlobalQueue.he = pendingCheckRead;
+GlobalQueue.Oe = pendingCheckRead;
 
-GlobalQueue.Oe = recordFreshRead;
+GlobalQueue.he = recordFreshRead;
 
 GlobalQueue.Ie = applyReask;
 
@@ -6972,68 +7001,130 @@ function descend(e, t, n, i, r = false) {
  * loading windows, handleAsync landings, commit-through-setter) on next
  * primitives; the generic draft write-traps are reused from the legacy
  * module unchanged.
- */ function createWriteTraps(e, t) {
-    // Save/restore, never hard-reset: the draft can be driven from inside an
-    // enclosing authoritative-write scope (next-store optimistic derives), and
-    // a hard `false` would clobber it mid-derive.
-    const n = {
-        get(e, t) {
+ */
+/**
+ * Wrap a store proxy as a projection DRAFT: every operation carries the write
+ * override (the derive is the author — its ops must not hit the §6c firewall
+ * gate, even in a continuation after an `await`/`yield` where the sync write
+ * scope has closed).
+ *
+ * FAKE TARGET, not the store proxy itself (#3060): after a proxy trap
+ * returns, the engine runs spec invariant validation against the proxy's
+ * TARGET — [[OwnPropertyKeys]] after ownKeys, [[GetOwnProperty]] after
+ * set/getOwnPropertyDescriptor/defineProperty. With the store proxy as
+ * target those checks re-enter the store's traps OUTSIDE the override
+ * bracket (the trap's finally has already run), so `Object.keys(state)` in
+ * a derive continuation fired the firewall gate and re-threw the
+ * projection's own pending NotReadyError into the derive. A dummy of
+ * matching kind (array/object, same trick as the store's own TargetShape)
+ * keeps invariant validation away from the store entirely; the traps
+ * forward to the closed-over inner proxy inside the bracket.
+ *
+ * Save/restore projectionWriteActive, never hard-reset: the draft can be
+ * driven from inside an enclosing authoritative-write scope (next-store
+ * optimistic derives), and a hard `false` would clobber it mid-derive.
+ */ function wrapDraft(e, t, n) {
+    const i = {
+        get(i, r) {
+            let o;
+            const s = projectionWriteActive;
+            setWriteOverride(true);
+            setProjectionWriteActive(true);
+            try {
+                o = e[r];
+            } finally {
+                setWriteOverride(false);
+                setProjectionWriteActive(s);
+            }
+            if (r === $TARGET) return o;
+            return typeof o === "object" && o !== null ? wrapDraft(o, t, n) : o;
+        },
+        has(t, n) {
             let i;
             const r = projectionWriteActive;
             setWriteOverride(true);
             setProjectionWriteActive(true);
             try {
-                i = e[t];
+                i = n in e;
             } finally {
                 setWriteOverride(false);
                 setProjectionWriteActive(r);
             }
-            if (t === $TARGET) return i;
-            return typeof i === "object" && i !== null ? new Proxy(i, n) : i;
+            return i;
         },
-        has(e, t) {
-            let n;
-            const i = projectionWriteActive;
+        set(i, r, o) {
+            if (t && !t()) return true;
+            const s = projectionWriteActive;
             setWriteOverride(true);
             setProjectionWriteActive(true);
             try {
-                n = t in e;
+                e[r] = o;
+                n?.();
             } finally {
                 setWriteOverride(false);
-                setProjectionWriteActive(i);
+                setProjectionWriteActive(s);
             }
-            return n;
+            return true;
         },
-        set(n, i, r) {
-            if (e && !e()) return true;
+        deleteProperty(i, r) {
+            if (t && !t()) return true;
             const o = projectionWriteActive;
             setWriteOverride(true);
             setProjectionWriteActive(true);
             try {
-                n[i] = r;
-                t?.();
+                delete e[r];
+                n?.();
             } finally {
                 setWriteOverride(false);
                 setProjectionWriteActive(o);
             }
             return true;
         },
-        deleteProperty(n, i) {
-            if (e && !e()) return true;
+        ownKeys() {
+            const t = projectionWriteActive;
+            setWriteOverride(true);
+            setProjectionWriteActive(true);
+            try {
+                return Reflect.ownKeys(e);
+            } finally {
+                setWriteOverride(false);
+                setProjectionWriteActive(t);
+            }
+        },
+        getOwnPropertyDescriptor(t, n) {
+            let i;
             const r = projectionWriteActive;
             setWriteOverride(true);
             setProjectionWriteActive(true);
             try {
-                delete n[i];
-                t?.();
+                i = Reflect.getOwnPropertyDescriptor(e, n);
             } finally {
                 setWriteOverride(false);
                 setProjectionWriteActive(r);
             }
+            // The dummy target doesn't hold the key, so a non-configurable report
+            // would violate the proxy invariant. Store descriptors are already
+            // normalized configurable; enforce it for raw leaves too.
+                        if (i) i.configurable = true;
+            return i;
+        },
+        defineProperty(i, r, o) {
+            if (t && !t()) return true;
+            const s = projectionWriteActive;
+            setWriteOverride(true);
+            setProjectionWriteActive(true);
+            try {
+                Reflect.defineProperty(e, r, o);
+                n?.();
+            } finally {
+                setWriteOverride(false);
+                setProjectionWriteActive(s);
+            }
             return true;
         }
     };
-    return n;
+    // Matching-kind dummy so Array.isArray(draft) answers like the store.
+        return new Proxy(Array.isArray(e) ? [] : {}, i);
 }
 
 function createProjectionNextInternal(e, t, n) {
@@ -7089,7 +7180,7 @@ function runProjectionComputedNext(e, t, n, i, r) {
     // seed so draft writes cannot tear through to readers (#2988). Every commit
     // point reconciles the shadow through the normal commit path.
         const l = o.ze ? JSON.parse(JSON.stringify(e[$TARGET][STORE_VALUE])) : null;
-    const f = new Proxy(e, createWriteTraps(() => !s || o.i?.ht === u, r));
+    const f = wrapDraft(e, () => !s || o.i?.Ot === u, r);
     storeSetterNext(f, r => {
         u = t(l ?? r);
         s = true;
@@ -7144,8 +7235,8 @@ function installNextBlockedHalf() {
             e.clear();
         };
     }
-    const e = GlobalQueue.ve;
-    GlobalQueue.ve = t => {
+    const e = GlobalQueue.be;
+    GlobalQueue.be = t => {
         for (const e of t.j) {
             const t = e?.[$TARGET];
             const n = t?.fam?.node;
@@ -8162,8 +8253,8 @@ class RevealController {
         Ft: true
     });
     An=true;
-    hn=true;
-    On=false;
+    On=true;
+    hn=false;
     constructor(e, t) {
         this._n = e;
         this.Tn = t;
@@ -8221,10 +8312,10 @@ class RevealController {
         untrack(() => this.pn());
     }
     pn(e, t) {
-        if (this.On) return;
-        this.On = true;
+        if (this.hn) return;
+        this.hn = true;
         const n = this.An;
-        const i = this.hn;
+        const i = this.On;
         try {
             const n = e ?? read(this.cn), i = untrack(this._n), r = i === "sequential" && !!untrack(this.Tn), o = t ?? r;
             if (n) {
@@ -8276,10 +8367,10 @@ class RevealController {
             }
         } finally {
             this.An = this.sn();
-            this.hn = this.fn();
-            this.On = false;
+            this.On = this.fn();
+            this.hn = false;
         }
-        if (this.dn && (n !== this.An || i !== this.hn)) this.dn.pn();
+        if (this.dn && (n !== this.An || i !== this.On)) this.dn.pn();
     }
 }
 
@@ -8299,8 +8390,8 @@ class CollectionQueue extends Queue {
     });
     En;
     Sn=false;
-    bn;
-    vn=ON_INIT;
+    vn;
+    bn=ON_INIT;
     constructor(e) {
         super();
         this.gn = e;
@@ -8311,16 +8402,16 @@ class CollectionQueue extends Queue {
     }
     notify(e, t, n, i) {
         if (!(t & this.gn)) return super.notify(e, t, n, i);
-        if (this.Sn && this.bn) {
+        if (this.Sn && this.vn) {
             const e = untrack(() => {
                 try {
-                    return this.bn();
+                    return this.vn();
                 } catch {
                     return ON_INIT;
                 }
             });
-            if (e !== this.vn) {
-                this.vn = e;
+            if (e !== this.bn) {
+                this.bn = e;
                 this.Sn = false;
                 this.un.clear();
             }
@@ -8367,9 +8458,9 @@ class CollectionQueue extends Queue {
             }
             if (!this.ln) {
                 setSignal(this.cn, false);
-                if (this.bn) {
+                if (this.vn) {
                     try {
-                        this.vn = untrack(() => this.bn());
+                        this.bn = untrack(() => this.vn());
                     } catch {
                         /* value not yet committed — _prevOn stays stale, next notify will reset */}
                 }
@@ -8387,7 +8478,7 @@ function createCollectionBoundary(e, t, n, i) {
         ownedWrite: true,
         Ft: true
     });
-    if (i) o.bn = i;
+    if (i) o.vn = i;
     const s = o.yn = createBoundChildren(r, t, o, e);
     // Prime source tracking so reveal registration sees pending sources.
         untrack(() => {