@solidjs/signals 2.0.0-rc.14 → 2.0.0-rc.15

package/dist/observe/signals.js

@@ -1,20 +1,20 @@
-import { NotReadyError, unwrapStatusError, TimeoutError } from "./core/error.js";
+import { TimeoutError, NotReadyError, unwrapStatusError } from "./core/error.js";
 
 import "./core/verdict.js";
 
-import { CONFIG_CHILDREN_FORBIDDEN, EFFECT_USER, $REFRESH, CONFIG_REDERIVE, REACTIVE_JOINED, CONFIG_AUTO_DISPOSE, CONFIG_FRESH_READ, CONFIG_AUTHORITATIVE } from "./core/constants.js";
+import { CONFIG_CHILDREN_FORBIDDEN, EFFECT_USER, $REFRESH, CONFIG_AUTO_DISPOSE, CONFIG_AUTHORITATIVE, CONFIG_REDERIVE, REACTIVE_JOINED, CONFIG_FRESH_READ, CONFIG_GUESS, STATUS_PENDING, STATUS_ERROR } from "./core/constants.js";
 
 import { computed, signal, runWithOwner, setMemo, setSignal, markRefresh, read, untrack } from "./core/core.js";
 
 import { registerGraph } from "./core/dev.js";
 
-import { globalQueue, flushTransaction, resolveTx, passTx, staleReader, dirtyQueue, joinFuture } from "./core/scheduler.js";
+import { globalQueue, flushTransaction, dirtyQueue, GlobalQueue, resolveTx, passTx, staleReader, joinFuture } from "./core/scheduler.js";
 
 import { cleanup, createRoot, getOwner, dispose } from "./core/owner.js";
 
 import { effect, trackedEffect } from "./core/effect.js";
 
-import { optimisticWrite } from "./core/lanes.js";
+import { optimisticWrite, truthRead, truthConfirmed } from "./core/lanes.js";
 
 /**
  * Low-level reactive-cleanup primitive. Registers a callback that runs when
@@ -73,7 +73,7 @@ function accessor(e) {
 function createSignal(e, t) {
     if (typeof e === "function") {
         const r = computed(e, t);
-        r.u &= ~CONFIG_AUTO_DISPOSE;
+        r.i &= ~CONFIG_AUTO_DISPOSE;
         return [ accessor(r), setMemo.bind(null, r) ];
     }
     const r = signal(e, t);
@@ -84,7 +84,7 @@ function createSignal(e, t) {
 function createOptimistic(e, t) {
     if (typeof e === "function") {
         const r = computed(e, t);
-        r.u &= ~CONFIG_AUTO_DISPOSE;
+        r.i &= ~CONFIG_AUTO_DISPOSE;
         return [ accessor(r), optimisticWrite.bind(null, r) ];
     }
     const r = signal(e, t);
@@ -324,11 +324,15 @@ function createMemo(e, t) {
  * - a mainline reader whose pass read a frame another transaction holds
  *   joined it (L2, born held — A29) and delivers at that commit: the
  *   committed view, never a foreign hold's unrevealed frame. */ function watch(e, t, r, n = 0, o, c = flushTransaction) {
+    if (n & CONFIG_AUTHORITATIVE) {
+        GlobalQueue.Nn = truthRead;
+        GlobalQueue.rn = truthConfirmed;
+    }
     // `config` is on the node for its first pass too (the pass runs inside
     // `computed()`): `until`'s predicate is authoritative from its first read,
     // 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(() => {
+        computed(() => {
         let n;
         try {
             n = e();
@@ -337,18 +341,18 @@ function createMemo(e, t) {
             queueMicrotask(() => r(unwrapStatusError(e)));
             return;
         }
-        const i = getOwner();
+        const u = getOwner();
         // (Outside a flush a mainline pass joins through `passTx`.)
-                const u = flushTransaction ?? passTx;
-        if (i.R & REACTIVE_JOINED && u !== null && (c === null || resolveTx(c) !== resolveTx(u))) {
-            staleReader(i, resolveTx(u));
+                const i = flushTransaction ?? passTx;
+        if (u.R & REACTIVE_JOINED && i !== null && (c === null || resolveTx(c) !== resolveTx(i))) {
+            staleReader(u, resolveTx(i));
             return;
         }
         o?.(n);
         queueMicrotask(() => t(n));
     }, {
-        dt: n
-    }).u |= CONFIG_REDERIVE;
+        Ct: n
+    }).i |= CONFIG_REDERIVE;
 }
 
 /**
@@ -434,23 +438,29 @@ function createMemo(e, t) {
         const r = flushTransaction;
     const n = new Promise((n, o) => {
         queueMicrotask(() => {
-            // No createRoot: the microtask has no ambient owner, so the watcher is
-            // naturally detached, and settle disposes the node directly (dev keeps
-            // a root husk purely to stay quiet about the missing owner). The
-            // capture runs inside the watcher's own pass, where the ambient owner
-            // IS the watcher — exactly what dispose() takes.
+            // The root is load-bearing: an ownerless computed is auto-disposing,
+            // and the settle walk releases an unobserved one instead of re-running
+            // it, so the waiter would never see the refetch land (#3888). Settle
+            // disposes the waiter directly; the capture runs inside the watcher's
+            // own pass, where the ambient owner IS the watcher — exactly what
+            // dispose() takes.
             let c = null;
             const make = () => watch(() => {
                 if (c === null) c = getOwner();
-                return read(t);
+                // Authoritative: the truth beneath a guess (`until`'s view). A
+                // guessed node's own re-ask is not answered by it (#3895): park
+                // on that flight, or reject with its error.
+                                const e = read(t);
+                if (t.i & CONFIG_GUESS && t.S & (STATUS_PENDING | STATUS_ERROR)) throw t.m?.F;
+                return e;
             }, t => {
                 n(typeof e === "function" ? t : e);
                 dispose(c);
             }, e => {
                 o(e);
                 dispose(c);
-            }, CONFIG_FRESH_READ, undefined, r);
-            make();
+            }, CONFIG_FRESH_READ | CONFIG_AUTHORITATIVE, undefined, r);
+            createRoot(make);
         });
     });
     // Fire-and-forget refresh must not turn a failed refetch into an unhandled
@@ -499,14 +509,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
@@ -519,9 +529,9 @@ function createMemo(e, t) {
                 // The flip, inside the pass of the flush carrying it: the flush
                 // joins the action's transaction, and what it staged is held and
                 // revealed with the action.
-                if (e && c !== null && globalQueue.ee && resolveTx(c).tt !== 0) joinFuture(c);
+                if (e && c !== null && globalQueue.X && 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, {
@@ -627,7 +637,7 @@ function createMemo(e, t) {
  *   on owner disposal
  */ function onSettled(e) {
     const t = getOwner();
-    t && !(t.u & CONFIG_CHILDREN_FORBIDDEN) ? trackedEffect(() => untrack(e), {
+    t && !(t.i & CONFIG_CHILDREN_FORBIDDEN) ? trackedEffect(() => untrack(e), {
         name: "onSettled"
     }) : globalQueue.enqueue(EFFECT_USER, function fire() {
         // Settled means derived. A settle that reverts optimism (or replays

package/dist/observe/store/affects.js

@@ -1,10 +1,10 @@
 import { GlobalQueue } from "../core/scheduler.js";
 
-import { installAffectsHooks, getNode, optHooks } from "./store.js";
+import { optHooks, installAffectsHooks } from "./hooks.js";
 
 import { lookupTarget, $OWNER } from "./target.js";
 
-import { isWrappable, $TARGET } from "./types.js";
+import { $TARGET } from "./types.js";
 
 /**
  * Store — the store half of `affects()` (plan sec. 29, plan sec. 37; A24 (4), #2882,
@@ -23,113 +23,120 @@ import { isWrappable, $TARGET } from "./types.js";
  * the verdict. A mark declared on a draft (inside a setter) or over an
  * optimistic family walks the view the writer sees.
  *
- * Installed by `store/index.ts`: a program with stores carries it; one
- * without pays nothing (affects.ts asks `GlobalQueue._storeMarks`).
+ * Imported by `affects()`, which installs it on its first store target
+ * (#3891, after #3912): a program with stores that never declares a mark
+ * carries none of it. It never imports store.ts — the engine's top level —
+ * so a program declaring marks without stores carries this module alone:
+ * the store's nodes and its wrappability test come through `GlobalQueue`
+ * (`_storeNode`, `_storeWrappable`), and node birth and the untracked traps
+ * reach back through `affectsHooks` (hooks.ts).
  */
 /** The keyless mark's carrier key: a leaf of the record no read serves. */ const $AFFECTS = Symbol(0);
 
 const scopes = new Map;
 
+function scopeOf(e, o) {
+    let n = scopes.get(e);
+    if (n === undefined) scopes.set(e, n = {
+        eo: new Set,
+        oo: [],
+        bt: o
+    });
+    return n;
+}
+
 /** The nodes an `affects(store[, key])` declaration marks (affects.ts
- * registers each). */ function storeMarks(e, n) {
-    if (n === undefined) {
-        const n = getNode(e, $AFFECTS);
-        let o = scopes.get(n);
-        if (o === undefined) scopes.set(n, o = {
-            scope: new Set,
-            inherited: []
-        });
-        const t = [ n ];
-        walk(e.px, o, t, e.fam, new Set);
-        return t;
+ * registers each). */ function storeMarks(e, o) {
+    const n = GlobalQueue.no(e, o === undefined ? $AFFECTS : o);
+    const t = scopeOf(n, o);
+    if (o === undefined) {
+        const o = [ n ];
+        walk(e.px, t, o, e.fam, new Set);
+        return o;
     }
-    const o = e.n?.[n] ?? getNode(e, n);
-    let t = scopes.get(o);
-    if (t === undefined) scopes.set(o, t = {
-        scope: new Set,
-        inherited: [],
-        key: n
-    });
-    t.scope.add(e.v);
-    if (e.pb !== null) t.scope.add(e.pb);
-    return [ o ];
+    t.eo.add(e.v);
+    if (e.pb !== null) t.eo.add(e.pb);
+    return [ n ];
 }
 
 /** The identities reachable from `value` into the scope (the draft's and
  * the committed backing both, when a draft is open; an optimistic family's
  * view), every live node under each record into `found`. Untracked by
- * construction: raws, never traps. */ function walk(e, n, o, t, s) {
-    if (!isWrappable(e)) return;
+ * construction: raws, never traps. */ function walk(e, o, n, t, s) {
+    if (!GlobalQueue.so(e)) return;
     const f = e[$TARGET] ?? lookupTarget(e, t);
-    let i = f !== undefined ? f.pb ?? f.v : e;
-    if (s.has(i)) return;
-    s.add(i);
-    n.scope.add(i);
+    let r = f !== undefined ? f.pb ?? f.v : e;
+    if (s.has(r)) return;
+    s.add(r);
+    o.eo.add(r);
     if (f !== undefined) {
-        if (f.pb !== null) n.scope.add(f.v);
+        if (f.pb !== null) o.eo.add(f.v);
         // The writer's view: the tick's own unflushed guesses are in motion too.
-                if (f.fam?.opt === true) i = optHooks.view(f, i, true);
+                if (f.fam?.opt === true) r = optHooks.view(f, r, true);
         const e = f.n;
-        if (e !== null) for (const n of Reflect.ownKeys(e)) 
+        if (e !== null) for (const o of Reflect.ownKeys(e)) 
         // Another mark's carrier is its own channel: counting it here would
         // extend that scope's lifetime to this declaration's.
-        if (n !== $AFFECTS) o.push(e[n]);
+        if (o !== $AFFECTS) n.push(e[o]);
         const s = f.h;
-        if (s !== null) for (const e of Reflect.ownKeys(s)) o.push(s[e]);
-        if (f.k !== null) o.push(f.k);
-        if (f.dk !== null) o.push(f.dk);
+        if (s !== null) for (const e of Reflect.ownKeys(s)) n.push(s[e]);
+        if (f.k !== null) n.push(f.k);
+        if (f.dk !== null) n.push(f.dk);
         t = f.fam ?? t;
     }
-    for (const e of Reflect.ownKeys(i)) {
-        if (e === $OWNER) continue;
-        const f = Object.getOwnPropertyDescriptor(i, e);
-        if (f === undefined || f.get !== undefined) continue;
-        walk(f.value, n, o, t, s);
+    for (const e of Reflect.ownKeys(r)) if (e !== $OWNER) {
+        const f = Object.getOwnPropertyDescriptor(r, e);
+        if (f.get === undefined) walk(f.value, o, n, t, s);
     }
 }
 
 /** A live scope covering `t`'s identity (keyed: for `key`). Chained
  * backings (§7b): a view's backing is another store's proxy — marks cover
- * the BASE raw, so every identity along the chain is checked. */ function covering(e, n, o) {
+ * the BASE raw, so every identity along the chain is checked. */ function covering(e, o, n) {
     for (const [t, s] of scopes) {
-        if (t === o || s.key !== undefined && s.key !== n) continue;
-        for (let n = e.v; ;) {
-            if (s.scope.has(n)) return t;
-            const e = n?.[$TARGET];
+        if (t === n || s.bt !== undefined && s.bt !== o) continue;
+        for (let o = e.v; ;) {
+            if (s.eo.has(o)) return t;
+            const e = o?.[$TARGET];
             if (e === undefined) break;
-            const o = e.pb ?? e.v;
-            if (o === n) break;
-            n = o;
+            const n = e.pb ?? e.v;
+            if (n === o) break;
+            o = n;
         }
     }
     return null;
 }
 
-installAffectsHooks({
+/** The store's side: node birth and the untracked traps call it (store.ts,
+ * through `affectsHooks`) — with no live mark too: an empty scope map is
+ * no work. */ const hooks = {
     // A node born on a record a live mark covers inherits it (released with
     // the carrier's last registration).
-    born(e, n, o) {
-        if (o === $AFFECTS) return;
-        const t = covering(e, o, n);
-        if (t === null) return;
-        GlobalQueue.h(n);
-        scopes.get(t).inherited.push(n);
+    fo(e, o, n) {
+        if (scopes.size === 0 || n === $AFFECTS) return;
+        const t = covering(e, n, o);
+        if (!t) return;
+        GlobalQueue.O(o);
+        scopes.get(t).oo.push(o);
     },
     // An untracked probe (`isPending(() => s.x)` with no observer) reading a
     // record a live mark covers: no node carries the mark for it — the
     // verdict is told directly.
-    witness(e, n) {
-        const o = e.n?.[$AFFECTS];
-        if (o !== undefined && o.m !== null && o.m.T !== 0 || covering(e, n) !== null) GlobalQueue.Bt();
+    ro(e, o) {
+        if (e.n?.[$AFFECTS]?.m?.T || covering(e, o)) GlobalQueue.Bt();
     }
-});
+};
 
-GlobalQueue.O = storeMarks;
+/** `affects()` calls it before a store-targeted declaration (idempotent). */ function installStoreAffects() {
+    installAffectsHooks(hooks);
+}
 
 /** The carrier's last mark released (affects.ts): its scope dies, and the
- * nodes that inherited the mark release theirs. */ GlobalQueue.N = e => {
-    const n = scopes.get(e);
-    if (n === undefined) return;
+ * nodes that inherited the mark release theirs. */ function releaseMarkScope(e) {
+    const o = scopes.get(e);
+    if (o === undefined) return;
     scopes.delete(e);
-    GlobalQueue.A(n.inherited);
-};
+    GlobalQueue.k(o.oo);
+}
+
+export { installStoreAffects, releaseMarkScope, storeMarks };

package/dist/observe/store/hooks.js

@@ -0,0 +1,13 @@
+let optHooks = null;
+
+function installOptHooks(o) {
+    optHooks = o;
+}
+
+let affectsHooks = null;
+
+function installAffectsHooks(o) {
+    affectsHooks = o;
+}
+
+export { affectsHooks, installAffectsHooks, installOptHooks, optHooks };

package/dist/observe/store/index.js

@@ -2,8 +2,6 @@ import { createStore as createStore$1, deep as deep$1, snapshot as snapshot$1 }
 
 export { storeHasFamily, storeHasOptimisticFamily, storeIsShallow } from "./store.js";
 
-import "./affects.js";
-
 export { createOptimisticStore } from "./optimistic.js";
 
 import { createStoreDerived } from "./projection.js";

package/dist/observe/store/optimistic.js

@@ -10,7 +10,9 @@ import { GlobalQueue, txOf, list, insertSubs, laneDirty, notifyEpoch, schedule }
 
 import { runProjectionComputed } from "./projection.js";
 
-import { wrap, nameStore, storeSetter, LaneView, committed, getNode, unwrapValue, sameKey, installOptHooks, resolveChainedRaw, getHasNode, targetsEqual, getContainerNode, cloneRaw } from "./store.js";
+import { wrap, nameStore, storeSetter, LaneView, committed, getNode, unwrapValue, sameKey, resolveChainedRaw, getHasNode, targetsEqual, getContainerNode, cloneRaw } from "./store.js";
+
+import { installOptHooks } from "./hooks.js";
 
 import { $OWNER } from "./target.js";
 
@@ -79,7 +81,7 @@ function notifyOptimisticWrites(e, n) {
     // inner store's truth for its key before guessing over it.
         const o = e.ch ? e.v : null;
     const guess = (e, n, i, r) => {
-        if (o !== null) e.pe = i ? n in t : unwrapValue(t[n]);
+        if (o !== null) e.Ae = i ? n in t : unwrapValue(t[n]);
         // By value: a function leaf is a value, not an updater (#3017).
                 optimisticWrite(e, () => r);
     };
@@ -157,9 +159,40 @@ function rowSame(e, n, t) {
     if (t === null || !isWrappable(e) || !isWrappable(n)) return false;
     const i = t(unwrapValue(e));
     const r = t(unwrapValue(n));
+    // Keyless rows are identified by position — reconcile's fallback when the
+    // key is missing. The caller already paired these by index, so two keyless
+    // rows are the same row and the landing confirms the arrangement instead of
+    // dissolving it. Dissolving held an external echo under the action, and a
+    // mainline `until` then timed out on a source that already contained it
+    // (#3898). Keyed rows still match only on the key.
+        if (i === undefined && r === undefined) return true;
     return i !== undefined && sameKey(i, r);
 }
 
+/** Whether reconcile would write anything into `a` from `b`: wrappable
+ * pairs descend, leaves compare as its writes do. A key mismatch is a
+ * replacement, which a content difference already says. Plain data — the
+ * server's echo of a guessed row is a new object with the same contents. */ function echoes(e, n) {
+    if (e === n) return true;
+    if (!isWrappable(e) || !isWrappable(n)) return false;
+    e = unwrapValue(e);
+    n = unwrapValue(n);
+    const t = Object.keys(e);
+    if (Array.isArray(e) !== Array.isArray(n) || t.length !== Object.keys(n).length) return false;
+    for (const i of t) if (!hasOwn.call(n, i) || !echoes(e[i], n[i])) return false;
+    return true;
+}
+
+// A cycle (a row that references itself) is not plain data: no match, so
+// the landing stays a correction.
+GlobalQueue.sn = (e, n) => {
+    try {
+        return echoes(e, n);
+    } catch {
+        return false;
+    }
+};
+
 function arrangementEqual(e, n, t) {
     if (Array.isArray(e) !== Array.isArray(n)) return false;
     if (Array.isArray(e)) {
@@ -233,10 +266,10 @@ 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.In = (e, n) => {
+ * positionally — the guess stands as written (the documented residue). */ GlobalQueue._n = (e, n) => {
     const t = e.yt;
     if (t === undefined || e.bt !== $TRACK) return;
-    const i = e.m.Z;
+    const i = e.m.B;
     if (!(i instanceof LaneView)) return;
     if (!Array.isArray(n) || !Array.isArray(i.rows)) {
         i.base = n;
@@ -262,15 +295,15 @@ function arrangementEqual(e, n, t) {
             s.add(t);
         } else a.push(n);
     }
-    const l = i.removed;
+    const u = i.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) && (l === null || !l.has(i))) a.push(t);
+        if (i !== undefined && !s.has(i) && (u === null || !u.has(i))) a.push(t);
     }
     i.rows = a;
     i.base = a;
-    const u = txOf(e);
+    const l = txOf(e);
     const c = committed(t);
     const d = t.n;
     for (let e = 0; e < a.length; e++) {
@@ -279,17 +312,17 @@ function arrangementEqual(e, n, t) {
         // 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], u);
-        } else if (!sameRow(n.u & CONFIG_OVERRIDE ? n.m.Z : c[e], a[e], r)) laneSet(n, a[e], u);
+            if (!sameRow(c[e], a[e], r)) laneSet(getNode(t, e), a[e], l);
+        } else if (!sameRow(n.i & CONFIG_OVERRIDE ? n.m.B : c[e], a[e], r)) laneSet(n, a[e], l);
     }
     if (d !== null) {
         for (let e = a.length; ;e++) {
             const n = d[e];
             if (n === undefined) break;
-            laneSet(n, undefined, u);
+            laneSet(n, undefined, l);
         }
         const e = d.length;
-        if (e !== undefined && (e.u & CONFIG_OVERRIDE || c.length !== a.length)) laneSet(e, a.length, u);
+        if (e !== undefined && (e.i & CONFIG_OVERRIDE || c.length !== a.length)) laneSet(e, a.length, l);
     }
 };
 
@@ -304,11 +337,11 @@ function sameRow(e, n, t) {
  * node that was not the lane's becomes its derivation (its committed value
  * untouched beneath; the lane's end commits the latest). */ function laneSet(e, n, t) {
     const i = ext(e);
-    if (!(e.u & CONFIG_OVERRIDE)) {
-        e.u |= CONFIG_OVERRIDE;
+    if (!(e.i & CONFIG_OVERRIDE)) {
+        e.i |= CONFIG_OVERRIDE;
         list(e, t);
-    } else if (i.Z === n) return;
-    i.Z = n;
+    } else if (i.B === n) return;
+    i.B = n;
     if (e.t !== null) {
         insertSubs(e);
         laneDirty(e, t);
@@ -354,7 +387,7 @@ function sweepOverlaid() {
             // The container shows its backing again (a shown arrangement guess
             // that ended without a landing left its `LaneView` as the value).
                         const t = e.k;
-            if (t !== null && t.pe instanceof LaneView) t.pe = t.pe.base;
+            if (t !== null && t.Ae instanceof LaneView) t.Ae = t.Ae.base;
         }
         if (n.size === 0) overlaidFamilies.delete(e);
     }
@@ -371,8 +404,8 @@ function sweepOverlaid() {
     if (i !== null) for (const e of Reflect.ownKeys(i)) {
         const r = i[e];
         const o = untrack(() => unwrapValue(n[e]));
-        if (r.tn && r.tn(r.pe, o)) continue;
-        r.pe = o;
+        if (r.en && r.en(r.Ae, o)) continue;
+        r.Ae = o;
         // (The lane's end notified it this epoch when the shown value and the
         // covered one differed — its readers re-derive already.)
                 if (r.t !== null && r.Pt !== notifyEpoch) {
@@ -384,8 +417,8 @@ function sweepOverlaid() {
     if (r !== null) for (const e of Reflect.ownKeys(r)) {
         const i = r[e];
         const o = untrack(() => e in n);
-        if (i.pe === o) continue;
-        i.pe = o;
+        if (i.Ae === o) continue;
+        i.Ae = o;
         if (i.t !== null && i.Pt !== notifyEpoch) {
             insertSubs(i);
             t = true;
@@ -394,9 +427,9 @@ function sweepOverlaid() {
     // The arrangement the readers saw (the shown guess) against the inner's
     // now: a structural reader re-derives when they differ.
         const o = e.k;
-    if (o !== null && o.t !== null && o.pe instanceof LaneView && o.Pt !== notifyEpoch) {
+    if (o !== null && o.t !== null && o.Ae instanceof LaneView && o.Pt !== notifyEpoch) {
         const i = Array.isArray(n) ? untrack(() => n.map(unwrapValue)) : n;
-        if (!arrangementEqual(o.pe.rows, i, e.fam?.key ?? null)) {
+        if (!arrangementEqual(o.Ae.rows, i, e.fam?.key ?? null)) {
             insertSubs(o);
             t = true;
         }
@@ -405,12 +438,12 @@ function sweepOverlaid() {
 }
 
 function carriesLane(e) {
-    if (e.k !== null && e.k.u & CONFIG_OVERRIDE) return true;
-    if (e.dk !== null && e.dk.u & CONFIG_OVERRIDE) return true;
+    if (e.k !== null && e.k.i & CONFIG_OVERRIDE) return true;
+    if (e.dk !== null && e.dk.i & CONFIG_OVERRIDE) return true;
     const n = e.n;
-    if (n !== null) for (const e of Reflect.ownKeys(n)) if (n[e].u & CONFIG_OVERRIDE) return true;
+    if (n !== null) for (const e of Reflect.ownKeys(n)) if (n[e].i & CONFIG_OVERRIDE) return true;
     const t = e.h;
-    if (t !== null) for (const e of Reflect.ownKeys(t)) if (t[e].u & CONFIG_OVERRIDE) return true;
+    if (t !== null) for (const e of Reflect.ownKeys(t)) if (t[e].i & CONFIG_OVERRIDE) return true;
     return false;
 }
 
@@ -428,9 +461,9 @@ function overlaid(e) {
  * the backing answers. */ function optimisticHas(e, n) {
     if (!overlaid(e)) return undefined;
     const t = e.h?.[n];
-    if (t !== undefined && t.u & CONFIG_OVERRIDE) return !!shown(t);
+    if (t !== undefined && t.i & CONFIG_OVERRIDE) return !!shown(t);
     const i = e.n?.[n];
-    if (i !== undefined && i.u & CONFIG_OVERRIDE) return shown(i) !== undefined;
+    if (i !== undefined && i.i & CONFIG_OVERRIDE) return shown(i) !== undefined;
     return undefined;
 }
 
@@ -441,7 +474,7 @@ function overlaid(e) {
     if (t === undefined) return undefined;
     if (!t) return null;
     const i = e.n?.[n];
-    const r = i !== undefined && i.u & CONFIG_OVERRIDE ? shown(i) : e.v[n];
+    const r = i !== undefined && i.i & CONFIG_OVERRIDE ? shown(i) : e.v[n];
     // An array's `length` is reported as the array has it (non-configurable).
         if (n === "length" && Array.isArray(e.v)) return {
         value: r,
@@ -474,7 +507,7 @@ i = false) {
         for (const e of Reflect.ownKeys(o)) {
             const r = o[e];
             let s;
-            if (r.u & CONFIG_OVERRIDE) s = t(r); else if (!i || (s = pendingGuessOf(r)) === NOT_PENDING) continue;
+            if (r.i & CONFIG_OVERRIDE) s = t(r); else if (!i || (s = pendingGuessOf(r)) === NOT_PENDING) continue;
             if (e === "length" && Array.isArray(n)) {
                 if (n.length !== s) ensure().length = s;
             } else if (!isEqual(n[e], s) || !hasOwn.call(n, e)) {
@@ -487,10 +520,10 @@ i = false) {
         for (const e of Reflect.ownKeys(s)) {
             const o = s[e];
             let a;
-            if (o.u & CONFIG_OVERRIDE) a = t(o); else if (!i || (a = pendingGuessOf(o)) === NOT_PENDING) continue;
+            if (o.i & CONFIG_OVERRIDE) a = t(o); else if (!i || (a = pendingGuessOf(o)) === NOT_PENDING) continue;
             const f = !!a;
-            const l = r ?? n;
-            if (!f && e in l) delete ensure()[e];
+            const u = r ?? n;
+            if (!f && e in u) delete ensure()[e];
         }
     }
     return r ?? n;
@@ -529,7 +562,7 @@ function createOptimisticStore(e, n, t) {
             if (!a.node) a.node = getOwner();
             runProjectionComputed(f, n, s);
         }, t);
-        i.u &= ~CONFIG_AUTO_DISPOSE;
+        i.i &= ~CONFIG_AUTO_DISPOSE;
         a.node = i;
     }
     return [ f, e => storeSetter(f, e) ];