@solidjs/signals 2.0.0-rc.10 → 2.0.0-rc.13

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

@@ -203,8 +203,10 @@ r = -1) {
         //  - a held ADOPTION (ht): the adopted value already swapped into `v`;
         //    committed is the held view `hv[key]`, staged is `v[key]`.
         const o = heldFoldTransition(e);
-        let f = heldAdoptionTransition(e);
-        if (f !== null) n = e.hv[t]; else if ((f = o) !== null) n = e.v[t];
+        let s = heldAdoptionTransition(e);
+        // A key the adoption left unchanged is not born holding (#3706).
+                if (s !== null && !heldKey(e, t)) s = null;
+        if (s !== null) n = e.hv[t]; else if ((s = o) !== null) n = e.v[t];
         // Create-floor diet: slotSignal bakes the whole node into one literal —
         // no options object, no equals/unobserved closures, no NodeExtension,
         // no post-construction expandos (acc + the wrap cache px/pxv are
@@ -215,7 +217,7 @@ r = -1) {
         // notification machinery. Projection nodes carry the projection
         // computed as their firewall: reads through them link the derive's
         // status/lifecycle (§7b).
-                const s = l = slotSignal(n, slotNodeEquals, e, t, 
+                const f = l = slotSignal(n, slotNodeEquals, e, t, 
         // Accessor-ness resolved ONCE per node (no per-object descriptor
         // scan on reads): accessor keys serve through Reflect.get with the
         // proxy receiver.
@@ -223,13 +225,13 @@ r = -1) {
         // Optimistic families: arm the override slot — setSignal routes armed
         // nodes through the core engine (lanes, ownership, reverts all native).
                 if (e.fam?.opt) {
-            ext(s).Fe = NOT_PENDING;
-            s.C |= CONFIG_OPTIMISTIC;
+            ext(f).Fe = NOT_PENDING;
+            f.C |= CONFIG_OPTIMISTIC;
         }
         // A node born inside a live mark's identity scope inherits the mark
         // (the declaration walk could only cover nodes existing then).
-                if (t !== $AFFECTS && affectsScopesLive()) inheritAffectsMarks(s, e.v, t);
-        if (f !== null) stageHeldKey(s, o !== null ? e.del !== null && e.del.has(t) ? undefined : e.pb[t] : e.v[t], f);
+                if (t !== $AFFECTS && affectsScopesLive()) inheritAffectsMarks(f, e.v, t);
+        if (s !== null) stageHeldKey(f, o !== null ? e.del !== null && e.del.has(t) ? undefined : e.pb[t] : e.v[t], s);
         i[t] = l;
         e.nc++;
         markDescendants(e);
@@ -301,6 +303,33 @@ r = -1) {
     return true;
 }
 
+// #3706: the keys an adoption under a live hold changed against the held
+// view — the adoption twin of `wk` (#3688), keyed on the target. adoptPB
+// records `[adopted object]`; the keys are diffed against IT, once, on the
+// first held read (its children are re-pointed by then), and replace the
+// entry. Never against the live backing — a mainline write during the hold
+// replaces that, and its key is not the adoption's. WK_ALL holds the whole
+// container.
+const heldKeys = new WeakMap;
+
+function heldKey(e, t) {
+    let n = heldKeys.get(e);
+    if (Array.isArray(n)) heldKeys.set(e, n = adoptionChangedKeys(e, n[0]));
+    return n === WK_ALL || n.has(t);
+}
+
+function adoptionChangedKeys(e, t) {
+    const n = e.hv;
+    // A chained backing, an optimistic family, a chained held view, a swapped
+    // or non-plain prototype (inherited accessors read through `this`): whole.
+        if (t[$TARGET] !== undefined || e.fam?.opt === true || n[$TARGET] !== undefined || Object.getPrototypeOf(n) !== Object.getPrototypeOf(t) || !plainProto(t)) return WK_ALL;
+    const r = new Set;
+    // Accessors are never invoked: they and a flipped enumerability are changes.
+        for (const i of Reflect.ownKeys(n)) if (!hasOwn.call(t, i) || isOwnAccessor(n, i) || isOwnAccessor(t, i) || propertyIsEnumerable.call(n, i) !== propertyIsEnumerable.call(t, i) || !(isEqual(n[i], t[i]) || sameLogicalSlot(e, n[i], t[i]))) r.add(i);
+    for (const e of Reflect.ownKeys(t)) if (!hasOwn.call(n, e)) r.add(e);
+    return r;
+}
+
 function stageHeldKey(e, t, n) {
     if (slotNodeEquals.call(e, e.ce, t)) return;
     e._e = t;
@@ -449,6 +478,23 @@ let hookInstalled = false;
     return r;
 }
 
+/** Shallow copy of a WIDE plain-data (sc 2) backing for the overlay rebuild
+ * (#3689). Own keys land on a null-prototype object — V8 creates those in
+ * dictionary mode, so the copy is O(keys) hash inserts — and the prototype
+ * is attached after. A spread builds a fast-mode object one map transition
+ * per key; from a source in dictionary mode (a backing that took deletes)
+ * whose key order differs from the last copy's, every transition is a fresh
+ * map with an O(keys) descriptor copy: measured 270 µs vs 28 µs at 400 keys,
+ * 1.3 ms vs 75 µs at 1000. Narrow, stable-shaped backings keep the spread
+ * (cloneRaw): there the clone IC copies the property store at once and is
+ * 3–8× cheaper than any per-key loop. */ function wideClone(e, t) {
+    const n = Object.create(null);
+    for (const t of Reflect.ownKeys(e)) n[t] = e[t];
+    Object.setPrototypeOf(n, Object.prototype);
+    n[$OWNER] = t;
+    return n;
+}
+
 /** Copy own `key` from `from` onto `to`. A plain data slot (enumerable,
  * writable, configurable, no accessor) is a bare assignment — the common case
  * and the cheap one; anything else goes through defineProperty so accessors
@@ -485,21 +531,67 @@ let hookInstalled = false;
  * backing into a prototype, and every later flatten writes into that
  * prototype); above it the clone's O(keys) copy dominates (#3044). */ const OVERLAY_MIN_KEYS = 32;
 
+/** Overlay commit choice (#3689): flatten in place, or rebuild the backing
+ * (materializePB, then the clone path's swap)? Measured on V8 (Node 26): a
+ * committed backing that has served as an overlay prototype is kept as a
+ * FAST-MODE prototype object up to V8's descriptor limit (1020 own
+ * properties), and there every in-place DELETE is O(keys) — normalize to
+ * dictionary plus re-optimize as a prototype, ~0.08 µs × keys — and every
+ * in-place ADD is a map transition copying the descriptors, ~0.006 µs ×
+ * keys. Detaching the overlay first does not help: prototype-ness is a
+ * property of the object's map. One rebuild (wideClone, deletes, writes) is
+ * ~0.07–0.09 µs × keys — the price of ONE in-place delete. So a fold that
+ * deleted anything, or added more than ~16 keys, commits cheaper rebuilt (a
+ * 400-key record churning 100 keys per commit, 10,000 membership readers:
+ * 4.7 ms → 0.22 ms per step); a pure rewrite of existing keys — the
+ * overlay's home case — stays in place at O(written).
+ * Past the descriptor limit V8 keeps the backing in dictionary mode where
+ * every in-place op is O(1), and a rebuild would be a pure O(keys) loss on
+ * exactly the growing-record pattern the overlay exists for (#3044) — the
+ * count gate keeps those in place. The gate reads `kc`, which the set trap
+ * counts up for keys new to the container and the delete commit counts down. */ const OVERLAY_REBUILD_MAX_KEYS = 1024;
+
+const OVERLAY_REBUILD_MIN_ADDS = 16;
+
+function overlayRebuilds(e, t) {
+    if (e.kc > OVERLAY_REBUILD_MAX_KEYS) return false;
+    if (e.del !== null && e.del.size !== 0) return true;
+    // Every trap write records its key, so the written-key count bounds the
+    // adds — the common few-key fold (#3044's growing record) answers here
+    // without enumerating the overlay.
+        const n = e.wk;
+    if (n !== null && n !== WK_ALL && n.size <= OVERLAY_REBUILD_MIN_ADDS) return false;
+    const r = e.v;
+    let i = 0;
+    for (const e of Reflect.ownKeys(t)) if (!hasOwn.call(r, e) && ++i > OVERLAY_REBUILD_MIN_ADDS) return true;
+    return false;
+}
+
 /** Downgrade a prototype-overlay pending backing to the clone path: builds
  * the real container (committed + overlay writes − deletes) that fold will
  * SWAP in as the committed backing, exactly as if the draft had started on
  * the clone path. Consumers that need a complete container (reconcile's
- * diff walks, drafts escaping into other storage) call this. */ function materializePB(e) {
-    if (!e.ovl) return;
+ * diff walks, drafts escaping into other storage) call this, and so does the
+ * commit itself when the fold changed the key set (overlayRebuilds). Returns
+ * the pending backing (the clone, or the pb as-is when not an overlay). */ function materializePB(e) {
     const t = e.pb;
-    const n = cloneRaw(e.v, e);
-    for (const e of Reflect.ownKeys(t)) copyOwn(n, t, e);
-    if (e.del !== null) {
+    if (!e.ovl) return t;
+    const n = e.sc === 2 ? wideClone(e.v, e) : cloneRaw(e.v, e);
+    // Deletes before writes (#3689): on a fast-mode clone (the descriptor
+    // path) the first delete normalizes it once, and the writes then land as
+    // O(1) dictionary adds instead of O(keys) map transitions each. Order is
+    // free semantically — a rewritten key left `del` at write time, so no
+    // write targets a deleted key.
+        if (e.del !== null) {
         for (const t of e.del) delete n[t];
+        e.kc -= e.del.size;
         e.del = null;
     }
+    // Plain-data grade (sc 2): bare assignment, as flattenOverlay does.
+        for (const r of Reflect.ownKeys(t)) e.sc === 2 ? n[r] = t[r] : copyOwn(n, t, r);
     e.pb = n;
     e.ovl = false;
+    return n;
 }
 
 function ensurePB(e) {
@@ -639,6 +731,7 @@ function ensurePB(e) {
         if (heldMaskView(e) === null) e.hv = e.v;
         e.ht = activeTransition ?? PLAIN_HOLD;
         if (!n && activeTransition !== null) heldAdoptions.add(e);
+        heldKeys.set(e, [ t ]);
     }
     e.pb = null;
     // Overlay and accessor-scan state describe the OUTGOING backing — a
@@ -770,6 +863,7 @@ function queueFold(e) {
         for (const r of Reflect.ownKeys(t)) e.sc === 2 ? n[r] = t[r] : copyOwn(n, t, r);
     if (e.del !== null) {
         for (const t of e.del) delete n[t];
+        e.kc -= e.del.size;
         e.del = null;
     }
     e.pb = null;
@@ -828,11 +922,13 @@ function drainFolds() {
  // re-queue: commit happens when the hold settles
                                 continue;
             }
-            if (t.ovl) {
+            if (t.ovl && (t.v !== n || !overlayRebuilds(t, i))) {
                 // Overlay flatten (#3044): the backing keeps its identity, so the
                 // `t.v === old` gate below skips path copying (the parent slot
                 // already points here) and the adopted-notify (setter notifications
-                // happened at write time).
+                // happened at write time). A backing privatized mid-batch is a fresh
+                // clone, never a prototype — in-place writes into it are cheap, and
+                // the merge branch below is what a materialized pb would need anyway.
                 flattenOverlay(t, i);
             } else if (t.v !== n) {
                 // Privatized mid-batch (#3271): an earlier fold in this drain
@@ -873,7 +969,10 @@ function drainFolds() {
                 t.wk = null;
  // written-keys window closes with the fold commit
                         } else {
-                t.v = i;
+                // An overlay whose fold changed the key set rebuilds (#3689) and
+                // takes the swap like a clone-path draft: the parent slot re-points
+                // in the path copy below.
+                t.v = t.ovl ? materializePB(t) : i;
                 t.ch = false;
  // pb is always a plain clone
                                 t.pb = null;
@@ -1052,8 +1151,12 @@ function drainFolds() {
         if (e.ht !== null) e.ht = e.hv = null;
         // Overlay landing (#3352): flatten in place — identity-stable, and
         // privatizeCommitted re-slots the parent itself when it has to clone an
-        // unowned seed, so no path copy is needed.
-                if (e.ovl) return flattenOverlay(e, t);
+        // unowned seed, so no path copy is needed. A landing that changed the
+        // key set rebuilds instead (#3689) and swaps like a clone-path landing.
+                if (e.ovl) {
+            if (!overlayRebuilds(e, t)) return flattenOverlay(e, t);
+            t = materializePB(e);
+        }
         const n = e.v;
         e.pb = null;
         e.v = t;
@@ -1124,8 +1227,8 @@ i = true) {
             return;
         }
         const o = i?.value;
-        const f = l?.value;
-        if (!isEqual(o, f) && !targetsEqual(o, f)) setSignal(e, typeof f === "function" ? () => f : f);
+        const s = l?.value;
+        if (!isEqual(o, s) && !targetsEqual(o, s)) setSignal(e, typeof s === "function" ? () => s : s);
     } else {
         const i = n[t];
         const l = r[t];
@@ -1295,21 +1398,25 @@ const UNSAFE_KEYS = new Set([ "__proto__", "prototype", "constructor" ]);
     return false;
 }
 
-function readSource(e) {
+/** The backing a reader is served. `key` (the get/has/descriptor traps)
+ * scopes a fold hold to the keys the fold touched — see pendingBackingVisible —
+ * and an adoption hold to the keys the adoption changed (heldKey). */ function readSource(e, t) {
     // Adoption hold first (#3074): an adoption staged under a live transaction
     // (or a latest()-pull, PLAIN_HOLD) serves the pre-hold committed view to
     // committed-visibility readers — context-free and children-forbidden ones,
     // and stale passes off a foreign hold. Drafts, write-override and latest()
     // see the adopted backing.
-    const t = e.ht;
-    if (t !== null && !latestReadActive && !inDraft(e) && !getWriteOverride()) {
-        const n = heldMaskView(e);
-        if (n !== null) {
+    const n = e.ht;
+    if (n !== null && !latestReadActive && !inDraft(e) && !getWriteOverride()) {
+        const r = heldMaskView(e);
+        // A key the adoption left unchanged derives nothing from the hold, for
+        // any reader (#3706): the backing serves it.
+                if (r !== null && (t === undefined || heldKey(e, t))) {
             const e = readerContext();
-            if (e === null || e.C & CONFIG_CHILDREN_FORBIDDEN || !holdVisible(t === PLAIN_HOLD ? null : currentTransition(t), e)) return n;
+            if (e === null || e.C & CONFIG_CHILDREN_FORBIDDEN || !holdVisible(n === PLAIN_HOLD ? null : currentTransition(n), e)) return r;
         }
     }
-    return pendingBackingVisible(e, false) ? e.pb : e.v;
+    return pendingBackingVisible(e, false, t) ? e.pb : e.v;
 }
 
 /** The single pb-vs-committed visibility decision (#3147), shared by per-key
@@ -1326,7 +1433,7 @@ function readSource(e) {
  * `speculative` is deep()/snapshot's posture: an untrack/deep PEEK that sees
  * ordinary pending staging regardless of owner context (the documented
  * divergence from context-free per-key reads) — but never through a hold:
- * held truth stays masked exactly as it is for per-key readers. */ function pendingBackingVisible(e, t) {
+ * held truth stays masked exactly as it is for per-key readers. */ function pendingBackingVisible(e, t, n) {
     if (e.pb === null) return false;
     // The writer's own channels compose on the pending backing regardless.
         if (inDraft(e) || getWriteOverride()) return true;
@@ -1337,8 +1444,8 @@ function readSource(e) {
     // hold arms below: committed for no pass, the staged backing for the
     // holding pass, stale-of-foreign or A29 for a foreign one.
         if (heldTruthMasked(e)) return false;
-    const n = readerContext();
-    if (n === null || n.C & CONFIG_CHILDREN_FORBIDDEN) {
+    const r = readerContext();
+    if (r === null || r.C & CONFIG_CHILDREN_FORBIDDEN) {
         // No pass, or a children-forbidden one: the committed frame (A32) —
         // except the speculative peek (deep()/snapshot()), which sees ordinary
         // pending staging but never through a live foreign hold, and a
@@ -1346,11 +1453,30 @@ function readSource(e) {
         // readers UNLESS a transition holds the node commits (downstream async
         // hold — stale committed is the contract; the write-time stamp covers
         // keys with no node, #3336) or the scope is children-forbidden (#3082).
-        const r = liveFoldTransition(e);
-        if (t) return r === null || ownsHold(r);
-        return e.fam !== null && n === null && !foldHeld(e) && r === null;
+        const n = liveFoldTransition(e);
+        if (t) return n === null || ownsHold(n);
+        return e.fam !== null && r === null && !foldHeld(e) && n === null;
+    }
+    const i = liveFoldTransition(e);
+    // A hold changes what a reader of ONE key sees only through the fold's
+    // writes to that key. A key the fold left alone reads the same from either
+    // backing, so a pass reading it derives nothing from the hold: serve
+    // committed, with no transaction entry and no stale replay (#3688 — a memo
+    // reading an unchanged key beside an independent signal was held with
+    // someone else's action). Per-node reads already have this precision (a
+    // node with nothing staged enters nothing; stageHeldKey skips an equal
+    // value); this is the same rule at the container gate. `wk` is the trap's
+    // record of every write and delete this batch (deletes included, on the
+    // overlay and clone paths alike); null (a fold with no trap writes) or
+    // WK_ALL (an array length write) leaves the whole container held. Same
+    // exclusions as heldFoldTransition: an optimistic family's draft is seeded
+    // from node overrides the trap never saw, and a chained backing's
+    // committed layer is a live proxy, not a frozen twin of the clone.
+        if (i !== null && n !== undefined && !e.ch && e.fam?.opt !== true) {
+        const t = e.wk;
+        if (t != null && t !== WK_ALL && !t.has(n)) return false;
     }
-    return holdVisible(liveFoldTransition(e), n);
+    return holdVisible(i, r);
 }
 
 /** #3164 fold: HELD truth on an optimistic family — a pending backing
@@ -1481,7 +1607,7 @@ function isOwnAccessor(e, t) {
  * node is linked only for adoption-swap notification, its value never
  * shadows the live chain. */ function serveDataKey(e, t, n, r, i, l = -1) {
     const o = e.ch && r === e.v;
-    let f = n;
+    let s = n;
     // §6: on optimistic arrays LENGTH IS A VIEW, not a node value — one home
     // (backing ± presence overrides) for both length and indices makes torn
     // iteration impossible (a length node's value rides different visibility
@@ -1531,7 +1657,7 @@ function isOwnAccessor(e, t) {
         // seeding rule, applied to the read side (#3108).
         if (e.fam?.opt && draftSeesOverrides(e) && !authoritativeServe()) {
             const n = e.n?.[t];
-            if (n !== undefined && hasActiveOverride(n)) f = unwrapOverride(n.o?.Fe);
+            if (n !== undefined && hasActiveOverride(n)) s = unwrapOverride(n.o?.Fe);
         }
     } else {
         // §7b: a lane value on the outer node SHADOWS read-through — an active
@@ -1548,26 +1674,26 @@ function isOwnAccessor(e, t) {
             // parity): READ_SLOW = a global read window or non-plain node.
                         let r = readNodeFast(i);
             if (r === READ_SLOW) r = read(i);
-            if (!o || hasActiveOverride(i)) f = r === FORCE ? n : r;
+            if (!o || hasActiveOverride(i)) s = r === FORCE ? n : r;
         } else if (i !== undefined && (!o || hasActiveOverride(i))) {
-            f = nodeValue(i, n);
+            s = nodeValue(i, n);
         }
     }
     // Shallow stores serve data raw; store-proxy slots get boundary wrappers.
-        if (e.s) return serveShallow(e, t, f);
-    if (e.ch && !o && f !== null && typeof f === "object" && f[$TARGET] === undefined) f = resolveChainedRaw(e, t, f);
+        if (e.s) return serveShallow(e, t, s);
+    if (e.ch && !o && s !== null && typeof s === "object" && s[$TARGET] === undefined) s = resolveChainedRaw(e, t, s);
     if (i !== undefined) {
         // Wrap cache (see getNode): only wrappables are ever cached, so a hit
         // skips isWrappable too — pointer-compare replaces both checks.
-        if (i.pxv === f && f !== undefined) return draftServe(e, i.px);
-        if (!isWrappable(f)) return f;
-        const n = wrapNext(f, e, t);
+        if (i.pxv === s && s !== undefined) return draftServe(e, i.px);
+        if (!isWrappable(s)) return s;
+        const n = wrapNext(s, e, t);
         i.px = n;
-        i.pxv = f;
+        i.pxv = s;
         return draftServe(e, n);
     }
-    if (!isWrappable(f)) return f;
-    return draftServe(e, wrapNext(f, e, t));
+    if (!isWrappable(s)) return s;
+    return draftServe(e, wrapNext(s, e, t));
 }
 
 /** §6c store-wide status gate for reads that DON'T flow through a node:
@@ -1646,7 +1772,7 @@ const traps = {
         // observer, so bring the projection computed up to date here — signal/
         // memo parity for latest() reads through a projection.
                 if (e.fam !== null && latestReadActive && !inDraft(e) && !getWriteOverride()) pullProjectionForLatest(e);
-        const r = readSource(e);
+        const r = readSource(e, t);
         // Overlay delete (#3044): a prototype overlay cannot shadow a delete, so
         // deleted keys are tracked aside and read as absent in the pending view.
                 if (e.del !== null && r === e.pb && e.del.has(t)) {
@@ -1716,15 +1842,15 @@ const traps = {
         // that is own on NEITHER.
                 const o = e.ovl && r === e.pb;
         if ((t === "constructor" || t === "__proto__" || t === "prototype") && !hasOwn.call(r, t) && !(o && hasOwn.call(e.v, t))) return undefined;
-        let f = r[t];
-        if (f === undefined ? !hasOwn.call(r, t) && !(o && hasOwn.call(e.v, t)) : false) {
+        let s = r[t];
+        if (s === undefined ? !hasOwn.call(r, t) && !(o && hasOwn.call(e.v, t)) : false) {
             // Inherited: prototype getters/methods run with the proxy receiver.
-            f = Reflect.get(r, t, n);
-            if (typeof f === "function") return f;
+            s = Reflect.get(r, t, n);
+            if (typeof s === "function") return s;
  // proto methods untracked
             // Reading a currently-absent own key subscribes to it (R12) — for any
             // target OUTSIDE its own draft scope, even mid-setter (#3037, above).
-                        if (f === undefined && !inDraft(e)) {
+                        if (s === undefined && !inDraft(e)) {
                 if (getObserver() !== null) read(getNode(e, t, undefined, l));
                 const n = e.n?.[t];
                 if (n) {
@@ -1732,7 +1858,7 @@ const traps = {
                     if (e.s) return serveShallow(e, t, r);
                     return isWrappable(r) ? draftServe(e, wrapNext(r, e, t)) : r;
                 }
-            } else if (f === undefined && inDraft(e) && e.fam?.opt && draftSeesOverrides(e) && 
+            } else if (s === undefined && inDraft(e) && e.fam?.opt && draftSeesOverrides(e) && 
             // AUTHORITATIVE drafts (landing folds) never seed from overrides —
             // the caller's optimism is not truth (has-trap twin below).
             !authoritativeServe()) {
@@ -1742,21 +1868,21 @@ const traps = {
                 // arm, visibleKeys and optimisticView do. Reader-gating this arm
                 // (visibleOverride) made a second setter in the same action read
                 // `undefined` where the first had pushed a row (#3665, rc.9).
-                                if (n !== undefined && hasActiveOverride(n)) f = unwrapOverride(n.o?.Fe);
+                                if (n !== undefined && hasActiveOverride(n)) s = unwrapOverride(n.o?.Fe);
             }
-            if (e.s) return serveShallow(e, t, f);
-            return isWrappable(f) ? draftServe(e, wrapNext(f, e, t)) : f;
+            if (e.s) return serveShallow(e, t, s);
+            return isWrappable(s) ? draftServe(e, wrapNext(s, e, t)) : s;
         }
-        if (typeof f === "function" && !hasOwn.call(r, t) && !(o && hasOwn.call(e.v, t))) return f;
+        if (typeof s === "function" && !hasOwn.call(r, t) && !(o && hasOwn.call(e.v, t))) return s;
  // proto method
-                return serveDataKey(e, t, f, r, i, l);
+                return serveDataKey(e, t, s, r, i, l);
     },
     has(e, t) {
         if (t === $TARGET || t === $PROXY || t === $TRACK) return true;
         if (t === $OWNER || t === $RECORD) return false;
         if (pendingCheckActive) witnessAffectsMark(e, t);
         if (e.fam !== null && getObserver() === null && !inDraft(e)) firewallGate(e);
-        const n = readSource(e);
+        const n = readSource(e, t);
         let r = t in n;
         // Overlay deletes read as absent in the pending view (#3044).
                 if (r && e.del !== null && n === e.pb && e.del.has(t)) r = false;
@@ -1812,7 +1938,7 @@ const traps = {
                 if (pendingCheckActive) witnessAffectsMark(e, t);
         const n = getObserver();
         if (e.fam !== null && n === null && !inDraft(e)) firewallGate(e);
-        const r = readSource(e);
+        const r = readSource(e, t);
         const i = visibleDescriptor(e, r, t);
         if (!inDraft(e) && n !== null && !observerHoldsKeySet(e, n)) {
             // The node is born from the source's presence (as `has` births it),
@@ -1857,10 +1983,12 @@ const traps = {
             }
         } else {
             if (e.wk !== WK_ALL) (e.wk ??= new Set).add(t);
-            // Live own-key estimate for the overlay/clone choice (#3360): `in`
-            // sees through an overlay to the committed keys, so this counts keys
-            // NEW to the container. Deletes are not un-counted (a stale high
-            // count only picks the overlay a little early).
+            // Live own-key estimate for the overlay/clone choice (#3360) and the
+            // overlay's commit choice (#3689): `in` sees through an overlay to the
+            // committed keys, so this counts keys NEW to the container. Overlay
+            // deletes are counted down when they commit (`del` is exact); clone-
+            // path deletes are not (a stale high count on a narrow container only
+            // picks the overlay a little early).
                         if (!(t in o)) e.kc++;
         }
         // Own data keys literally named "prototype"/"constructor" land as data —
@@ -2269,9 +2397,9 @@ function snapshotWalk(e, t, n) {
         // Snapshot runs mid-flush (tracked memos execute before commit), so a
         // pending prototype overlay must present as a REAL merged container.
                 if (o && l.ovl) materializePB(l);
-        const f = o ? l.pb : l.v;
-        if (f === r) break;
-        r = f;
+        const s = o ? l.pb : l.v;
+        if (s === r) break;
+        r = s;
     }
     if (!isWrappable(r)) return r;
     // Optimistic families: compose the visible view; a composed view is a fresh
@@ -2322,11 +2450,11 @@ function snapshotWalk(e, t, n) {
                 Object.defineProperty(i, l, o);
                 continue;
             }
-            const f = o.value;
-            const s = f !== null && typeof f === "object" ? snapshotWalk(f, t, n) : f;
-            if (o.enumerable && o.writable && o.configurable) i[l] = s; else Object.defineProperty(i, l, {
+            const s = o.value;
+            const f = s !== null && typeof s === "object" ? snapshotWalk(s, t, n) : s;
+            if (o.enumerable && o.writable && o.configurable) i[l] = f; else Object.defineProperty(i, l, {
                 ...o,
-                value: s
+                value: f
             });
         }
         if (e && i.length !== r.length) i.length = r.length;
@@ -2341,13 +2469,13 @@ function snapshotWalk(e, t, n) {
         if (!i || i.get || i.set) continue;
         const l = i.value;
         if (l === null || typeof l !== "object") continue;
-        const f = snapshotWalk(l, t, n);
-        if (f !== l) {
+        const s = snapshotWalk(l, t, n);
+        if (s !== l) {
             if (o === null) {
                 o = Array.isArray(r) ? [ ...r ] : Object.create(Object.getPrototypeOf(r), Object.getOwnPropertyDescriptors(r));
                 t.set(r, o);
             }
-            o[e] = f;
+            o[e] = s;
         }
     }
     return o ?? r;

package/dist/types/core/attribution-hooks.d.ts

@@ -258,6 +258,34 @@ export interface NavigationRef {
      * a pending navigation to fold onto it opens a navigation of its own.
      */
     redirect?: number;
+    /**
+     * The route the document arrived on — declared by the router around the
+     * work that establishes its initial match (building its context), not
+     * around a write: there is no location write on a fresh document, and
+     * without this a consumer has the route pattern for every navigation
+     * but the first. The record opens at `at`, which defaults to `0` (the
+     * `performance.now()` origin — the document's own navigation start, so
+     * the record joins Navigation Timing); a router mounted long after the
+     * document loaded passes its own start. It settles when the frame closes,
+     * `committed` with no writes: it declares the route, it does not time the
+     * mount — the holds the mount waits in are their own records. `from` is
+     * meaningless for it and ignored.
+     */
+    initial?: boolean;
+    /**
+     * The interaction the navigation is for, when the router already knows it
+     * will not be on the stack at write time. A router that awaits between
+     * the request and the write (guards or loaders resolved in its core before
+     * it publishes the location) captures `OBSERVE.attribution.currentOrigin()`
+     * in the request and hands it back here, and the record — and every hold
+     * and re-run its write causes — joins the click as if the write had been
+     * synchronous. Any origin will do: the engine takes the interaction it
+     * carries. Declared beats ambient: the key's presence is the declaration
+     * — `interaction: currentOrigin()` with nothing in effect at the request
+     * (`undefined`) declares that the navigation was for no interaction, and an
+     * interaction on the stack at write time is used only when the key is absent.
+     */
+    interaction?: ChangeOrigin;
 }
 export declare let attrHooks: AttributionHooks | null;
 export declare function setAttributionHooks(hooks: AttributionHooks | null): void;

package/dist/types/core/attribution.d.ts

@@ -815,6 +815,15 @@ export interface NavigationEvent {
     params?: Readonly<Record<string, string | undefined>>;
     /** When the navigation was requested (`performance.now()` clock). */
     at: number;
+    /**
+     * The route the document arrived on, declared by the router at its initial
+     * match (`NavigationRef.initial`): `at` is the document's navigation start
+     * (`0` unless the router passed its own), there is no `from`, `writes` is
+     * `0`, and it settles `committed` when the router's frame closes — the
+     * record names the route the page loaded as; its timing is Navigation
+     * Timing's, not the runtime's.
+     */
+    initial?: true;
     /** The user interaction it ran under, when known — a link click. */
     interaction?: ChangeOrigin;
     /** Root writes the frame performed, redirect hops included. */

package/dist/types/core/constants.d.ts

@@ -148,20 +148,29 @@ export declare const CONFIG_OVERRIDE_SUPERSEDED: number;
  * transaction. A parked node (status propagation stamps `_transition`
  * without recomputing) recomputed when its source lands otherwise disposed
  * its committed children mid-hold, running their cleanups before the
- * transaction's atomic reveal. Cleared by `commitPendingNode`. */
+ * transaction's atomic reveal. Cleared by `commitPendingNode`. Transaction
+ * work only (A15 lane work and transaction work, #3698): zombies are parked
+ * by a pass under a held transaction; a pass over a lane parks a LANE frame
+ * instead (`CONFIG_LANE_FRAME`), whatever the node's kind. */
 export declare const CONFIG_HELD_CHILDREN: number;
 /** The frame parked in `_pendingFirstChild` / `_pendingDisposal` is a LANE
- * frame (#3662, A15 lanes corollary): an effect's lane pass direct-commits,
- * so the frame it replaces leaves the screen when the lane's queue applies
- * the run (A30) — not at the action's commit like #3404's transaction
- * zombies, and not at the pass (a held lane defers the run). Drained by the
- * lane's render entry the parking site pushed ahead of the new frame's
- * effects (cleanups before side effects), by `commitPendingNode` if a hold
- * commits the node first, or with the owner's death. While set the parked
- * frame is not a hold (the node is not queued or stamped for it), a
- * superseding pass disposes the never-shown live children on the spot, and a
- * lane-channel dirty on a member is cancelled (`laneZombie`). Effects only: a
- * memo's lane pass publishes an override (A17, #3479). */
+ * frame (#3662, #3698; A15 lane work and transaction work): a lane pass —
+ * on an effect or a memo alike — publishes into the lane's frame (an
+ * effect's run; a memo's derived override, A17), so the frame it replaces
+ * leaves the screen when the lane applies (A30) — not at the action's
+ * commit like #3404's transaction zombies, and not at the pass (a held lane
+ * defers the apply with the frame still displayed). Drained by the lane's
+ * render entry the parking site pushed ahead of the new frame's effects
+ * (cleanups before side effects), by `commitPendingNode` if a hold commits
+ * the node first, or with the owner's death. While set the parked frame is
+ * not a hold (the node is not queued or stamped for it — lane work never
+ * makes its node transaction work), a superseding pass disposes the
+ * never-shown live children on the spot, and a lane-channel dirty on a
+ * member is cancelled (`laneZombie`). Ruled 2026-09-28 (#3698): a pass is
+ * lane work or transaction work by its owner, never by node kind. #3662
+ * flagged effects only, and a memo's lane pass parked a transaction zombie
+ * that queued and stamped the memo as the action's pending node, so its
+ * next mainline recompute re-entered the hold. */
 export declare const CONFIG_LANE_FRAME: number;
 /** In-flight async node whose inputs were PUBLISHED while it was pending: a
  * batch or transaction committed with the node still `STATUS_PENDING` (an