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

package/dist/prod/store/projection.js

@@ -12,6 +12,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, storeSetter, runDirect } from "./store.js";
@@ -50,22 +52,22 @@ import { $TARGET, markRawIngest, isWrappable, setWriteOverride } from "./types.j
  * set/getOwnPropertyDescriptor/defineProperty. With the store proxy as
  * target those checks re-enter the store's traps OUTSIDE the override
  * bracket, so `Object.keys(state)` in a derive continuation fired the gate.
- */ function wrapDraft(e, t, r, n, o, i) {
+ */ function wrapDraft(e, t, r, o, n, i) {
     const mutate = e => {
         if (!t()) return true;
         setWriteOverride(true);
         // A continuation's write is the flight's answer: it asks the flight's
         // question (A18 provenance — a landing beneath a newer guess is held,
         // not a correction; lanes.ts `laneWrite`).
-                const n = question;
+                const o = question;
         if (i !== undefined) setQuestion(i());
         try {
             r ? r(e) : e();
         } finally {
             setWriteOverride(false);
-            setQuestion(n);
+            setQuestion(o);
         }
-        if (o) o();
+        if (n) n();
         return true;
     };
     const read = e => {
@@ -79,23 +81,23 @@ import { $TARGET, markRawIngest, isWrappable, setWriteOverride } from "./types.j
     const s = {
         get(s, c) {
             const u = read(() => e[c]);
-            return !n && typeof u === "object" && u !== null && c !== $TARGET ? wrapDraft(u, t, r, false, o, i) : u;
+            return !o && typeof u === "object" && u !== null && c !== $TARGET ? wrapDraft(u, t, r, false, n, i) : u;
         },
         has: (t, r) => read(() => r in e),
-        set: (t, r, n) => mutate(() => {
-            e[r] = n;
+        set: (t, r, o) => mutate(() => {
+            e[r] = o;
         }),
         deleteProperty: (t, r) => mutate(() => {
             delete e[r];
         }),
         ownKeys: () => read(() => Reflect.ownKeys(e)),
         getOwnPropertyDescriptor(t, r) {
-            const n = read(() => Reflect.getOwnPropertyDescriptor(e, r));
-            if (n) n.configurable = true;
-            return n;
+            const o = read(() => Reflect.getOwnPropertyDescriptor(e, r));
+            if (o) o.configurable = true;
+            return o;
         },
-        defineProperty: (t, r, n) => mutate(() => {
-            Reflect.defineProperty(e, r, n);
+        defineProperty: (t, r, o) => mutate(() => {
+            Reflect.defineProperty(e, r, o);
         })
     };
     const c = new Proxy(Array.isArray(e) ? [] : {}, s);
@@ -127,6 +129,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
@@ -162,6 +165,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
@@ -174,8 +181,8 @@ function forEachFamilyNode(e, t) {
     for (const r of e.live) {
         const e = r.n;
         if (e !== null) for (const r of Reflect.ownKeys(e)) t(e[r]);
-        const n = r.h;
-        if (n !== null) for (const e of Reflect.ownKeys(n)) t(n[e]);
+        const o = r.h;
+        if (o !== null) for (const e of Reflect.ownKeys(o)) t(o[e]);
         if (r.k !== null) t(r.k);
         if (r.dk !== null) t(r.dk);
     }
@@ -185,7 +192,7 @@ function forEachFamilyNode(e, t) {
  * result (sync, or each async landing) through the reconcile channel.
  * Draft validity is per run (R37): live from here until the NEXT run starts
  * — a sync derive that subscribes to an external source and pushes into
- * the draft from the callback (#3585) is the model use. */ function runProjectionComputed(e, t, r, n, o) {
+ * the draft from the callback (#3585) is the model use. */ function runProjectionComputed(e, t, r, o, n) {
     const i = getOwner();
     const s = e[$TARGET];
     const c = s.fam;
@@ -199,8 +206,8 @@ function forEachFamilyNode(e, t) {
     // 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.Te : 0);
-    const f = wrapDraft(e, () => c.run === u && !isDisposed(i), o, s.s, 
+        const asking = () => question || (i.T !== null && i.T.Ee !== null ? i.T.Ie : 0);
+    const f = wrapDraft(e, () => c.run === u && !isDisposed(i), n, s.s, 
     // A write after the run returned (a continuation, a callback) arms the
     // drain itself when no landing will.
     () => {
@@ -210,24 +217,24 @@ function forEachFamilyNode(e, t) {
     // `_value`); every later run — a re-derive in a flush, an async landing
     // — stages and commits with the flush like a memo's recompute.
         const d = u === 1;
-    const pass = () => storeSetter(f, o => {
-        l = t(a ?? o);
-        const commit = t => {
+    const pass = () => storeSetter(f, n => {
+        l = t(a ?? n);
+        const commit = (t, u = 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 (a && (t === undefined || t === a)) t = cloneState(a, s.s);
-            if (t !== o && t !== undefined) {
+            if (t !== n && t !== undefined) {
                 const write = () => {
-                    const n = question;
+                    const o = question;
                     setQuestion(asking());
                     try {
                         storeSetter(e, e => reconcileState(t, e, r, true), false);
                     } finally {
-                        setQuestion(n);
+                        setQuestion(o);
                     }
                 };
-                n ? n(write, t) : write();
+                o ? o(write, t) : write();
             }
             // A landing (not the sync pass's own commit): the readers held
             // pending on the derive settle.
@@ -235,8 +242,11 @@ 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 (u) insertSubs(i);
         };
         const u = handleAsync(i, l, commit, (e, t) => {
             // The flight rejected: the leaves' readers learn it from here —
@@ -248,7 +258,8 @@ function forEachFamilyNode(e, t) {
             if (d && i.m & STATUS_UNINITIALIZED) return;
             if (t) wakeFamily(c); else errorFamily(c);
         });
-        if (!i.ce) commit(u);
+        // (The status is the one before this pass: `recompute` sets it after.)
+                if (!i.ce) commit(u, i.m & (STATUS_PENDING | STATUS_ERROR));
     }, false);
     try {
         d ? runDirect(pass) : pass();
@@ -273,8 +284,8 @@ function createProjectionInternal(e, t, r) {
     // Seedless (`fn` takes no draft): the root starts as an empty record. It is
     // a draft like any seed, never observable before the first landing (A25).
     t ||= {};
-    const n = r?.key === undefined ? "id" : r.key;
-    const o = {
+    const o = r?.key === undefined ? "id" : r.key;
+    const n = {
         map: new WeakMap,
         node: null,
         live: new Set,
@@ -282,10 +293,10 @@ function createProjectionInternal(e, t, r) {
         shallow: !!r?.shallow,
         // The row key, for a child paired after the adoption (store.ts
         // `adoptChild`, #3712) as the adoption pairs them.
-        key: typeof n === "function" ? n : n === null ? null : e => isWrappable(e) ? e[n] : undefined
+        key: typeof o === "function" ? o : o === null ? null : e => isWrappable(e) ? e[o] : undefined
     };
-    const i = wrap(t, null, null, o);
-    if (o.shallow) {
+    const i = wrap(t, null, null, n);
+    if (n.shallow) {
         i[$TARGET].s = true;
         markRawIngest(t);
     }
@@ -294,14 +305,14 @@ function createProjectionInternal(e, t, r) {
         loadingValue: undefined
     };
     const c = computed(() => {
-        if (!o.node) o.node = getOwner();
-        runProjectionComputed(i, e, n);
+        if (!n.node) n.node = getOwner();
+        runProjectionComputed(i, e, o);
     }, s);
     c.l &= ~CONFIG_AUTO_DISPOSE;
-    o.node = c;
+    n.node = c;
     // The derive's leaves are not its dependents: a mark's repoll
     // (affects-marks.ts) reaches their readers through this.
-        c.fam = o;
+        c.fam = n;
     return {
         store: i,
         node: c
@@ -313,8 +324,8 @@ function createProjection(e, t, r) {
 }
 
 /** `createStore(fn, seed, options)`: a projection with a user setter. */ function createStoreDerived(e, t, r) {
-    const {store: n} = createProjectionInternal(e, t, r);
-    return [ n, e => storeSetter(n, e) ];
+    const {store: o} = createProjectionInternal(e, t, r);
+    return [ o, e => storeSetter(o, e) ];
 }
 
 export { createProjection, createStoreDerived, runProjectionComputed };

package/dist/prod/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/prod/store/store.js

@@ -1,10 +1,10 @@
-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 { signalHook } from "../core/identities.js";
 
-import { setSlotUnobserved } from "../core/graph.js";
+import { link, setSlotUnobserved } from "../core/graph.js";
 
 import { getObserver } from "../core/owner.js";
 
@@ -16,7 +16,7 @@ import { lookupTarget, setLookup, $OWNER, isOwned, markDescendants } from "./tar
 
 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";
 
@@ -220,7 +220,7 @@ function sameLogicalSlot(e, n, t) {
 
 function releaseSlot(e) {
     const n = e.O;
-    const t = e.ze;
+    const t = e.Xe;
     if (t === $TRACK) {
         if (n.k === e) n.k = null;
     } else if (t === $DEEP) {
@@ -236,7 +236,7 @@ function releaseSlot(e) {
 /** A node was born on `target`: a family target enters the live index. */ function noteNode(e, n, t) {
     if (e.fam !== null) e.fam.live.add(e);
     markDescendants(e);
-    if (affectsHooks !== null) affectsHooks.fo(e, n, t);
+    if (affectsHooks !== null) affectsHooks.ro(e, n, t);
 }
 
 // Shared slot-node release handler: registered once; the core sweep
@@ -247,7 +247,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);
@@ -258,9 +258,9 @@ setSlotUnobserved(e => {
  * pending one — and held by the container's transaction when the container
  * is held (#3706: the unit of the hold is the key — a key the batch left
  * unchanged stages nothing and holds no one). */ function bornStaged(e, n, t, r) {
-    if (n.xe && n.xe(n.le, t)) return;
+    if (n.ye && n.ye(n.le, t)) return;
     queuePendingNode(n);
-    n.ie = t;
+    n.ue = t;
     const o = e.k;
     if (o === null) return;
  // a node-less staging holds nothing (`stageOn`)
@@ -326,7 +326,7 @@ function getHasNode(e, n) {
         // would have read had the node been there from the write.
                 if (e.pb !== null && !directCommit) {
             n.le = preBatch(e);
-            n.ie = e.pb;
+            n.ue = e.pb;
             queuePendingNode(n);
         }
     }
@@ -343,10 +343,10 @@ function getHasNode(e, n) {
  * 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, n) {
-    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 t = getContainerNode(e);
-    if (t.ie === NOT_PENDING) queuePendingNode(t);
-    t.ie = n;
+    if (t.ue === NOT_PENDING) queuePendingNode(t);
+    t.ue = n;
     // 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(t);
@@ -364,6 +364,7 @@ const storePark = e => {
         const t = foldList[n];
         if (t.k === null && t.pb !== null) holdNode(getContainerNode(t), e);
     }
+    optHooks?.park(e);
 };
 
 function getDeepNode(e) {
@@ -419,16 +420,23 @@ function isOwnAccessor(e, n) {
         t[$OWNER] = n;
         return t;
     }
-    const t = Object.getOwnPropertyDescriptors(e);
-    for (const r of Reflect.ownKeys(t)) {
-        const o = t[r];
-        if (r === "length" && Array.isArray(e)) continue;
-        o.configurable = true;
-        if (!o.get && !o.set) o.writable = true; else n.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 t;
+    if (!n.a && n.kc <= e.length + 1 && Object.getPrototypeOf(e) === Array.prototype) t = e.slice(); else {
+        const r = Object.getOwnPropertyDescriptors(e);
+        for (const t of Reflect.ownKeys(r)) {
+            const o = r[t];
+            if (t === "length" && Array.isArray(e)) continue;
+            o.configurable = true;
+            if (!o.get && !o.set) o.writable = true; else n.a = true;
+        }
+        t = Array.isArray(e) ? Object.defineProperties([], r) : Object.create(Object.getPrototypeOf(e), r);
     }
-    const r = Array.isArray(e) ? Object.defineProperties([], t) : Object.create(Object.getPrototypeOf(e), t);
-    r[$OWNER] = n;
-    return r;
+    t[$OWNER] = n;
+    return t;
 }
 
 /** Wide plain clone (many keys): null-prototype build, then reset. */ function wideClone(e, n) {
@@ -494,7 +502,7 @@ const plainProto = e => {
     const t = overlayOnto(e, e.sc === 2 ? wideClone(e.v, e) : cloneRaw(e.v, e), n);
     e.pb = t;
     // The staging IS the pending backing: re-point the container node.
-        if (e.k?.ie === n) e.k.ie = t;
+        if (e.k?.ue === n) e.k.ue = t;
     return t;
 }
 
@@ -515,7 +523,7 @@ const plainProto = e => {
         // mainline setter mid-hold publishes mainline; the held keys stay held).
         n = e.pb = cloneRaw(n, e);
         const t = e.k;
-        if (t !== null && !(t.l & CONFIG_HELD)) t.ie = n;
+        if (t !== null && !(t.l & CONFIG_HELD)) t.ue = n;
     } else if (n === null) {
         const t = e.v;
         if (!directCommit) queueFold(e);
@@ -692,7 +700,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(n[t]);
@@ -722,10 +730,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 n = e.O;
     if (n.ch) {
-        const t = e.ze;
+        const t = e.Xe;
         const r = n.v;
         if (n.h?.[t] === e) e.le = untrack(() => t in r); else if (n.n?.[t] === e) e.le = untrack(() => unwrapValue(r[t]));
     }
@@ -738,9 +746,9 @@ installStoreHooks(storePark, () => {
 });
 
 /** The store half of `affects()` (store/affects.ts) makes its marks' nodes
- * and walks records through these: it never imports the engine. */ GlobalQueue.no = getNode;
+ * and walks records through these: it never imports the engine. */ GlobalQueue.so = getNode;
 
-GlobalQueue.so = isWrappable;
+GlobalQueue.fo = isWrappable;
 
 /** A projection's creation run commits directly (a memo's first value is
  * its `_value`, not a staging): the draft still writes a clone of the seed,
@@ -840,13 +848,18 @@ function heldDerivation(e, n, t) {
     // 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, n);
-        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, n);
+            return;
+        }
+        // The derive's draft: new rows under guessed rows are paired with them
+        // first (D-34, #4329).
+                optHooks.pair(e, n);
     }
     const t = e.v;
     const r = e.n;
@@ -990,7 +1003,10 @@ function membershipChanged(e, n) {
     } else {
         const o = t[n];
         const i = r[n];
-        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 (t[$TARGET] || !isEqual(o, i) && !targetsEqual(o, i)) setSignal(e, typeof i === "function" ? () => i : i);
     }
 }
 
@@ -1016,7 +1032,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
@@ -1027,14 +1044,14 @@ function hasAccessorFlag(e) {
  * answers the arrangement — before, only the presence write reached the
  * lane, by accident of being unconditional. */ function notifyFoldTail(e, n, t) {
     const r = e.h;
+    const o = n[$TARGET];
     if (r !== null) {
-        const e = n[$TARGET];
-        for (const o of Reflect.ownKeys(r)) if (e || o in n !== o in t) setSignal(r[o], o in t);
+        for (const e of Reflect.ownKeys(r)) if (o || e in n !== e in t) setSignal(r[e], e in t);
     }
-    const o = e.k;
-    if (o !== null && (o.o !== null || o.l & CONFIG_OVERRIDE)) {
-        const e = Array.isArray(t) && Array.isArray(n) ? arrayStructureChanged(n, t) : membershipChanged(n, t);
-        if (e) notifyContainer(o, t);
+    const i = e.k;
+    if (i !== null && (i.o !== null || i.l & CONFIG_OVERRIDE)) {
+        const e = o || (Array.isArray(t) && Array.isArray(n) ? arrayStructureChanged(n, t) : membershipChanged(n, t));
+        if (e) notifyContainer(i, t);
     }
 }
 
@@ -1089,7 +1106,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 n = e.k;
-    if (n !== null) return n.ie !== NOT_PENDING ? asBacking(n.le) : e.v;
+    if (n !== null) return n.ue !== NOT_PENDING ? asBacking(n.le) : e.v;
     // A node-less staging (`stageOn`): the fold queue remembers the frame.
         return e.pb !== null ? preBatch(e) : e.v;
 }
@@ -1101,7 +1118,7 @@ function inDraft(e) {
  * committed frame. */ function stagingReader() {
     let e = context;
     if (e === null) return null;
-    if (e.Qe) e = e.Ye ?? null;
+    if (e.Qe) e = e.Ke ?? null;
     return e === null || e.l & CONFIG_CHILDREN_FORBIDDEN ? null : e;
 }
 
@@ -1208,7 +1225,7 @@ function inDraft(e) {
 
 /** Did the HELD staging (the container node's, not a mainline layer above
  * it) change `key`? */ function heldKeyChanged(e, n, t = true) {
-    return changedBetween(e, e.k.le, e.k.ie, n, t) && !adoptChild(e, n);
+    return changedBetween(e, e.k.le, e.k.ue, n, t) && !adoptChild(e, n);
 }
 
 /** The values of a held frame, built once per frame: neither the committed
@@ -1237,12 +1254,12 @@ function rawsOf(e) {
     const t = e.k;
     const r = asBacking(t.le);
     const o = r[n];
-    const i = t.ie[n];
+    const i = t.ue[n];
     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(t.ie).has(o)) return false;
+    rawsOf(r).has(i) || rawsOf(t.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, n)[$TARGET];
@@ -1285,9 +1302,16 @@ function changedBetween(e, n, t, 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, n, t) {
-    let r = read(e);
-    if (e.ie !== NOT_PENDING && !(e.l & CONFIG_HELD) && context === null && t.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, n, t) {
+    let r;
+    if (e.ue !== NOT_PENDING && !(e.l & CONFIG_HELD) && t.fam !== null && (context === null || t.fam.node?.m & STATUS_UNINITIALIZED)) {
+        if (context !== null && tracking) link(e, context);
+        r = e.ue;
+    } else r = read(e);
     return r === FORCE ? n : r;
 }
 
@@ -1365,9 +1389,9 @@ function changedBetween(e, n, t, 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 && n.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 && n.m & STATUS_PENDING && optHooks?.stands(e)) return;
         read(n);
     } else untrack(() => read(n));
 }
@@ -1380,7 +1404,7 @@ function changedBetween(e, n, t, r, o) {
  * classification, as core reads it — `heldNotFinal`). */ function holdWithDerive(e, n) {
     const t = e.fam?.node;
     if (t !== undefined && t !== null && !userWrite && // the derive's own write (its draft or landing), not a user setter's
-    t.l & CONFIG_HELD && n.ie !== NOT_PENDING && 
+    t.l & CONFIG_HELD && n.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.
     !(n.l & (CONFIG_HELD | CONFIG_OVERRIDE))) {
@@ -1472,7 +1496,7 @@ const traps = {
                 }
         // (The witness before the pull: a mark on an uninitialized derived
         // store is witnessed, then the pull throws — loading, declared pending.)
-                if (verdict !== null && affectsHooks !== null && getObserver() === null) affectsHooks.ro(e, n);
+                if (verdict !== null && affectsHooks !== null && getObserver() === null) affectsHooks.io(e, n);
         if (e.fam !== null) pullFamily(e);
         // Hot inline case: existing PLAIN node (non-accessor) read outside any
         // draft — the dbmon/uibench effect re-read shape. Core's `read()` serves
@@ -1549,7 +1573,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, n, i));
+                // (`nodeValue` reads — and links — the node it creates.)
+                if (getObserver() !== null) getNode(e, n, i);
                 const t = e.n?.[n];
                 if (t) {
                     const r = nodeValue(t, undefined, e);
@@ -1569,7 +1594,7 @@ const traps = {
         if (n === $OWNER || n === $RECORD) return false;
         // (The witness before the pull: a mark on an uninitialized derived
         // store is witnessed, then the pull throws — loading, declared pending.)
-                if (verdict !== null && affectsHooks !== null && getObserver() === null) affectsHooks.ro(e, n);
+                if (verdict !== null && affectsHooks !== null && getObserver() === null) affectsHooks.io(e, n);
         if (e.fam !== null) pullFamily(e);
         const t = readSource(e, n);
         // A tracked reader's presence node answers (born from the two frames;
@@ -1594,14 +1619,14 @@ const traps = {
         return n in t && !(t === e.pb && e.del?.has(n));
     },
     ownKeys(e) {
-        if (verdict !== null && affectsHooks !== null && getObserver() === null) affectsHooks.ro(e, undefined);
+        if (verdict !== null && affectsHooks !== null && getObserver() === null) affectsHooks.io(e, undefined);
         if (e.fam !== null) pullFamily(e);
         return visibleKeys(e, enumerationSource(e));
     },
     getOwnPropertyDescriptor(e, n) {
         if (n === $OWNER || n === $RECORD) return undefined;
         const t = getObserver();
-        if (verdict !== null && affectsHooks !== null && t === null) affectsHooks.ro(e, n);
+        if (verdict !== null && affectsHooks !== null && t === null) affectsHooks.io(e, n);
         if (e.fam !== null) pullFamily(e);
         // An enumerator (spread, Object.entries) already holds the container
         // node and reads its frame; a descriptor read on its own tracks
@@ -1728,8 +1753,8 @@ const traps = {
  * to the key's presence node or a later add never re-runs it. */ function observerHoldsContainer(e, n) {
     const t = e.k;
     if (t === null) return false;
-    const r = t.ve;
-    return r !== null && r.u === n && (!(n.R & REACTIVE_RECOMPUTING_DEPS) || r.de === n.Ne);
+    const r = t.Ze;
+    return r !== null && r.u === n && (!(n.R & REACTIVE_RECOMPUTING_DEPS) || r.Ne === n.de);
 }
 
 function storeSetter(e, n, t = true) {
@@ -1797,6 +1822,17 @@ function createStore(e, n) {
     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) {