@solidjs/signals 2.0.0-rc.19 → 2.0.0-rc.20

package/dist/observe/store/projection.js

@@ -14,6 +14,8 @@ import { getOwner, isDisposed } from "../core/owner.js";
 
 import { question, setQuestion, insertSubs, schedule } from "../core/scheduler.js";
 
+import { optHooks } from "./hooks.js";
+
 import { reconcileState } from "./reconcile.js";
 
 import { wrap, nameStore, storeSetter, runDirect } from "./store.js";
@@ -129,6 +131,7 @@ function cloneState(e, t) {
     // reader the landing leaves unchanged does not re-run to clear it (#4305).
         const r = new NotReadyError(t);
     e.woke = true;
+    optHooks?.ask(e);
     forEachFamilyNode(e, e => {
         if (e.o === null) return;
         // The leaf carries the derive's pending as a propagated copy, as a memo
@@ -164,6 +167,10 @@ function cloneState(e, t) {
     forEachFamilyNode(e, e => {
         if (e.o !== null) settlePendingSource(e, t);
     });
+    // The landing is the derive's change for a reader parked on the derive
+    // itself, whatever status the landing pass began from (an errored derive
+    // re-asked: a reader that met the error has no leaf to learn it from).
+        insertSubs(t);
 }
 
 /** A source's status reached the derive by propagation (core
@@ -192,16 +199,16 @@ function forEachFamilyNode(e, t) {
     const s = e[$TARGET];
     const c = s.fam;
     const a = c.run = (c.run || 0) + 1;
-    let l;
+    let u;
     // Open loading window (seedLoadingValue): the observable store IS commit #0
     // 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 = i.ce ? cloneState(s.v, s.s) : null;
+        const l = i.ce ? cloneState(s.v, s.s) : null;
     // The question a write of this run answers: inside a slice, the slice's
     // (the sync pass); in a continuation — the flight still registered — the
     // flight's (`handleAsync` stamped it with the action that asked).
-        const asking = () => question || (i.T !== null && i.T.Ee !== null ? i.T.de : 0);
+        const asking = () => question || (i.T !== null && i.T.Ee !== null ? i.T.Ie : 0);
     const f = wrapDraft(e, () => c.run === a && !isDisposed(i), n, s.s, 
     // A write after the run returned (a continuation, a callback) arms the
     // drain itself when no landing will.
@@ -213,12 +220,12 @@ function forEachFamilyNode(e, t) {
     // — stages and commits with the flush like a memo's recompute.
         const d = a === 1;
     const pass = () => storeSetter(f, n => {
-        l = t(u ?? n);
-        const commit = t => {
+        u = t(l ?? n);
+        const commit = (t, a = 1) => {
             // Shadow run: commit a detached snapshot, never the shadow itself
             // (adoption takes the value by identity — handing it the live
             // shadow would fuse the draft to the observable store).
-            if (u && (t === undefined || t === u)) t = cloneState(u, s.s);
+            if (l && (t === undefined || t === l)) t = cloneState(l, s.s);
             if (t !== n && t !== undefined) {
                 const write = () => {
                     const o = question;
@@ -237,10 +244,13 @@ function forEachFamilyNode(e, t) {
             // A commit is the derive's change for the readers that observed its
             // flight (linked by `pullFamily`; a settled pull does not link), as
             // a memo's landing is for its readers: one that caught the NotReady
-            // (a fallback value, not pending) re-runs too (#4070).
-                        insertSubs(i);
+            // (a fallback value, not pending) re-runs too (#4070). A pass of a
+            // settled derive has none (`wake` 0): a link left is a stale one a
+            // held frame keeps (A30), from a reader that re-ran since. Woken by
+            // every pass, a reader feeding a key the pass peeks at looped (#4342).
+                        if (a) insertSubs(i);
         };
-        const a = handleAsync(i, l, commit, (e, t) => {
+        const a = handleAsync(i, u, commit, (e, t) => {
             // The flight rejected: the leaves' readers learn it from here —
             // they do not subscribe to the derive. Pending again (a NotReady
             // rejection): the wake, as for the pass. Errored: every live
@@ -250,7 +260,8 @@ function forEachFamilyNode(e, t) {
             if (d && i.m & STATUS_UNINITIALIZED) return;
             if (t) wakeFamily(c); else errorFamily(c);
         });
-        if (!i.ce) commit(a);
+        // (The status is the one before this pass: `recompute` sets it after.)
+                if (!i.ce) commit(a, i.m & (STATUS_PENDING | STATUS_ERROR));
     }, false);
     try {
         d ? runDirect(pass) : pass();

package/dist/observe/store/reconcile.js

@@ -79,7 +79,10 @@ import { $TARGET, markRawIngest, isWrappable, rawValuesUsed, isRawValue } from "
     if (r) markRawIngest(n);
     // The deep witness is bumped once per adoption (none to bump: done).
         let u = e.dk === null;
-    if (Array.isArray(i) !== l) {
+    // A live chained base (a store proxy, §7b) reads the inner store's
+    // current frame, not what the nodes were last told — nothing to diff
+    // against: the fold writes every node (#4361).
+        if (Array.isArray(i) !== l || f[$TARGET]) {
         notifyFold(e, f, n);
         return;
     }
@@ -186,7 +189,10 @@ import { $TARGET, markRawIngest, isWrappable, rawValuesUsed, isRawValue } from "
     let a = 0;
     for (const l in n) {
         const c = n[l];
-        const d = f[l];
+        let d = f[l];
+        // A key under a guess is judged against the guess too (D-34): a truth
+        // equal to the value the guess covered still answers it.
+                if (optHooks && d === c && i !== f) d = i[l];
         const p = c !== null && typeof c === "object";
         if (d === c && (!p || !isOwned(c)) && (s === null || s[l] === undefined || !hasAccessorFlag(s[l]))) {
             if (s?.[l] !== undefined) a++;

package/dist/observe/store/store.js

@@ -1,14 +1,14 @@
 import { attrHooks } from "../core/attribution-hooks.js";
 
-import { CONFIG_MANUAL_WRITE, CONFIG_OVERRIDE, CONFIG_HELD, $REFRESH, NOT_PENDING, STATUS_PENDING, STATUS_ERROR, EFFECT_RENDER, REACTIVE_RECOMPUTING_DEPS, REACTIVE_STAGED_READ, CONFIG_VERDICT, CONFIG_CHILDREN_FORBIDDEN, CONFIG_PROMOTED, REACTIVE_DIRTY, REACTIVE_CHECK } from "../core/constants.js";
+import { CONFIG_MANUAL_WRITE, CONFIG_OVERRIDE, CONFIG_HELD, $REFRESH, NOT_PENDING, STATUS_PENDING, STATUS_ERROR, EFFECT_RENDER, REACTIVE_RECOMPUTING_DEPS, REACTIVE_STAGED_READ, CONFIG_VERDICT, CONFIG_CHILDREN_FORBIDDEN, STATUS_UNINITIALIZED, CONFIG_PROMOTED, REACTIVE_DIRTY, REACTIVE_CHECK } from "../core/constants.js";
 
-import { writeHook, setSignal, isEqual, read, verdict, snapshotCaptureActive, captureWriteSnapshot, context, notePromotedWrite, untrack, slotSignal, stagedScreen, stagedRead } from "../core/core.js";
+import { writeHook, setSignal, isEqual, read, verdict, snapshotCaptureActive, captureWriteSnapshot, context, notePromotedWrite, untrack, slotSignal, stagedScreen, stagedRead, tracking } from "../core/core.js";
 
 import { registerGraph } from "../core/dev.js";
 
 import { signalHook } from "../core/identities.js";
 
-import { setSlotUnobserved } from "../core/graph.js";
+import { link, setSlotUnobserved } from "../core/graph.js";
 
 import { getOwner, getObserver } from "../core/owner.js";
 
@@ -20,7 +20,7 @@ import { lookupTarget, storeOwners, setLookup, $OWNER, isOwned, markDescendants
 
 import { optHooks, affectsHooks } from "./hooks.js";
 
-import { $TARGET, rawValuesUsed, isRawValue, isWrappable, markRawIngest, writeOverride, markRawOne, $RECORD, $PROXY, $TRACK } from "./types.js";
+import { $TARGET, rawValuesUsed, isRawValue, isWrappable, markRawIngest, writeOverride, markRawOne, $RECORD, $PROXY, $TRACK, installShallowView } from "./types.js";
 
 export { markRaw } from "./types.js";
 
@@ -224,7 +224,7 @@ function sameLogicalSlot(e, t, n) {
 
 function releaseSlot(e) {
     const t = e.O;
-    const n = e.Vt;
+    const n = e.gt;
     if (n === $TRACK) {
         if (t.k === e) t.k = null;
     } else if (n === $DEEP) {
@@ -251,7 +251,7 @@ function releaseSlot(e) {
 // holds: its release waits for the commit that resolves it. So does a leaf of
 // a held container (#4146): a mainline write it carried is in the held
 // staging too, where it would read as the hold's until the landing.
-const slotKept = e => e.ie !== NOT_PENDING || e.l & CONFIG_OVERRIDE || e.O.k?.l & CONFIG_HELD;
+const slotKept = e => e.ue !== NOT_PENDING || e.l & CONFIG_OVERRIDE || e.O.k?.l & CONFIG_HELD;
 
 setSlotUnobserved(e => {
     if (slotKept(e)) deferredReleases.add(e); else releaseSlot(e);
@@ -264,7 +264,7 @@ setSlotUnobserved(e => {
  * unchanged stages nothing and holds no one). */ function bornStaged(e, t, n, r) {
     if (t.je && t.je(t.le, n)) return;
     queuePendingNode(t);
-    t.ie = n;
+    t.ue = n;
     const o = e.k;
     if (o === null) return;
  // a node-less staging holds nothing (`stageOn`)
@@ -344,7 +344,7 @@ function getHasNode(e, t) {
         // would have read had the node been there from the write.
                 if (e.pb !== null && !directCommit) {
             t.le = preBatch(e);
-            t.ie = e.pb;
+            t.ue = e.pb;
             queuePendingNode(t);
         }
     }
@@ -361,10 +361,10 @@ function getHasNode(e, t) {
  * re-created, queued, swept and dropped ~7000 container nodes). If the
  * flush parks, the seam materializes and holds the node then
  * (`storeParkHook`) — the one case the staging home exists for. */ function stageOn(e, t) {
-    if (e.k === null && passLane === null && (context === null || globalQueue.q) && !deriveHolds(e)) return;
+    if (e.k === null && passLane === null && (context === null || globalQueue.Y) && !deriveHolds(e)) return;
     const n = getContainerNode(e);
-    if (n.ie === NOT_PENDING) queuePendingNode(n);
-    n.ie = t;
+    if (n.ue === NOT_PENDING) queuePendingNode(n);
+    n.ue = t;
     // A28 (4): a write issued inside a pass outside a flush (a creation-time
     // derive) is promoted at the pass's end — the batch with it.
         if (context !== null) notePromotedWrite(n);
@@ -382,6 +382,7 @@ const storePark = e => {
         const n = foldList[t];
         if (n.k === null && n.pb !== null) holdNode(getContainerNode(n), e);
     }
+    optHooks?.park(e);
 };
 
 function getDeepNode(e) {
@@ -468,16 +469,23 @@ function isOwnAccessor(e, t) {
         n[$OWNER] = t;
         return n;
     }
-    const n = Object.getOwnPropertyDescriptors(e);
-    for (const r of Reflect.ownKeys(n)) {
-        const o = n[r];
-        if (r === "length" && Array.isArray(e)) continue;
-        o.configurable = true;
-        if (!o.get && !o.set) o.writable = true; else t.a = true;
+    // A plain array with no accessors and no named keys beyond `length`
+    // (`kc` counts own keys) clones by `slice()`: the descriptor path
+    // allocates one descriptor per element, O(n) per first draft write (10k
+    // rows: ~10 ms per push).
+        let n;
+    if (!t.a && t.kc <= e.length + 1 && Object.getPrototypeOf(e) === Array.prototype) n = e.slice(); else {
+        const r = Object.getOwnPropertyDescriptors(e);
+        for (const n of Reflect.ownKeys(r)) {
+            const o = r[n];
+            if (n === "length" && Array.isArray(e)) continue;
+            o.configurable = true;
+            if (!o.get && !o.set) o.writable = true; else t.a = true;
+        }
+        n = Array.isArray(e) ? Object.defineProperties([], r) : Object.create(Object.getPrototypeOf(e), r);
     }
-    const r = Array.isArray(e) ? Object.defineProperties([], n) : Object.create(Object.getPrototypeOf(e), n);
-    r[$OWNER] = t;
-    return r;
+    n[$OWNER] = t;
+    return n;
 }
 
 /** Wide plain clone (many keys): null-prototype build, then reset. */ function wideClone(e, t) {
@@ -543,7 +551,7 @@ const plainProto = e => {
     const n = overlayOnto(e, e.sc === 2 ? wideClone(e.v, e) : cloneRaw(e.v, e), t);
     e.pb = n;
     // The staging IS the pending backing: re-point the container node.
-        if (e.k?.ie === t) e.k.ie = n;
+        if (e.k?.ue === t) e.k.ue = n;
     return n;
 }
 
@@ -564,7 +572,7 @@ const plainProto = e => {
         // mainline setter mid-hold publishes mainline; the held keys stay held).
         t = e.pb = cloneRaw(t, e);
         const n = e.k;
-        if (n !== null && !(n.l & CONFIG_HELD)) n.ie = t;
+        if (n !== null && !(n.l & CONFIG_HELD)) n.ue = t;
     } else if (t === null) {
         const n = e.v;
         if (!directCommit) queueFold(e);
@@ -741,7 +749,7 @@ let foldIndex = null;
             if (r.pb === null) continue;
  // folded already (a direct commit)
                         const o = r.k;
-            if (o !== null && o.ie !== NOT_PENDING) {
+            if (o !== null && o.ue !== NOT_PENDING) {
                 // held: commits with its hold
                 foldList.push(r);
                 foldOlds.push(t[n]);
@@ -771,10 +779,10 @@ let foldIndex = null;
 /** Core asks (lanes.ts `covered`): the value a slot node's guess covered.
  * A chained link's committed value is the inner store's at the last
  * read-through — refreshed here, since a guess served the reads since
- * (#3672: the revert compares against the base's live value). */ GlobalQueue.fn = e => {
+ * (#3672: the revert compares against the base's live value). */ GlobalQueue.an = e => {
     const t = e.O;
     if (t.ch) {
-        const n = e.Vt;
+        const n = e.gt;
         const r = t.v;
         if (t.h?.[n] === e) e.le = untrack(() => n in r); else if (t.n?.[n] === e) e.le = untrack(() => unwrapValue(r[n]));
     }
@@ -945,13 +953,18 @@ function heldDerivation(e, t, n) {
     // Optimistic channel: a user's writes on an optimistic family become
     // guesses on the nodes (lanes); the draft is discarded, the committed
     // backing never touched.
-        if (optHooks && userWrite && e.fam?.opt === true) {
-        // The draft is discarded first: the diff reads the target (its nodes
-        // are born from the committed frame, not the draft).
-        e.pb = null;
-        e.wk = null;
-        e.pb = optHooks.writes(e, t);
-        return;
+        if (optHooks && e.fam?.opt === true) {
+        if (userWrite) {
+            // The draft is discarded first: the diff reads the target (its nodes
+            // are born from the committed frame, not the draft).
+            e.pb = null;
+            e.wk = null;
+            e.pb = optHooks.writes(e, t);
+            return;
+        }
+        // The derive's draft: new rows under guessed rows are paired with them
+        // first (D-34, #4329).
+                optHooks.pair(e, t);
     }
     const n = e.v;
     const r = e.n;
@@ -1096,7 +1109,10 @@ function membershipChanged(e, t) {
     } else {
         const o = n[t];
         const i = r[t];
-        if (!isEqual(o, i) && !targetsEqual(o, i)) setSignal(e, typeof i === "function" ? () => i : i);
+        // A live chained `old` (a store proxy, §7b) already reads the inner
+        // store's next frame, not what the node was last told: written, the
+        // node's own equality judging it (#4361).
+                if (n[$TARGET] || !isEqual(o, i) && !targetsEqual(o, i)) setSignal(e, typeof i === "function" ? () => i : i);
     }
 }
 
@@ -1122,7 +1138,8 @@ function hasAccessorFlag(e) {
  * unrelated `a.value` stayed stale until the action settled). A real
  * change still writes, and on a held node still proposes. A live chained
  * `old` (a store proxy, §7b) reflects the inner store, not what the node
- * was last told — written unconditionally, as before.
+ * was last told — written unconditionally, as before; its container too
+ * (#4361).
  *
  * The container is told of an arrangement change when it has structural
  * subscribers OR carries an arrangement guess (S4): for a guessed
@@ -1133,14 +1150,14 @@ function hasAccessorFlag(e) {
  * answers the arrangement — before, only the presence write reached the
  * lane, by accident of being unconditional. */ function notifyFoldTail(e, t, n) {
     const r = e.h;
+    const o = t[$TARGET];
     if (r !== null) {
-        const e = t[$TARGET];
-        for (const o of Reflect.ownKeys(r)) if (e || o in t !== o in n) setSignal(r[o], o in n);
+        for (const e of Reflect.ownKeys(r)) if (o || e in t !== e in n) setSignal(r[e], e in n);
     }
-    const o = e.k;
-    if (o !== null && (o.o !== null || o.l & CONFIG_OVERRIDE)) {
-        const e = Array.isArray(n) && Array.isArray(t) ? arrayStructureChanged(t, n) : membershipChanged(t, n);
-        if (e) notifyContainer(o, n);
+    const i = e.k;
+    if (i !== null && (i.o !== null || i.l & CONFIG_OVERRIDE)) {
+        const e = o || (Array.isArray(n) && Array.isArray(t) ? arrayStructureChanged(t, n) : membershipChanged(t, n));
+        if (e) notifyContainer(i, n);
     }
 }
 
@@ -1195,7 +1212,7 @@ function inDraft(e) {
  * "adoption is eager by contract" — and the node keeps the frame committed
  * readers under a hold still see), `t.v` otherwise. */ function committed(e) {
     const t = e.k;
-    if (t !== null) return t.ie !== NOT_PENDING ? asBacking(t.le) : e.v;
+    if (t !== null) return t.ue !== NOT_PENDING ? asBacking(t.le) : e.v;
     // A node-less staging (`stageOn`): the fold queue remembers the frame.
         return e.pb !== null ? preBatch(e) : e.v;
 }
@@ -1207,7 +1224,7 @@ function inDraft(e) {
  * committed frame. */ function stagingReader() {
     let e = context;
     if (e === null) return null;
-    if (e.Pt) e = e.ht ?? null;
+    if (e.Pt) e = e.Ht ?? null;
     return e === null || e.l & CONFIG_CHILDREN_FORBIDDEN ? null : e;
 }
 
@@ -1314,7 +1331,7 @@ function inDraft(e) {
 
 /** Did the HELD staging (the container node's, not a mainline layer above
  * it) change `key`? */ function heldKeyChanged(e, t, n = true) {
-    return changedBetween(e, e.k.le, e.k.ie, t, n) && !adoptChild(e, t);
+    return changedBetween(e, e.k.le, e.k.ue, t, n) && !adoptChild(e, t);
 }
 
 /** The values of a held frame, built once per frame: neither the committed
@@ -1343,12 +1360,12 @@ function rawsOf(e) {
     const n = e.k;
     const r = asBacking(n.le);
     const o = r[t];
-    const i = n.ie[t];
+    const i = n.ue[t];
     const l = Array.isArray(r) ? e.fam?.key : null;
     if (e.s || l === undefined || !sameRow(o, i, l) || !isWrappable(o) || !isWrappable(i) || Array.isArray(o) !== Array.isArray(i) || lookupTarget(o, e.fam) !== undefined || lookupTarget(i, e.fam) !== undefined || 
     // A raw in both frames (the same objects swapped or reordered) is its
     // own row: pairing it with another would alias the two after the commit.
-    rawsOf(r).has(i) || rawsOf(n.ie).has(o)) return false;
+    rawsOf(r).has(i) || rawsOf(n.ue).has(o)) return false;
     // A raw-marked value wraps to itself, a proxy to its own target: neither
     // is a fresh target around `ov`.
         const u = wrap(o, e, t)[$TARGET];
@@ -1391,9 +1408,16 @@ function changedBetween(e, t, n, r, o) {
 
 /** Value of a key with a leaf: core's — `read()` links a tracked reader and,
  * tracked or not, applies the hold and A28 rules a signal's read does. A
- * projection's unheld staging is ahead for a handler (`familyAhead`). */ function nodeValue(e, t, n) {
-    let r = read(e);
-    if (e.ie !== NOT_PENDING && !(e.l & CONFIG_HELD) && context === null && n.fam !== null) r = e.ie;
+ * projection's unheld staging is ahead for a handler (`familyAhead`), and is
+ * the only value while its derive has never committed: the committed side
+ * is the seed, never observable (A25) — a reader core serves the screen (a
+ * verdict reader, #4355) is served the staging, as for a memo born staged
+ * (core `serve`). */ function nodeValue(e, t, n) {
+    let r;
+    if (e.ue !== NOT_PENDING && !(e.l & CONFIG_HELD) && n.fam !== null && (context === null || n.fam.node?.m & STATUS_UNINITIALIZED)) {
+        if (context !== null && tracking) link(e, context);
+        r = e.ue;
+    } else r = read(e);
     return r === FORCE ? t : r;
 }
 
@@ -1471,9 +1495,9 @@ function changedBetween(e, t, n, r, o) {
         // (committed plus the guesses) and does not suspend on the derive; a
         // verdict window still asks it (`isPending` is true while the flight is
         // up). The family's, not the target's: the edit stands in for the one
-        // flight the family has.
-                const r = e.fam.overlaid;
-        if (verdict === null && t.m & STATUS_PENDING && r !== undefined && r.size !== 0) return;
+        // flight the family has — not over a new question they do not answer
+        // (optimistic.ts `stands`, #4336).
+                if (verdict === null && t.m & STATUS_PENDING && optHooks?.stands(e)) return;
         read(t);
     } else untrack(() => read(t));
 }
@@ -1486,7 +1510,7 @@ function changedBetween(e, t, n, r, o) {
  * classification, as core reads it — `heldNotFinal`). */ function holdWithDerive(e, t) {
     const n = e.fam?.node;
     if (n !== undefined && n !== null && !userWrite && // the derive's own write (its draft or landing), not a user setter's
-    n.l & CONFIG_HELD && t.ie !== NOT_PENDING && 
+    n.l & CONFIG_HELD && t.ue !== NOT_PENDING && 
     // A node carrying a guess is the lane's: its staging is the truth beneath
     // the guess (`setSignal` → `laneWrite`), never re-homed by the store.
     !(t.l & (CONFIG_HELD | CONFIG_OVERRIDE))) {
@@ -1655,7 +1679,8 @@ const traps = {
             // Reading a currently-absent own key subscribes to it (R12) — for any
             // target OUTSIDE its own draft scope, even mid-setter (#3037, above).
                         if (u === undefined && !inDraft(e)) {
-                if (getObserver() !== null) read(getNode(e, t, i));
+                // (`nodeValue` reads — and links — the node it creates.)
+                if (getObserver() !== null) getNode(e, t, i);
                 const n = e.n?.[t];
                 if (n) {
                     const r = nodeValue(n, undefined, e);
@@ -1834,8 +1859,8 @@ const traps = {
  * to the key's presence node or a later add never re-runs it. */ function observerHoldsContainer(e, t) {
     const n = e.k;
     if (n === null) return false;
-    const r = n.Ct;
-    return r !== null && r.u === t && (!(t.R & REACTIVE_RECOMPUTING_DEPS) || r.Ie === t.Ne);
+    const r = n.Ot;
+    return r !== null && r.u === t && (!(t.R & REACTIVE_RECOMPUTING_DEPS) || r.de === t.Ne);
 }
 
 function storeSetter(e, t, n = true) {
@@ -1914,6 +1939,17 @@ function createStore(e, t) {
     return [ r, setter ];
 }
 
+/** The list driver's slot view of a shallow store (types.ts `shallowView`):
+ * one `readSource` for the container instead of a trap per slot. A shallow
+ * store's slots hold raw records, so the backing the container read serves
+ * is what each slot read would — except where a slot's own leaf can answer
+ * differently: an optimistic family's guesses, a chained backing, accessor
+ * keys, or a read inside a draft or write scope. Those keep the trap. */ installShallowView(e => {
+    // Any open write scope keeps the trap (it covers `inDraft`).
+    if (e?.s && !(e.ch || e.a || writeScopes || writeOverride || e.fam?.opt)) return e.fam && pullFamily(e), 
+    readSource(e);
+});
+
 /** True when `proxy` is a SHALLOW store (children served verbatim, slots
  * replaced by reference — #2932). The list driver uses this to choose the
  * slot-patch channel (collected row bodies) over per-record registration. */ function storeIsShallow(e) {

package/dist/observe/store/types.js

@@ -70,4 +70,14 @@ function setWriteOverride(e) {
     writeOverride = e;
 }
 
-export { $PROXY, $RECORD, $TARGET, $TRACK, isRawValue, isWrappable, markRaw, markRawIngest, markRawOne, ownEnumerableKeys, rawValuesUsed, setWriteOverride, writeOverride };
+/** The list driver's view of a shallow store (map.ts): the backing a read of
+ * every slot serves this reader, or `undefined` when the list is no shallow
+ * store or a slot read could differ from it. Installed by store.ts's top
+ * level, so a `<For>` in an app without stores carries none of it; it lives
+ * beside `$TRACK` so map.ts reaches no other store module. */ let shallowView = null;
+
+function installShallowView(e) {
+    shallowView = e;
+}
+
+export { $PROXY, $RECORD, $TARGET, $TRACK, installShallowView, isRawValue, isWrappable, markRaw, markRawIngest, markRawOne, ownEnumerableKeys, rawValuesUsed, setWriteOverride, shallowView, writeOverride };

package/dist/observe/store/utils.js

@@ -925,7 +925,7 @@ const omitTraps = {
             // CONFIG_KEY_BAG); prod passes no options.
             n[r] = createMemo(o, {
                 name: "merge",
-                St: CONFIG_KEY_BAG
+                ct: CONFIG_KEY_BAG
             });
             t[r++] = SOURCE_MEMO;
             continue;

package/dist/prod/affects.js

@@ -16,7 +16,8 @@ import { $TARGET } from "./store/types.js";
 // A mark is a declared in-flight change: the marked node — and everything
 // derived from it — reads pending (`isPending` → true) from the declaration
 // until the surrounding transaction lands (an ambient mark, declared outside
-// one, releases at the next seam). The marked values stay readable: no reader
+// one, releases at the next seam; either, on a node whose own flight is
+// still up then, at the seam after that flight lands). The marked values stay readable: no reader
 // suspends on a mark, a mark holds nothing and entangles nothing — it is not
 // a node of its transaction (`blocked` never sees it), and a reader of marked
 // data joins nothing through it. A mark is never a re-ask, so a declared
@@ -71,7 +72,16 @@ function affects(e, t) {
     schedule();
 }
 
-installMarkHooks(release, e => {
+installMarkHooks(e => {
+    // A landing's mark on a node whose own flight is up (a declared reload's
+    // quiet re-ask the action did not wait for) stays to the seam after
+    // that flight lands, as an ambient one does: the reload's window is the
+    // flight's (#4349). The rest release with the transaction.
+    const t = [];
+    for (let r = 0; r < e.length; r++) (inFlight(e[r]) ? ambient : t).push(e[r]);
+    e.length = 0;
+    release(t);
+}, e => {
     if (ambient.length === 0) return;
     // The flush parked: the declaration's window is the frame's — the marks
     // are its transaction's ("nothing async below ⇒ no window").