@solidjs/signals 2.0.0-rc.16 → 2.0.0-rc.17

package/dist/prod/core/scheduler.js

@@ -14,6 +14,8 @@ import { runHeap, enqueueSub, deleteFromHeap } from "./heap.js";
 
 import { devCheckQuiescent } from "./invariants.js";
 
+import { rethrowCleanupError } from "./owner.js";
+
 // Optional-module hooks: module bindings, not `GlobalQueue` statics, so a
 // bundle that never imports the installing module never assigns them — its
 // minifier folds every guarded call site (and the branch behind it) away.
@@ -38,12 +40,12 @@ let endLanesHook = null;
 
 let lanesBlockedHook = null;
 
-function installLaneHooks(e, n, o, l, t, s, u, i, r) {
+function installLaneHooks(e, n, o, t, l, s, u, i, r) {
     laneReadHook = e;
     laneStageHook = n;
     laneOutcomeHook = o;
-    laneWriteHook = l;
-    applyGuessesHook = t;
+    laneWriteHook = t;
+    applyGuessesHook = l;
     laneSeamsHook = s;
     laneCorrectionsHook = u;
     endLanesHook = i;
@@ -73,12 +75,12 @@ let boundarySeamHook = null;
 
 let heldRunHook = null;
 
-function installBoundaryHooks(e, n, o, l, t) {
+function installBoundaryHooks(e, n, o, t, l) {
     catchHook = e;
     freshHook = n;
     hiddenHook = o;
-    boundarySeamHook = l;
-    heldRunHook = t;
+    boundarySeamHook = t;
+    heldRunHook = l;
 }
 
 /** Store (store/store.ts): `park` — the flush parked into `t`: the store
@@ -287,16 +289,16 @@ let judge = null;
 }
 
 function blockedBy(e, n, o = false) {
-    for (let l = 0; l < e.length; l++) {
-        const t = e[l];
-        if (!(t.m & STATUS_PENDING) || t.R & REACTIVE_DISPOSED || t.l & CONFIG_GUESS || t.T.Re !== null && txOf(t) !== n || o && !ownSource(t, n)) continue;
+    for (let t = 0; t < e.length; t++) {
+        const l = e[t];
+        if (!(l.m & STATUS_PENDING) || l.R & REACTIVE_DISPOSED || l.l & CONFIG_GUESS || l.T.Re !== null && txOf(l) !== n || o && !ownSource(l, n)) continue;
         // The frame's own pending observer (off screen: this one holds nothing;
         // the next listed node may).
-                if (t.i === EFFECT_RENDER) {
-            if (onScreen(t, judge ?? n)) return true;
+                if (l.i === EFFECT_RENDER) {
+            if (onScreen(l, judge ?? n)) return true;
             continue;
         }
-        for (let e = t.o; e !== null; e = e.t) {
+        for (let e = l.o; e !== null; e = e.t) {
             const o = e.u;
             // A frame reader: a render effect, or a stale reader of the flight
             // (REACTIVE_FRAME_READ — a verdict reader, `observeFlight`; lane work,
@@ -399,9 +401,9 @@ function deferZombie(e) {
 
 /** The nodes under `owner` a transaction other than `t` holds (boundaries.ts:
  * what an earlier hold staged under a re-armed boundary). */ function heldUnder(e, n, o) {
-    for (let l = e.De; l !== null; l = l.pe) {
-        if ((l.l & (CONFIG_HELD | CONFIG_OVERRIDE)) === CONFIG_HELD && txOf(l) !== n) o(l);
-        heldUnder(l, n, o);
+    for (let t = e.De; t !== null; t = t.pe) {
+        if ((t.l & (CONFIG_HELD | CONFIG_OVERRIDE)) === CONFIG_HELD && txOf(t) !== n) o(t);
+        heldUnder(t, n, o);
     }
 }
 
@@ -498,6 +500,8 @@ function schedule() {
 function haltReactivity(e) {
     if (halted) return;
     halted = true;
+    // A cleanup error collected before the halt is dropped (owner.ts).
+        rethrowCleanupError(true);
     let n = "[REACTIVITY_HALTED]";
     // Surface the cause here too: callers rethrow it, but a creation-time throw
     // unwinds through ancestor recomputes that convert it to status instead of
@@ -513,6 +517,15 @@ function haltReactivity(e) {
     o && o(e);
 }
 
+/**
+ * Dev: `haltReactivity`, located at `subject` — the computation the uncaught
+ * error escaped from — for the REACTIVITY_HALTED message's owner path. Call
+ * sites pick it in dev builds only (`haltReactivity(e)` in production), so
+ * production keeps the one-argument halt and its bytes unchanged.
+ */ function haltReactivityAt(e, n) {
+    haltReactivity(e);
+}
+
 // Logs on the first write after a halt so a frozen interaction is traceable.
 function notifyHalted() {
     if (haltNotified) return;
@@ -664,7 +677,7 @@ class GlobalQueue {
         // This flush's own runs, the lanes' reveals, and the landings' held runs
         // are collected apart and ordered below.
                 const o = this.un;
-        const l = this.un = [ [], [] ];
+        const t = this.un = [ [], [] ];
         // The passes that read this frame's stagings as the screen read held
         // writes if it parked: the lane seam re-derives them on the committed
         // world (a lane's runs wait this round).
@@ -691,8 +704,8 @@ class GlobalQueue {
         // parked (something async below) — the window is the frame's, the marks
         // are its transaction's; else they release at the seam, verdict-only,
         // nothing to show (affects.ts).
-                const t = n && liveTx(n);
-        releaseAmbientMarksHook?.(t);
+                const l = n && liveTx(n);
+        releaseAmbientMarksHook?.(l);
         // The effect phase: lane work first (displayed ahead of the frame), then
         // this flush's runs, then the runs the landings held from earlier
         // flushes — as one pass would have queued them (#3540: a shell
@@ -700,14 +713,14 @@ class GlobalQueue {
         // write; #3528: a display-ahead swap before the count it is shown
         // beside). A parked frame's runs wait with its transaction instead: the
         // effect phase applies a committed frame.
-                const s = t !== null;
+                const s = l !== null;
         for (let e = 0; e < 2; e++) {
-            if (s) append(t.un[e], o[e]);
+            if (s) append(l.un[e], o[e]);
             // The plain flush — no reveal, no landing, not parked — has nothing to
             // order around its own runs: they are the queue as they stand (the
             // same array, not a copy; `run` takes it whole). Every other seam
             // builds the ordered queue above.
-                        this.un[e] = s || l[e].length || this.un[e].length ? l[e].concat(s ? [] : o[e], this.un[e]) : o[e];
+                        this.un[e] = s || t[e].length || this.un[e].length ? t[e].concat(s ? [] : o[e], this.un[e]) : o[e];
         }
         if (deferredZombies.length !== 0) {
             // Survivors are the displayed frame of a held pass: they rerun for the
@@ -749,8 +762,8 @@ class GlobalQueue {
      *
      * A boundary between the observer and the root (boundaries.ts) is asked
      * first: a fallback catches what is not ready under it, and the root
-     * never hears of it. */    notify(e, n, o, l) {
-        if (catchHook?.(e, o & n, l)) return true;
+     * never hears of it. */    notify(e, n, o, t) {
+        if (catchHook?.(e, o & n, t)) return true;
         if (n & STATUS_PENDING) {
             if (o & STATUS_PENDING) {
                 // A pass that went pending holds its frame: the async's own
@@ -932,7 +945,7 @@ function commitPendingNode(e) {
     // commit beneath a flight publishes its inputs (A15 reveal corollary,
     // #3305): a reveal of it must observe, not show the pre-flight value.
         const o = e.se === NOT_PENDING && (n.m & STATUS_PENDING) !== 0;
-    const l = e.l & CONFIG_STAGED_ERROR;
+    const t = e.l & CONFIG_STAGED_ERROR;
     // An answer commits: the error it replaces leaves the display (D-41).
         if (!o && n.T) n.T.de = undefined;
     e.l = o ? e.l & -1048833 | CONFIG_INPUTS_PUBLISHED : e.l & -3147137;
@@ -940,7 +953,7 @@ function commitPendingNode(e) {
     // show, through the ordinary error path (`stageError`). Its readers first
     // see it in the cycle after this seam: a tracked re-read there is not a
     // retry (`read`), or a boundary re-derived by it would retry it forever.
-        if (l) {
+        if (t) {
         const o = e.se;
         e.se = NOT_PENDING;
         e.ie = clock + 1;
@@ -954,7 +967,7 @@ function commitPendingNode(e) {
         // the landed value's commit (A19 exc. 2, #3178): verdict-quiet through
         // the reveal. (The sweep of a node still in flight is not a landing.)
         // The A28 stash goes with it.
-                if (n.T != null) n.T.Ve = false, n.T.Be = NOT_PENDING;
+                if (n.T != null) n.T.Ve = false, n.T.je = NOT_PENDING;
         // An effect with a staged value was born held (L2): its first run is
         // this commit's, not its creation's (A29) — queue it now.
                 if (e.i && e.i !== EFFECT_TRACKED) {
@@ -1018,10 +1031,13 @@ function flush(e) {
     while (scheduled) {
         globalQueue.flush();
     }
+    // A cleanup that threw during the drain, now that the drain is complete
+    // (owner.ts).
+        rethrowCleanupError();
 }
 
 function runQueue(e, n) {
     for (let o = 0; o < e.length; o++) e[o](n);
 }
 
-export { GlobalQueue, MAINLINE_QUESTION, ROOT_ERROR_HOOK, actionDepth, applyGuessesHook, blocked, boundarySeamHook, bumpNotifyEpoch, catchHook, clock, commitPendingNode, deferZombie, dirtyQueue, endLanesHook, enforceLoadingBoundary, enterAction, exitAction, externalUntrackHook, flush, flushTransaction, freshHook, globalQueue, haltReactivity, heldRunHook, heldTrim, heldUnder, hiddenHook, holdNode, insertSubs, installBoundaryHooks, installLaneHooks, installMarkHooks, installStoreHooks, installVerdictHooks, joinFuture, joinPassTx, laneCorrectionsHook, laneDirty, laneOutcomeHook, laneReadHook, laneSeamsHook, laneStageHook, laneWriteHook, lanesBlockedHook, list, liveTx, merge, newTransaction, nextQuestion, notifyEpoch, observeFlightHook, ownFlights, passLane, passTx, question, queuePendingNode, releaseAmbientMarksHook, releaseMarksHook, releaseQueues, reruns, resetErrorHalt, resolveTx, sameLane, schedule, setExternalHooks, setPassLane, setQuestion, stagedReaders, staleReader, storeCommitHook, storeParkHook, txOf, unhold, wireExternalSourceHook };
+export { GlobalQueue, MAINLINE_QUESTION, ROOT_ERROR_HOOK, actionDepth, applyGuessesHook, blocked, boundarySeamHook, bumpNotifyEpoch, catchHook, clock, commitPendingNode, deferZombie, dirtyQueue, endLanesHook, enforceLoadingBoundary, enterAction, exitAction, externalUntrackHook, flush, flushTransaction, freshHook, globalQueue, haltReactivity, haltReactivityAt, heldRunHook, heldTrim, heldUnder, hiddenHook, holdNode, insertSubs, installBoundaryHooks, installLaneHooks, installMarkHooks, installStoreHooks, installVerdictHooks, joinFuture, joinPassTx, laneCorrectionsHook, laneDirty, laneOutcomeHook, laneReadHook, laneSeamsHook, laneStageHook, laneWriteHook, lanesBlockedHook, list, liveTx, merge, newTransaction, nextQuestion, notifyEpoch, observeFlightHook, ownFlights, passLane, passTx, question, queuePendingNode, releaseAmbientMarksHook, releaseMarksHook, releaseQueues, reruns, resetErrorHalt, resolveTx, sameLane, schedule, setExternalHooks, setPassLane, setQuestion, stagedReaders, staleReader, storeCommitHook, storeParkHook, txOf, unhold, wireExternalSourceHook };

package/dist/prod/core/verdict.js

@@ -175,7 +175,7 @@ let probeFound = false;
  * a router's link claim probing inside the computation that creates the
  * anchor). A throw still reaches the pass through `untrack`. */ function markVerdictReader(e) {
     let t = context;
-    if (t?.je) t = t.Ye;
+    if (t?.Qe) t = t.Ye;
     if (t !== null && tracking) {
         t.l |= CONFIG_VERDICT;
         t.R |= REACTIVE_PROBED;
@@ -318,6 +318,9 @@ let probeFound = false;
         const u = (n.m & STATUS_PENDING) !== 0 && !quietPending(n);
         if (e.l & CONFIG_GUESS) {
             if (probing && (u || e.se !== NOT_PENDING && (!e.xe || !e.xe(e.T.v, e.se)))) probeFound = true;
+            // A lane a correction folded under (D-34): `latest()` shows the hold's
+            // world whole — the truth beneath each guess, else what it covered.
+                        if (latestActive && r.folded) return r.folded(null, e);
             return e.T.v;
         }
         if (probing && u) probeFound = true;

package/dist/prod/map.js

@@ -301,7 +301,7 @@ function updateKeyedMap() {
                 this.ct && (this.ct = []);
                 this.lt && (this.lt = []);
             }
-            if (this.H && !this.ht[0]) {
+            if (this.H && !this.ht.length) {
                 // an aborted fallback attempt leaves an owner without a mapping;
                 // dispose it before re-creating
                 this.tn[0]?.dispose();
@@ -539,7 +539,7 @@ function updateRepeat() {
                 // Reset offset to match the cleared data (#2767, repro 2).
                                 this.dt = 0;
             }
-            if (this.H && !this.ht[0]) {
+            if (this.H && !this.ht.length) {
                 // an aborted fallback attempt leaves an owner without a mapping;
                 // dispose it before re-creating
                 this.tn[0]?.dispose();

package/dist/prod/signals.js

@@ -292,7 +292,12 @@ function createMemo(e, t) {
             o = undefined;
         }
         runWithOwner(n, () => {
-            effect(() => (c(), o = getOwner()), t => {
+            effect(() => {
+                const e = getOwner();
+                o = e;
+                c();
+                return e;
+            }, t => {
                 o = undefined;
                 r?.();
                 const n = (e.effect || e)?.();
@@ -334,14 +339,14 @@ function createMemo(e, t) {
     // or an already-displayed guess would satisfy it in a later slice. (REDERIVE
     // after: the first pass's own error is the promise's rejection.)
         computed(() => {
-        let i, u = false;
+        let u, i = false;
         try {
-            i = e();
+            u = e();
         } catch (e) {
             if (e instanceof NotReadyError) throw e;
             // An error is an answer (D-41): delivered by the same frame rule.
-                        i = unwrapStatusError(e);
-            u = true;
+                        u = unwrapStatusError(e);
+            i = true;
         }
         const s = getOwner();
         // A truth reader waits out a `createDeferred` flight its value derives
@@ -354,9 +359,9 @@ function createMemo(e, t) {
             staleReader(s, resolveTx(a));
             return;
         }
-        if (u) return void queueMicrotask(() => r(i));
-        o?.(i);
-        queueMicrotask(() => t(i));
+        if (i) return void queueMicrotask(() => r(u));
+        o?.(u);
+        queueMicrotask(() => t(u));
     }, {
         Le: n
     }).l |= CONFIG_REDERIVE;
@@ -516,14 +521,14 @@ function createMemo(e, t) {
         // (`saving=true` beside the confirmed `version=1` is a tear no timeline
         // contains). Updates that do not flip the predicate reveal freely.
                 const c = flushTransaction;
-        createRoot(i => {
-            let u;
+        createRoot(u => {
+            let i;
             let s;
             const settle = e => {
-                if (u !== undefined) clearTimeout(u);
+                if (i !== undefined) clearTimeout(i);
                 if (s !== undefined) o.removeEventListener("abort", s);
                 e();
-                i();
+                u();
             };
             // Authoritative: the predicate sees the truth, never the action's own
             // optimistic guess — a guess cannot satisfy the wait for its own
@@ -538,7 +543,7 @@ function createMemo(e, t) {
                 // revealed with the action.
                 if (e && c !== null && globalQueue.q && resolveTx(c).tt !== 0) joinFuture(c);
             });
-            if (t?.timeout !== undefined) u = setTimeout(() => settle(() => n(new TimeoutError)), t.timeout);
+            if (t?.timeout !== undefined) i = setTimeout(() => settle(() => n(new TimeoutError)), t.timeout);
             if (o !== undefined) {
                 s = () => settle(() => n(o.reason));
                 o.addEventListener("abort", s, {

package/dist/prod/store/optimistic.js

@@ -1,12 +1,12 @@
-import { CONFIG_OVERRIDE, CONFIG_AUTO_DISPOSE, NOT_PENDING } from "../core/constants.js";
+import { CONFIG_OVERRIDE, CONFIG_GUESS, EFFECT_RENDER, CONFIG_CHILDREN_FORBIDDEN, NOT_PENDING, CONFIG_SLOT_NODE, CONFIG_AUTO_DISPOSE } from "../core/constants.js";
 
-import { computed, ext, untrack, read, isEqual } from "../core/core.js";
+import { computed, joinPassAt, ext, untrack, read, isEqual } from "../core/core.js";
 
 import { pendingGuessOf, optimisticWrite } from "../core/lanes.js";
 
 import { getOwner } from "../core/owner.js";
 
-import { GlobalQueue, txOf, list, insertSubs, laneDirty, notifyEpoch, schedule } from "../core/scheduler.js";
+import { GlobalQueue, txOf, insertSubs, joinFuture, resolveTx, passLane, list, laneDirty, notifyEpoch, schedule } from "../core/scheduler.js";
 
 import { runProjectionComputed } from "./projection.js";
 
@@ -93,16 +93,16 @@ function notifyOptimisticWrites(e, n) {
         // A chained draft holds the inner store's raws; a raw is the inner slot it
         // resolves to (as a read of it serves) — the row a held write staged is
         // the same row, not a guess over the slot (#3796).
-                const a = n[t];
-        const f = unwrapValue(o && a ? resolveChainedRaw(e, t, a) : a);
+                const u = n[t];
+        const f = unwrapValue(o && u ? resolveChainedRaw(e, t, u) : u);
         if (!(t in i)) {
             guess(getNode(e, t), t, false, f);
             guess(getHasNode(e, t), t, true, true);
             s = true;
         } else {
             const n = i[t];
-            const a = unwrapValue(o && n ? resolveChainedRaw(e, t, n) : n);
-            if (!isEqual(a, f) && !targetsEqual(a, f)) {
+            const u = unwrapValue(o && n ? resolveChainedRaw(e, t, n) : n);
+            if (!isEqual(u, f) && !targetsEqual(u, f)) {
                 guess(getNode(e, t), t, false, f);
                 if (r) s = true;
             }
@@ -122,29 +122,31 @@ function notifyOptimisticWrites(e, n) {
     if (s) {
         const o = r ? n.map(unwrapValue) : shallowKeys(n);
         // The rows the setter removed from the view it saw, by key: a later
-        // re-base over another action's truth must not bring them back.
+        // re-base over another action's truth must not bring them back. A set
+        // (empty or not) marks a keyed arrangement guess (`fold`).
                 let s = null;
-        const a = e.fam.key;
-        if (r && a !== null && a !== undefined) {
+        const u = e.fam.key;
+        if (r && u !== null && u !== undefined) {
+            s = new Set;
             const e = new Set;
             for (let n = 0; n < o.length; n++) {
-                const t = isWrappable(o[n]) ? a(o[n]) : undefined;
+                const t = isWrappable(o[n]) ? u(o[n]) : undefined;
                 if (t !== undefined) e.add(t);
             }
             for (let n = 0; n < i.length; n++) {
                 const t = unwrapValue(i[n]);
-                const r = isWrappable(t) ? a(t) : undefined;
-                if (r !== undefined && !e.has(r)) (s ??= new Set).add(r);
+                const r = isWrappable(t) ? u(t) : undefined;
+                if (r !== undefined && !e.has(r)) s.add(r);
             }
         }
         optimisticWrite(getContainerNode(e), new LaneView(o, t, s));
     }
     if (e.dk !== null) optimisticWrite(e.dk, {});
     markOverlaid(e);
-    const a = optStaged.get(e);
-    if (a === undefined) return null;
+    const u = optStaged.get(e);
+    if (u === undefined) return null;
     optStaged.delete(e);
-    return a;
+    return u;
 }
 
 /** The container comparator's lane arm (store.ts `containerEquals`): an
@@ -228,18 +230,18 @@ function arrangementEqual(e, n, t) {
             }
         }
         for (let s = 0; s < n.length; s++) {
-            const a = n[s];
+            const u = n[s];
             let f;
-            if (isWrappable(a)) {
+            if (isWrappable(u)) {
                 if (o !== null) {
-                    const e = t(a);
+                    const e = t(u);
                     if (e !== undefined) f = o.get(e);
                 } else if (s < i && isWrappable(unwrapValue(r[s]))) f = r[s];
             }
             if (f !== undefined) {
-                if (unwrapValue(f) !== a) reconcileDraft(f, a, t);
+                if (unwrapValue(f) !== u) reconcileDraft(f, u, t);
                 if (e[s] !== f) e[s] = f;
-            } else if (unwrapValue(e[s]) !== a) e[s] = a;
+            } else if (unwrapValue(e[s]) !== u) e[s] = u;
         }
         if (e.length !== n.length) e.length = n.length;
         return;
@@ -268,66 +270,105 @@ function arrangementEqual(e, n, t) {
  * node is born for it as the lane's derivation), on `length` only when the
  * committed length differs, and as the `LaneView`'s base for structural
  * reads. Unkeyed families compose
- * positionally — the guess stands as written (the documented residue). */ GlobalQueue.an = (e, n) => {
-    const t = e.O;
-    if (t === undefined || e.ze !== $TRACK) return;
-    const i = e.T.v;
-    if (!(i instanceof LaneView)) return;
-    if (!Array.isArray(n) || !Array.isArray(i.rows)) {
-        i.base = n;
+ * positionally — the guess stands as written (the documented residue). */ GlobalQueue.an = (e, n, t) => {
+    if (!t) return fold(e, n);
+    const i = e.O;
+    if (i === undefined || e.ze !== $TRACK) return;
+    const r = e.T.v;
+    if (!(r instanceof LaneView)) return;
+    if (!Array.isArray(n) || !Array.isArray(r.rows)) {
+        r.base = n;
         return;
     }
-    const r = t.fam?.key ?? null;
-    if (r === null) return;
-    const o = new Map;
+    const o = i.fam?.key ?? null;
+    if (o === null) return;
+    const s = new Map;
     for (let e = 0; e < n.length; e++) {
         const t = n[e];
-        const i = isWrappable(t) ? r(t) : undefined;
-        if (i !== undefined && !o.has(i)) o.set(i, t);
+        const i = isWrappable(t) ? o(t) : undefined;
+        if (i !== undefined && !s.has(i)) s.set(i, t);
     }
-    const s = new Set;
-    const a = [];
-    const f = i.rows;
-    for (let e = 0; e < f.length; e++) {
-        const n = f[e];
-        const t = isWrappable(n) ? r(n) : undefined;
-        const i = t !== undefined ? o.get(t) : undefined;
+    const u = new Set;
+    const f = [];
+    const a = r.rows;
+    for (let e = 0; e < a.length; e++) {
+        const n = a[e];
+        const t = isWrappable(n) ? o(n) : undefined;
+        const i = t !== undefined ? s.get(t) : undefined;
         if (i !== undefined) {
-            a.push(i);
-            s.add(t);
-        } else a.push(n);
+            f.push(i);
+            u.add(t);
+        } else f.push(n);
     }
-    const u = i.removed;
+    const l = r.removed;
     for (let e = 0; e < n.length; e++) {
         const t = n[e];
-        const i = isWrappable(t) ? r(t) : undefined;
-        if (i !== undefined && !s.has(i) && (u === null || !u.has(i))) a.push(t);
+        const i = isWrappable(t) ? o(t) : undefined;
+        if (i !== undefined && !u.has(i) && (l === null || !l.has(i))) f.push(t);
     }
-    i.rows = a;
-    i.base = a;
-    const l = txOf(e);
-    const c = committed(t);
-    const d = t.n;
-    for (let e = 0; e < a.length; e++) {
-        const n = d?.[e];
+    r.rows = f;
+    r.base = f;
+    const c = txOf(e);
+    const d = committed(i);
+    const p = i.n;
+    for (let e = 0; e < f.length; e++) {
+        const n = p?.[e];
         // A slot the lane does not own shows the committed row: it becomes the
         // lane's only where the composed row is another row (by key — the same
         // key's new object is the same row, its target adopted it).
                 if (n === undefined) {
-            if (!sameRow(c[e], a[e], r)) laneSet(getNode(t, e), a[e], l);
-        } else if (!sameRow(n.l & CONFIG_OVERRIDE ? n.T.v : c[e], a[e], r)) laneSet(n, a[e], l);
+            if (!sameRow(d[e], f[e], o)) laneSet(getNode(i, e), f[e], c);
+        } else if (!sameRow(n.l & CONFIG_OVERRIDE ? n.T.v : d[e], f[e], o)) laneSet(n, f[e], c);
     }
-    if (d !== null) {
-        for (let e = a.length; ;e++) {
-            const n = d[e];
+    if (p !== null) {
+        for (let e = f.length; ;e++) {
+            const n = p[e];
             if (n === undefined) break;
-            laneSet(n, undefined, l);
+            laneSet(n, undefined, c);
         }
-        const e = d.length;
-        if (e !== undefined && (e.l & CONFIG_OVERRIDE || c.length !== a.length)) laneSet(e, a.length, l);
+        const e = p.length;
+        if (e !== undefined && (e.l & CONFIG_OVERRIDE || d.length !== f.length)) laneSet(e, f.length, c);
     }
 };
 
+/** D-34 for a keyed arrangement guess: rows by key, not positions. A
+ * current truth that differs folds into the hold beneath it instead of
+ * voiding the lane: the guess stays the lane's value and the screen's until
+ * the hold commits, where rows match by key, and the graph outside the lane
+ * re-derives from the truth now (`foldedRead`). A confirmation is silent
+ * (A17): only truth readers are told. True: the lane stages the truth
+ * beneath (`laneWrite`). */ function fold(e, n) {
+    const t = e.O?.k;
+    const i = txOf(e);
+    // A guess the screen never showed is void at the correction (D-34); a
+    // keyed arrangement guess's view carries its removed-keys set.
+        if (!i.ke || !(t?.l & CONFIG_OVERRIDE) || !t.T.v?.removed) return false;
+    const r = e.T.v;
+    if ((!e.xe || !e.xe(r, n)) && !GlobalQueue.nn(r, n)) {
+        i.folded = foldedRead;
+        insertSubs(e);
+    } else GlobalQueue.sn?.(i);
+    joinFuture(resolveTx(i._parent ?? i));
+    return true;
+}
+
+/** A folded lane's guess read by a deriving pass outside the lane, tracked
+ * or not (`untrack` is about dependencies, not about which world a pass
+ * derives from), or by `latest()` (`c` null): the hold's world — the truth
+ * staged beneath the guess, else the value it covered — and the pass joins
+ * the hold. Lane passes and the screen keep the guess: held truth is masked
+ * from lane passes only (#3164). The store's own derive reconciles its
+ * landings against the arrangement the guesses made: it is the author, not
+ * a reader. */ function foldedRead(e, n) {
+    if (e !== null) {
+        if (!(n.l & CONFIG_GUESS) || passLane !== null || e.i === EFFECT_RENDER || e.l & CONFIG_CHILDREN_FORBIDDEN || n.O?.fam?.node === e) return NOT_PENDING;
+        const t = txOf(n);
+        joinPassAt(e, resolveTx(t._parent ?? t));
+    }
+    if (n.se !== NOT_PENDING) return n.se;
+    return n.l & CONFIG_SLOT_NODE ? GlobalQueue.fn(n) : n.Ie;
+}
+
 function sameRow(e, n, t) {
     if (e === n) return true;
     if (!isWrappable(e) || !isWrappable(n)) return false;
@@ -521,11 +562,11 @@ i = false) {
     if (s !== null) {
         for (const e of Reflect.ownKeys(s)) {
             const o = s[e];
-            let a;
-            if (o.l & CONFIG_OVERRIDE) a = t(o); else if (!i || (a = pendingGuessOf(o)) === NOT_PENDING) continue;
-            const f = !!a;
-            const u = r ?? n;
-            if (!f && e in u) delete ensure()[e];
+            let u;
+            if (o.l & CONFIG_OVERRIDE) u = t(o); else if (!i || (u = pendingGuessOf(o)) === NOT_PENDING) continue;
+            const f = !!u;
+            const a = r ?? n;
+            if (!f && e in a) delete ensure()[e];
         }
     }
     return r ?? n;
@@ -538,7 +579,7 @@ function createOptimisticStore(e, n, t) {
     // createProjectionInternal).
         const o = i ? n || {} : e;
     const s = r?.key === undefined ? "id" : r.key;
-    const a = {
+    const u = {
         map: new WeakMap,
         node: null,
         live: new Set,
@@ -546,8 +587,8 @@ function createOptimisticStore(e, n, t) {
         opt: true,
         key: typeof s === "function" ? s : s === null ? null : e => isWrappable(e) ? e[s] : undefined
     };
-    const f = wrap(o, null, null, a);
-    if (a.shallow) {
+    const f = wrap(o, null, null, u);
+    if (u.shallow) {
         f[$TARGET].s = true;
         markRawIngest(o);
     }
@@ -558,11 +599,11 @@ function createOptimisticStore(e, n, t) {
             loadingValue: undefined
         };
         const i = computed(() => {
-            if (!a.node) a.node = getOwner();
+            if (!u.node) u.node = getOwner();
             runProjectionComputed(f, n, s);
         }, t);
         i.l &= ~CONFIG_AUTO_DISPOSE;
-        a.node = i;
+        u.node = i;
     }
     return [ f, e => storeSetter(f, e) ];
 }