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

package/dist/prod/store/next/optimistic.js

@@ -1,4 +1,4 @@
-import { CONFIG_AUTO_DISPOSE, STATUS_PENDING, NOT_PENDING, CONFIG_OPTIMISTIC, CONFIG_HELD_TRUTH, unwrapOverride } from "../../core/constants.js";
+import { CONFIG_AUTO_DISPOSE, STATUS_PENDING, STATUS_UNINITIALIZED, NOT_PENDING, CONFIG_OPTIMISTIC, CONFIG_HELD_TRUTH, unwrapOverride } from "../../core/constants.js";
 
 import { computed, setSignal, isEqual } from "../../core/core.js";
 
@@ -18,13 +18,11 @@ import { $TARGET, markRawIngest, setNextOptimisticViewResolver, isWrappable, raw
 
 import { runProjectionComputedNext } from "./projection.js";
 
-import { wrapNext, runAuthoritative, storeSetterNext, hasActiveOverride, unwrapValue, targetsEqual, getNode, getHasNode, getKeySetNode, bumpDeep, stagedTruthPB, authoritativeRead } from "./store.js";
+import { wrapNext, runAuthoritative, storeSetterNext, hasActiveOverride, unwrapValue, targetsEqual, heldMaskView, getNode, getHasNode, getKeySetNode, bumpDeep, stagedTruthPB, authoritativeRead } from "./store.js";
 
-import { patchHooks, rowHooks } from "./patch-hooks.js";
+import { sameKey } from "./reconcile.js";
 
-import { sameKey, buildIdentityRowOps } from "./reconcile.js";
-
-import { setOptHooks } from "./target.js";
+import { setOptHooks, $OWNER, lookupTarget } from "./target.js";
 
 /**
  * Store rewrite — optimistic stores (§3/§7, RUL-3): no store-side layer, no
@@ -57,7 +55,7 @@ import { setOptHooks } from "./target.js";
  * staged values to converge (normal speculation). Resolves merges first:
  * merge unions optimistic nodes/stores into the target. */ function transitionHoldsOptimism(e) {
     const t = currentTransition(e);
-    return t.sn !== true && (t.ze.length !== 0 || t.En.size !== 0);
+    return t.ft !== true && (t.it.length !== 0 || t.En.size !== 0);
 }
 
 let blockedInstalled = false;
@@ -78,37 +76,28 @@ function installNextBlockedHalf() {
     // Scheduler flush tails call _clearOptimisticStores whenever tracked
     // stores exist; next has no layer to clear — reverts are engine-native —
     // so the hook only empties the batch set.
-        if (!GlobalQueue.qt) {
-        GlobalQueue.qt = e => {
-            // Patch channel (revert site): engine-native reverts flip node values
-            // back to committed; patched records need a forced DOM re-apply from
-            // the post-revert view. Emission only — next keeps no layer to clear.
+        if (!GlobalQueue.ni) {
+        GlobalQueue.ni = e => {
             for (const t of e) {
                 const e = t?.[$TARGET];
                 const n = e?.fam?.overlaid;
                 if (n !== undefined) {
                     for (const e of n) {
-                        if (e.pc !== null && e.pc.p !== null) patchHooks.emitPatchOptimistic(e, null, null);
-                        // Row-ops resync (family increment 2): reverts flip node values
-                        // back engine-natively; a driven list must rebuild retention by
-                        // row identity against the post-revert view (resolved from the
-                        // target at drain — overrides are gone by then).
-                                                if (e.pc !== null && e.pc.ro !== null) rowHooks.emitRowOpsOptimistic(e, null, null);
                         // Keyset resync (classic channel twin): the keyset node's own
                         // revert can compare EQUAL (a landing's bump matched the
                         // tentative bump) while the arrangement underneath changed —
                         // mapArray/ownKeys subscribers must re-read the post-revert
                         // view. Authoritative bump: never re-arm the node we are
                         // clearing.
-                                                if (e.k !== null) runAuthoritative(() => setSignal(e.k, e => e + 1));
+                        if (e.k !== null) runAuthoritative(() => setSignal(e.k, e => e + 1));
                     }
                 }
             }
             e.clear();
         };
     }
-    const e = GlobalQueue.dn;
-    GlobalQueue.dn = t => {
+    const e = GlobalQueue.cn;
+    GlobalQueue.cn = t => {
         for (const e of t.En) {
             const n = e?.[$TARGET];
             const i = n?.fam;
@@ -139,10 +128,10 @@ function familyHasLiveOverrides(e) {
             if (t === null) continue;
             for (const e of Reflect.ownKeys(t)) {
                 const n = t[e];
-                if (n.o?.Pe !== undefined && n.o?.Pe !== NOT_PENDING) return true;
+                if (n.o?.be !== undefined && n.o?.be !== NOT_PENDING) return true;
             }
         }
-        if (e.k !== null && e.k.o?.Pe !== undefined && e.k.o?.Pe !== NOT_PENDING) return true;
+        if (e.k !== null && e.k.o?.be !== undefined && e.k.o?.be !== NOT_PENDING) return true;
     }
     t.clear();
  // nothing live — drop the bookkeeping
@@ -155,23 +144,23 @@ function createOptimisticStoreNext(e, t, n) {
     installOptimisticEngine();
     installNextBlockedHalf();
     const i = typeof e === "function";
-    if (!i && n === undefined) n = t;
-    const o = i ? t : e;
-    const r = {
+    const o = i ? n : t;
+    const r = i ? t : e;
+    const s = {
         map: new WeakMap,
         node: null,
-        shallow: !!n?.shallow,
+        shallow: !!o?.shallow,
         opt: true
     };
-    const l = wrapNext(o, null, null, r);
-    r.px = l;
+    const l = wrapNext(r, null, null, s);
+    s.px = l;
     // Same key resolution the projection channels use ("id" default) — replay's
     // satisfaction rule reads it off the family.
-        const s = n?.key === undefined ? "id" : n.key;
-    r.key = typeof s === "function" ? s : s === null ? null : e => isWrappable(e) ? e[s] : undefined;
-    if (r.shallow) {
+        const u = o?.key === undefined ? "id" : o.key;
+    s.key = typeof u === "function" ? u : u === null ? null : e => isWrappable(e) ? e[u] : undefined;
+    if (s.shallow) {
         l[$TARGET].s = true;
-        markRawIngest(o);
+        markRawIngest(r);
     }
     if (i) {
         const t = e;
@@ -185,11 +174,11 @@ function createOptimisticStoreNext(e, t, n) {
         // flight (loading window) keeps the ambient reveal (#2933: the loading
         // rail is transaction-invisible).
                 const enterFlightTransition = () => {
-            const e = r.ft;
+            const e = s.ft;
             if (e == null) return;
             let t = liveTransition(e);
-            if (t === null) r.ft = t = createTransition();
-            r.node.Ae = t;
+            if (t === null) s.ft = t = createTransition();
+            s.node.ge = t;
             globalQueue.initTransition(t);
         };
         // Landing router (#3164 fold ruling): while a transaction retains
@@ -200,9 +189,9 @@ function createOptimisticStoreNext(e, t, n) {
         // flight-owned transaction (#3146). Sync commits (the derive's body,
         // owner is the firewall itself) reveal with their own recompute's flush.
                 const wrapCommit = (e, t) => {
-            const n = retainingTransition(r);
-            if (n !== null) return void stageLanding(r, n, t);
-            if (getOwner() !== r.node) enterFlightTransition();
+            const n = retainingTransition(s);
+            if (n !== null) return void stageLanding(s, n, t);
+            if (getOwner() !== s.node) enterFlightTransition();
             runAuthoritative(e);
         };
         // Draft writes (the derive mutating its draft, sync body and post-await
@@ -212,7 +201,7 @@ function createOptimisticStoreNext(e, t, n) {
         // batch; the write-override eager-commit branch in notifyWrites yields
         // to any active transaction).
                 const aroundDraftWrite = e => {
-            const t = retainingTransition(r);
+            const t = retainingTransition(s);
             if (t === null) e(); else runFolded(t, e);
         };
         // Flight declaration (#3146): a recompute that registered a truth-flight
@@ -234,33 +223,42 @@ function createOptimisticStoreNext(e, t, n) {
         // (#2933: the loading rail is transaction-invisible); a sync run clears
         // the declaration.
                 const declareFlight = e => {
-            if (e.o?.Ie == null) {
-                if (!e.Ne) r.ft = null;
+            if (e.o?.Pe == null) {
+                if (!e.Ae) s.ft = null;
                 return;
             }
-            if (e.Ne) return;
+            // First flight (#3146 carve-out): nothing has ever committed, so there
+            // is no truth to keep on screen and no optimistic state to protect. An
+            // uninitialized ask suspends its readers into their Loading boundary
+            // exactly like a plain derived store's first flight — declaring a
+            // transaction here instead held the ROOT MOUNT (render()'s scheduled
+            // insert rides transitions) until the fetch landed, so the boundary's
+            // fallback never showed and the whole page stayed blank. The loading
+            // window (#2933) already declares nothing for the same reason; once
+            // the first truth lands, every refetch flight declares as before.
+                        if (e.Ae || e.S & STATUS_UNINITIALIZED) return;
             let t = activeTransition;
             if (t === null) globalQueue.initTransition(t = createTransition());
-            r.ft = t;
-            e.Ae = t;
-            let n = t._e.get(e);
-            if (n === undefined) t._e.set(e, n = new Set);
+            s.ft = t;
+            e.ge = t;
+            let n = t.Re.get(e);
+            if (n === undefined) t.Re.set(e, n = new Set);
             n.add(e);
         };
-        let i;
-        if (n?.seedLoadingValue) i = {
+        let n;
+        if (o?.seedLoadingValue) n = {
             loadingValue: undefined
         };
-        const o = computed(() => {
+        const i = computed(() => {
             const e = getOwner();
             try {
-                runAuthoritative(() => runProjectionComputedNext(l, t, n?.key === undefined ? "id" : n.key, wrapCommit, aroundDraftWrite));
+                runAuthoritative(() => runProjectionComputedNext(l, t, o?.key === undefined ? "id" : o.key, wrapCommit, aroundDraftWrite));
             } finally {
                 declareFlight(e);
             }
-        }, i);
-        o.T &= ~CONFIG_AUTO_DISPOSE;
-        r.node = o;
+        }, n);
+        i.T &= ~CONFIG_AUTO_DISPOSE;
+        s.node = i;
     }
     return [ l, e => {
         // Retention ledger (#3164): record the owning transaction so landings
@@ -270,14 +268,14 @@ function createOptimisticStoreNext(e, t, n) {
         // per #2951 and dies with it).
         const t = activeTransition;
         storeSetterNext(l, e);
-        if (t !== null) (r.rt ??= new Set).add(t);
+        if (t !== null) (s.rt ??= new Set).add(t);
     } ];
 }
 
 /** Resolve a retained transition through its merge chain (`_done` holds the
  * merge target while merged, `true` once settled). Null = dead. */ function liveTransition(e) {
-    while (typeof e.sn === "object") e = e.sn;
-    return e.sn === true ? null : e;
+    while (typeof e.ft === "object") e = e.ft;
+    return e.ft === true ? null : e;
 }
 
 /** The transaction truth landings fold into: the first live member of the
@@ -322,10 +320,10 @@ function createOptimisticStoreNext(e, t, n) {
  * stay unarmed — the override is their display and its revert their
  * notification, A17). */ function runFolded(e, t) {
     runAsTransitionBatch(e, t);
-    const n = e.Lt;
+    const n = e.$t;
     for (let t = 0; t < n.length; t++) {
         const i = n[t];
-        i.Ae = e;
+        i.ge = e;
         if (i.T & CONFIG_OPTIMISTIC && !hasActiveOverride(i)) i.T |= CONFIG_HELD_TRUTH;
     }
 }
@@ -349,8 +347,8 @@ function createOptimisticStoreNext(e, t, n) {
                 if (!isWrappable(i)) continue;
                 const r = n(i);
                 if (r === undefined) continue;
-                const l = (o ??= new Map).get(r);
-                if (l === undefined) o.set(r, [ i ]); else l.push(i);
+                const s = (o ??= new Map).get(r);
+                if (s === undefined) o.set(r, [ i ]); else s.push(i);
             }
             // Echo adoption: an optimistic structural add whose key the landing
             // confirms must keep its raw (and so its proxy — list drivers keep the
@@ -360,35 +358,35 @@ function createOptimisticStoreNext(e, t, n) {
             // keys; overlay rows only extend coverage. Adopted raws enter staged
             // truth; at settle the override reverts and the reveal re-seats the
             // same raw.
-                        const l = e[$TARGET]?.n;
-            if (l != null) {
-                for (const e of Reflect.ownKeys(l)) {
-                    const t = l[e];
+                        const s = e[$TARGET]?.n;
+            if (s != null) {
+                for (const e of Reflect.ownKeys(s)) {
+                    const t = s[e];
                     if (!hasActiveOverride(t)) continue;
-                    const i = unwrapValue(unwrapOverride(t.o.Pe));
+                    const i = unwrapValue(unwrapOverride(t.o.be));
                     if (!isWrappable(i)) continue;
                     const r = n(i);
                     if (r === undefined) continue;
-                    const s = (o ??= new Map).get(r);
-                    if (s === undefined) o.set(r, [ i ]); else s.push(i);
+                    const l = (o ??= new Map).get(r);
+                    if (l === undefined) o.set(r, [ i ]); else l.push(i);
                 }
             }
             for (let r = 0; r < i; r++) {
                 const i = t[r];
-                let l;
+                let s;
                 if (isWrappable(i) && o !== null) {
                     const e = n(i);
                     if (e !== undefined) {
                         for (const [t, n] of o) {
                             if (!sameKey(t, e)) continue;
-                            l = n.shift();
+                            s = n.shift();
                             if (n.length === 0) o.delete(t);
                             break;
                         }
                     }
                 }
-                if (l !== undefined) {
-                    if (unwrapValue(e[r]) !== l) e[r] = l;
+                if (s !== undefined) {
+                    if (unwrapValue(e[r]) !== s) e[r] = s;
                     stagedApply(e[r], i, n);
                 } else {
                     const t = unwrapValue(e[r]);
@@ -409,15 +407,15 @@ function createOptimisticStoreNext(e, t, n) {
     // Object merge; also the degenerate root-kind-change shape (arrays accept
     // keyed writes/deletes, so a wholesale restatement still lands staged).
         for (const o of Reflect.ownKeys(t)) {
-        if (i && o === "length") continue;
+        if (i && o === "length" || o === $OWNER) continue;
         const r = t[o];
-        const l = unwrapValue(e[o]);
-        if (l === r) continue;
-        if (isWrappable(r) && isWrappable(l) && Array.isArray(r) === Array.isArray(l)) {
+        const s = unwrapValue(e[o]);
+        if (s === r) continue;
+        if (isWrappable(r) && isWrappable(s) && Array.isArray(r) === Array.isArray(s)) {
             // Different-keyed entities never merge (tentative-channel parity):
             // the incoming object replaces the slot wholesale.
             if (n !== null) {
-                const t = n(l);
+                const t = n(s);
                 const i = n(r);
                 if (t !== undefined && i !== undefined && !sameKey(t, i)) {
                     e[o] = r;
@@ -425,12 +423,12 @@ function createOptimisticStoreNext(e, t, n) {
                 }
             }
             stagedApply(e[o], r, n);
-        } else if (!isEqual(l, r) && !targetsEqual(l, r)) {
+        } else if (!isEqual(s, r) && !targetsEqual(s, r)) {
             e[o] = r;
         }
     }
     for (const n of Reflect.ownKeys(e)) {
-        if (i && n === "length" || n in t) continue;
+        if (i && n === "length" || n === $OWNER || n in t) continue;
         delete e[n];
     }
 }
@@ -453,50 +451,49 @@ function createOptimisticStoreNext(e, t, n) {
         const e = liveTransition(n);
         if (e !== null) globalQueue.initTransition(e);
     }
-    const i = e.v;
-    // Patch channel (override-application site): the draft IS the intended
-    // visible state; prev is the view before these overrides apply. Bypasses
-    // the transition stash — optimism is visible in flight.
-        if (e.pc !== null && e.pc.p !== null) patchHooks.emitPatchOptimistic(e, t, optimisticView(e, i));
-    // Row-ops channel (family increment 2): optimistic STRUCTURE on an array
-    // rides node overrides — it never enters the reconcile walk — so a driven
-    // list must get its structural ops here, lane-timed. Identity diff of the
-    // pre-write optimistic view against the draft; aligned writes emit nothing.
-        if (e.pc !== null && e.pc.ro !== null && Array.isArray(t)) {
-        const n = optimisticView(e, i);
-        if (Array.isArray(n)) {
-            const i = buildIdentityRowOps(n, t);
-            if (i !== null) rowHooks.emitRowOpsOptimistic(e, t, i);
-        }
-    }
-    const visible = (t, n) => {
+    // The write is judged against what ordinary readers SEE, not against the
+    // committed backing slot: under an adoption hold (#3074) `t.v` is already
+    // the truth a live transaction is holding, and an optimistic write equal
+    // to it compared as a no-op — no override, no lane, and the screen kept
+    // the pre-hold value until the transaction committed (#3330's store
+    // twin: `s.v = 1` after a `yield` while the derive had already staged
+    // `v: 1`). Signal parity: the override reveals on its lane now, with its
+    // derivations; the held truth reveals on the transaction's schedule.
+        const i = heldMaskView(e) ?? e.v;
+    // Compare RAWS on both sides (`nv` below is unwrapped already). A chained
+    // target's `old` is the inner store's proxy, whose reads hand back inner
+    // child PROXIES; the draft's clone holds the inner raws. Comparing the two
+    // as-is marked every untouched row changed, and the overlay then served
+    // each from an override as a fresh non-chained target — row identities
+    // churned for the life of the action and snapped back at settle (#3323).
+        const visible = (t, n) => {
         const i = e.n?.[t];
-        return i !== undefined && hasActiveOverride(i) ? unwrapOverride(i.o?.Pe) : n;
+        return unwrapValue(i !== undefined && hasActiveOverride(i) ? unwrapOverride(i.o?.be) : n);
     };
     const visiblePresent = t => {
         const n = e.h?.[t];
-        return n !== undefined && hasActiveOverride(n) ? !!unwrapOverride(n.o?.Pe) : t in i;
+        return n !== undefined && hasActiveOverride(n) ? !!unwrapOverride(n.o?.be) : t in i;
     };
     let o = false;
     const r = Array.isArray(t);
     for (const n of Reflect.ownKeys(t)) {
-        if (r && n === "length") continue;
-        const l = unwrapValue(t[n]);
+        if (r && n === "length" || n === $OWNER) continue;
+        const s = unwrapValue(t[n]);
         if (!visiblePresent(n)) {
             // Optimistic add: value node + presence node + membership bump.
-            setSignal(getNode(e, n, i[n]), () => l);
+            setSignal(getNode(e, n, i[n]), () => s);
             setSignal(getHasNode(e, n, n in i), true);
             o = true;
         } else {
             const t = visible(n, i[n]);
-            if (!isEqual(t, l) && !targetsEqual(t, l)) {
-                setSignal(getNode(e, n, t), () => l);
+            if (!isEqual(t, s) && !targetsEqual(t, s)) {
+                setSignal(getNode(e, n, t), () => s);
                 if (r) o = true;
             }
         }
     }
     for (const n of Reflect.ownKeys(i)) {
-        if (r && n === "length") continue;
+        if (r && n === "length" || n === $OWNER) continue;
         if (n in t || !visiblePresent(n)) continue;
         // Optimistic delete: node reads undefined, presence flips, membership bumps.
                 setSignal(getNode(e, n, i[n]), () => undefined);
@@ -521,7 +518,7 @@ function createOptimisticStoreNext(e, t, n) {
         e.pb = stagedTruthPB.get(e) ?? null;
     if (e.pb !== null) stagedTruthPB.delete(e);
     (e.fam.overlaid ??= new Set).add(e);
-    GlobalQueue._n?.(e.fam.px ?? e.px);
+    GlobalQueue.Nn?.(e.fam.px ?? e.px);
 }
 
 /** Optimistic-view composition for snapshot/deep (O1: snapshot is the CURRENT
@@ -540,7 +537,7 @@ function createOptimisticStoreNext(e, t, n) {
         for (const e of Reflect.ownKeys(i)) {
             const n = i[e];
             if (!hasActiveOverride(n)) continue;
-            const o = unwrapOverride(n.o?.Pe);
+            const o = unwrapOverride(n.o?.be);
             if (e === "length" && Array.isArray(t)) {
                 if (t.length !== o) ensure().length = o;
             } else if (!isEqual(t[e], o)) ensure()[e] = o;
@@ -551,7 +548,7 @@ function createOptimisticStoreNext(e, t, n) {
         for (const e of Reflect.ownKeys(o)) {
             const i = o[e];
             if (!hasActiveOverride(i)) continue;
-            const r = !!unwrapOverride(i.o?.Pe);
+            const r = !!unwrapOverride(i.o?.be);
             if (!r && e in (n ?? t)) delete ensure()[e];
         }
     }
@@ -561,12 +558,16 @@ function createOptimisticStoreNext(e, t, n) {
 function applyTentative(e, t, n) {
     const i = e.pb ?? e.v;
     const o = optimisticView(e, i);
-    const r = e.fam.map;
-    const l = Array.isArray(t);
-    if (Array.isArray(o) !== l) return;
+    const r = e.fam;
+    const s = Array.isArray(t);
+    if (Array.isArray(o) !== s) return;
  // kind change at root: flat overrides below
-        const s = [];
-    const u = l ? [ ...t ] : shallowWithSymbols(t);
+        const l = [];
+    let u;
+    if (s) u = [ ...t ]; else {
+        u = {};
+        for (const e of Reflect.ownKeys(t)) if (e !== $OWNER) u[e] = t[e];
+    }
     const match = (e, t) => {
         if (!isWrappable(e) || !isWrappable(t)) return null;
         if (rawValuesUsed && (isRawValue(e) || isRawValue(t))) return null;
@@ -578,15 +579,15 @@ function applyTentative(e, t, n) {
             // channel — NaN keys are self-equal.
                         if (i !== undefined && o !== undefined && !sameKey(i, o)) return null;
         }
-        return r.get(unwrapValue(e)) ?? null;
+        return lookupTarget(unwrapValue(e), r) ?? null;
     };
-    if (l) {
+    if (s) {
         const e = o;
         let i = null;
         for (let o = 0; o < t.length; o++) {
             const r = t[o];
             if (!isWrappable(r)) continue;
-            let l;
+            let s;
             if (n) {
                 const t = n(r);
                 if (t !== undefined) {
@@ -606,30 +607,31 @@ function applyTentative(e, t, n) {
                         }
                     }
                     const o = i.get(t);
-                    if (o === undefined) l = undefined; else if (Array.isArray(o)) {
-                        l = unwrapValue(e[o.shift()]);
+                    if (o === undefined) s = undefined; else if (Array.isArray(o)) {
+                        s = unwrapValue(e[o.shift()]);
                         if (o.length === 1) i.set(t, o[0]);
                     } else {
-                        l = unwrapValue(e[o]);
+                        s = unwrapValue(e[o]);
                         i.delete(t);
                     }
-                } else l = unwrapValue(e[o]);
-            } else l = unwrapValue(e[o]);
-            const a = match(l, r);
+                } else s = unwrapValue(e[o]);
+            } else s = unwrapValue(e[o]);
+            const a = match(s, r);
             if (a !== null) {
                 // Keep the existing row in the slot (identity preserved); recurse.
-                u[o] = unwrapValue(l);
-                s.push([ a, r ]);
+                u[o] = unwrapValue(s);
+                l.push([ a, r ]);
             }
         }
     } else {
         for (const e of Reflect.ownKeys(t)) {
+            if (e === $OWNER) continue;
             const n = unwrapValue(o[e]);
             const i = t[e];
             const r = match(n, i);
             if (r !== null) {
                 u[e] = n;
-                s.push([ r, i ]);
+                l.push([ r, i ]);
             }
         }
     }
@@ -639,13 +641,7 @@ function applyTentative(e, t, n) {
     e.pb = null;
     notifyOptimisticWrites(e, u);
     e.pb = a;
-    for (let e = 0; e < s.length; e++) applyTentative(s[e][0], unwrapValue(s[e][1]), n);
-}
-
-function shallowWithSymbols(e) {
-    const t = {};
-    for (const n of Reflect.ownKeys(e)) t[n] = e[n];
-    return t;
+    for (let e = 0; e < l.length; e++) applyTentative(l[e][0], unwrapValue(l[e][1]), n);
 }
 
 export { createOptimisticStoreNext, notifyOptimisticWrites, optimisticView, transitionHoldsOptimism };

package/dist/prod/store/next/projection.js

@@ -215,8 +215,8 @@ function runProjectionComputedNext(e, t, r, i, o) {
     // for the whole first flight — the derive works a detached shadow of the
     // seed so draft writes cannot tear through to readers (#2988). Every commit
     // point reconciles the shadow through the normal commit path.
-        const u = n.Ne ? JSON.parse(JSON.stringify(e[$TARGET][STORE_VALUE])) : null;
-    const l = wrapDraft(e, () => !c || n.o?.Ie === s, o);
+        const u = n.Ae ? JSON.parse(JSON.stringify(e[$TARGET][STORE_VALUE])) : null;
+    const l = wrapDraft(e, () => !c || n.o?.Pe === s, o);
     storeSetterNext(l, o => {
         s = t(u ?? o);
         c = true;
@@ -230,7 +230,7 @@ function runProjectionComputedNext(e, t, r, i, o) {
             i ? i(write, t) : write();
         };
         const l = handleAsync(n, s, commit);
-        if (!n.Ne) commit(l);
+        if (!n.Ae) commit(l);
     }, false);
     return n;
 }