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

package/dist/dev.js

@@ -42,11 +42,11 @@ import {
   K as currentOptimisticLane,
   L as enterStagedRead,
   M as currentTransition,
-  P as queuePendingNode,
-  Q as latestReadActive,
-  T as REACTIVE_MANUAL_WRITE,
-  U as REACTIVE_OPTIMISTIC_DIRTY,
-  V as assignOrMergeLane,
+  P as assignOrMergeLane,
+  Q as queuePendingNode,
+  T as latestReadActive,
+  U as REACTIVE_MANUAL_WRITE,
+  V as REACTIVE_OPTIMISTIC_DIRTY,
   W as LANE_RUN,
   X as attrHooks,
   Y as EFFECT_USER,
@@ -750,8 +750,53 @@ function overrideRead(el, c) {
  * action provenance, or an A17-silent confirmation (#3331). Before this the
  * landing took setSignal's plain path: a differing truth staged silently
  * under the override and the graph never moved until the commit.
+ *
+ * Slot arm (list-matrix F1): `mapArray`'s writes to its per-slot signals —
+ * the row accessors of index mode, the index accessors of keyed mode; never
+ * CONFIG_OPTIMISTIC, which is how the arm tells them from the store landings
+ * above — once a lane pass has run over the map. The list's frame lives in
+ * these writes as much as in the computed's result. Under a LANE pass the
+ * write is the lane's frame, as the computed's result is (lanes stage,
+ * `laneOverride`): the slot joins the lane carrying a DERIVED override —
+ * `_value` stays the committed row, the lane's readers and untracked reads
+ * see the override (A17), an off-lane render effect sees the committed frame
+ * (#3460), the revert promotes or drops it with the lane's transaction. The
+ * gate compares against the slot the pass publishes to (INV-11): the override
+ * when armed, the committed row otherwise. A plain `setSignal` here staged
+ * the write into the ACTION's transaction: `<For>` without `keyed` showed the
+ * pre-action list for the whole action while the keyed modes showed the
+ * optimistic one. A PLAIN pass over a slot still carrying the lane's frame —
+ * the landing, the reversion, a mainline re-pass — is the truth arriving
+ * under an override and takes the landing path below: a differing truth
+ * supersedes, an equal one confirms and the revert promotes. Every pass
+ * rewrites every slot whose value differs from the previous frame's (index
+ * mode rewrites every surviving slot), so a slot the landing does NOT write
+ * holds, by construction, what the truth yields. A slot with neither a lane
+ * nor an override is the plain write.
  */
 function landOnOverride(el, v) {
+  if (!(el._config & CONFIG_OPTIMISTIC)) {
+    const lane = currentOptimisticLane;
+    if (lane === null) {
+      if (!hasActiveOverride(el)) return setSignal(el, v);
+    } else {
+      // INV-11: the gate compares against the slot this pass publishes to —
+      // the override when one is armed, the committed row otherwise.
+      if (
+        !el._equals ||
+        !el._equals(hasActiveOverride(el) ? unwrapOverride(el._x._overrideValue) : el._value, v)
+      ) {
+        // Membership before the publish: `laneOverride` files the slot under
+        // the lane's transaction, and the read path routes a tracked reader
+        // of a lane member through `overrideRead` (CONFIG_HAS_LANE).
+        assignOrMergeLane(el, lane);
+        laneOverride(el, v, lane);
+        insertSubs(el, true);
+        schedule();
+      }
+      return v;
+    }
+  }
   const currentValue = el._pendingValue === NOT_PENDING ? el._value : el._pendingValue;
   if (typeof v === "function") v = v(currentValue);
   if (attrHooks !== null) attrHooks.write(el, currentValue, v);
@@ -4749,6 +4794,8 @@ function getNode(
     //    committed is the held view `hv[key]`, staged is `v[key]`.
     const fold = heldFoldTransition(target);
     let held = heldAdoptionTransition(target);
+    // A key the adoption left unchanged is not born holding (#3706).
+    if (held !== null && !heldKey(target, key)) held = null;
     if (held !== null) current = target.hv[key];
     else if ((held = fold) !== null) current = target.v[key];
     // Create-floor diet: slotSignal bakes the whole node into one literal —
@@ -4871,6 +4918,45 @@ function holdVisible(txn, c) {
   enterStagedRead(null, txn);
   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(target, key) {
+  let keys = heldKeys.get(target);
+  if (Array.isArray(keys)) heldKeys.set(target, (keys = adoptionChangedKeys(target, keys[0])));
+  return keys === WK_ALL || keys.has(key);
+}
+function adoptionChangedKeys(target, v) {
+  const hv = target.hv;
+  // A chained backing, an optimistic family, a chained held view, a swapped
+  // or non-plain prototype (inherited accessors read through `this`): whole.
+  if (
+    v[$TARGET] !== undefined ||
+    target.fam?.opt === true ||
+    hv[$TARGET] !== undefined ||
+    Object.getPrototypeOf(hv) !== Object.getPrototypeOf(v) ||
+    !plainProto(v)
+  )
+    return WK_ALL;
+  const keys = new Set();
+  // Accessors are never invoked: they and a flipped enumerability are changes.
+  for (const key of Reflect.ownKeys(hv))
+    if (
+      !hasOwn.call(v, key) ||
+      isOwnAccessor(hv, key) ||
+      isOwnAccessor(v, key) ||
+      propertyIsEnumerable.call(hv, key) !== propertyIsEnumerable.call(v, key) ||
+      !(isEqual(hv[key], v[key]) || sameLogicalSlot(target, hv[key], v[key]))
+    )
+      keys.add(key);
+  for (const key of Reflect.ownKeys(v)) if (!hasOwn.call(hv, key)) keys.add(key);
+  return keys;
+}
 function stageHeldKey(node, nv, txn) {
   if (slotNodeEquals.call(node, node._value, nv)) return;
   node._pendingValue = nv;
@@ -5071,6 +5157,23 @@ function cloneRaw(source, t) {
   clone[$OWNER] = t;
   return clone;
 }
+/** 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(source, t) {
+  const clone = Object.create(null);
+  for (const key of Reflect.ownKeys(source)) clone[key] = source[key];
+  Object.setPrototypeOf(clone, Object.prototype);
+  clone[$OWNER] = t;
+  return clone;
+}
 /** 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
@@ -5109,22 +5212,68 @@ function scanAccessorsOnce(target) {
  * 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(t, pb) {
+  if (t.kc > OVERLAY_REBUILD_MAX_KEYS) return false;
+  if (t.del !== null && t.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 wk = t.wk;
+  if (wk !== null && wk !== WK_ALL && wk.size <= OVERLAY_REBUILD_MIN_ADDS) return false;
+  const v = t.v;
+  let adds = 0;
+  for (const key of Reflect.ownKeys(pb))
+    if (!hasOwn.call(v, key) && ++adds > 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. */
+ * 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(target) {
-  if (!target.ovl) return;
-  const proto = target.pb;
-  const clone = cloneRaw(target.v, target);
-  for (const key of Reflect.ownKeys(proto)) copyOwn(clone, proto, key);
+  const pb = target.pb;
+  if (!target.ovl) return pb;
+  const clone = target.sc === 2 ? wideClone(target.v, target) : cloneRaw(target.v, target);
+  // 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 (target.del !== null) {
     for (const key of target.del) delete clone[key];
+    target.kc -= target.del.size;
     target.del = null;
   }
+  // Plain-data grade (sc 2): bare assignment, as flattenOverlay does.
+  for (const key of Reflect.ownKeys(pb))
+    target.sc === 2 ? (clone[key] = pb[key]) : copyOwn(clone, pb, key);
   target.pb = clone;
   target.ovl = false;
+  return clone;
 }
 function ensurePB(target) {
   let pb = target.pb;
@@ -5276,6 +5425,7 @@ function adoptPB(target, incoming, eager = false) {
     if (heldMaskView(target) === null) target.hv = target.v;
     target.ht = activeTransition ?? PLAIN_HOLD;
     if (!eager && activeTransition !== null) heldAdoptions.add(target);
+    heldKeys.set(target, [incoming]);
   }
   target.pb = null;
   // Overlay and accessor-scan state describe the OUTGOING backing — a
@@ -5405,6 +5555,7 @@ function flattenOverlay(t, pb) {
   for (const key of Reflect.ownKeys(pb)) t.sc === 2 ? (v[key] = pb[key]) : copyOwn(v, pb, key);
   if (t.del !== null) {
     for (const key of t.del) delete v[key];
+    t.kc -= t.del.size;
     t.del = null;
   }
   t.pb = null;
@@ -5465,11 +5616,13 @@ function drainFolds() {
         foldOlds.set(t, old); // re-queue: commit happens when the hold settles
         continue;
       }
-      if (t.ovl) {
+      if (t.ovl && (t.v !== old || !overlayRebuilds(t, pb))) {
         // 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, pb);
       } else if (t.v !== old) {
         // Privatized mid-batch (#3271): an earlier fold in this drain
@@ -5512,7 +5665,10 @@ function drainFolds() {
         t.pb = null;
         t.wk = null; // written-keys window closes with the fold commit
       } else {
-        t.v = pb;
+        // 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) : pb;
         t.ch = false; // pb is always a plain clone
         t.pb = null;
         t.wk = null; // written-keys window closes with the fold commit
@@ -5778,8 +5934,12 @@ function notifyWrites(t) {
     if (t.ht !== null) t.ht = t.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 (t.ovl) return flattenOverlay(t, pb);
+    // 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 (t.ovl) {
+      if (!overlayRebuilds(t, pb)) return flattenOverlay(t, pb);
+      pb = materializePB(t);
+    }
     const oldBacking = t.v;
     t.pb = null;
     t.v = pb;
@@ -6037,7 +6197,10 @@ function foldHeld(target) {
   }
   return false;
 }
-function readSource(target) {
+/** 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(target, key) {
   // 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,
@@ -6046,7 +6209,9 @@ function readSource(target) {
   const ht = target.ht;
   if (ht !== null && !latestReadActive && !inDraft(target) && !getWriteOverride()) {
     const hv = heldMaskView(target);
-    if (hv !== null) {
+    // A key the adoption left unchanged derives nothing from the hold, for
+    // any reader (#3706): the backing serves it.
+    if (hv !== null && (key === undefined || heldKey(target, key))) {
       const c = readerContext();
       if (
         c === null ||
@@ -6056,7 +6221,7 @@ function readSource(target) {
         return hv;
     }
   }
-  return pendingBackingVisible(target, false) ? target.pb : target.v;
+  return pendingBackingVisible(target, false, key) ? target.pb : target.v;
 }
 /** The single pb-vs-committed visibility decision (#3147), shared by per-key
  * backing reads (readSource) and deep()/snapshot composition (snapshotWalk)
@@ -6073,7 +6238,7 @@ function readSource(target) {
  * 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(target, speculative) {
+function pendingBackingVisible(target, speculative, key) {
   if (target.pb === null) return false;
   // The writer's own channels compose on the pending backing regardless.
   if (inDraft(target) || getWriteOverride()) return true;
@@ -6097,7 +6262,26 @@ function pendingBackingVisible(target, speculative) {
     if (speculative) return txn === null || ownsHold(txn);
     return target.fam !== null && c === null && !foldHeld(target) && txn === null;
   }
-  return holdVisible(liveFoldTransition(target), c);
+  const txn = liveFoldTransition(target);
+  // 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 (txn !== null && key !== undefined && !target.ch && target.fam?.opt !== true) {
+    const wk = target.wk;
+    if (wk != null && wk !== WK_ALL && !wk.has(key)) return false;
+  }
+  return holdVisible(txn, c);
 }
 /** #3164 fold: HELD truth on an optimistic family — a pending backing
  * stamped by a live transition that retains optimism — is masked from LANE
@@ -6411,7 +6595,7 @@ const traps = {
     // memo parity for latest() reads through a projection.
     if (target.fam !== null && latestReadActive && !inDraft(target) && !getWriteOverride())
       pullProjectionForLatest(target);
-    const src = readSource(target);
+    const src = readSource(target, key);
     // 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 (target.del !== null && src === target.pb && target.del.has(key)) {
@@ -6587,7 +6771,7 @@ const traps = {
     if (key === $OWNER || key === $RECORD) return false;
     if (pendingCheckActive) witnessAffectsMark(target, key);
     if (target.fam !== null && getObserver() === null && !inDraft(target)) firewallGate(target);
-    const src = readSource(target);
+    const src = readSource(target, key);
     let present = key in src;
     // Overlay deletes read as absent in the pending view (#3044).
     if (present && target.del !== null && src === target.pb && target.del.has(key)) present = false;
@@ -6644,7 +6828,7 @@ const traps = {
     if (pendingCheckActive) witnessAffectsMark(target, key);
     const obs = getObserver();
     if (target.fam !== null && obs === null && !inDraft(target)) firewallGate(target);
-    const src = readSource(target);
+    const src = readSource(target, key);
     const desc = visibleDescriptor(target, src, key);
     if (!inDraft(target) && obs !== null && !observerHoldsKeySet(target, obs)) {
       // The node is born from the source's presence (as `has` births it),
@@ -6690,10 +6874,12 @@ const traps = {
       }
     } else {
       if (target.wk !== WK_ALL) (target.wk ??= new Set()).add(key);
-      // 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 (!(key in pb)) target.kc++;
     }
     // Own data keys literally named "prototype"/"constructor" land as data —
@@ -8960,6 +9146,30 @@ function updateKeyedMap() {
         // entered rows, for the list-identity census.
         removedItems,
         createdItems;
+      // The pass's write to a per-slot signal (a row accessor in index mode,
+      // an index accessor in keyed mode). The list's frame lives in these
+      // writes as much as in the computed's result, so under a LANE pass they
+      // are the lane's frame too (F1): a plain `setSignal` staged them into
+      // the action's transaction and the row readers were served the
+      // committed value until the action landed — `<For>` without `keyed`
+      // showed the pre-action list for the whole action while the keyed modes
+      // showed the optimistic one. The engine publishes the write as a
+      // derived override on the slot (lanes stage, A17) and lands or
+      // supersedes it when a plain pass later writes a slot still carrying
+      // one (A18) — `landOnOverride`'s slot arm. Decided once per pass, not
+      // per slot: a lane pass marks the map (`_laneSlots`: its slots may
+      // carry overrides), a marked map routes every slot write through the
+      // engine while any lane is live — a slot's override resolves with its
+      // lane's transaction, or with the batch for an orphan lane
+      // (resolveOptimisticNodes, then cleanupCompletedLanes, both before the
+      // completion wakes any recompute), so a pass that finds no lane live
+      // knows the slots are clean and drops the mark — and an unmarked map
+      // takes `setSignal` directly. The engine is installed whenever a lane
+      // is active.
+      const write = (this._laneSlots =
+        currentOptimisticLane !== null || (this._laneSlots && activeLanes.size !== 0))
+        ? GlobalQueue._landOnOverride
+        : setSignal;
       // skip common prefix
       for (
         start = 0, end = Math.min(this._len, newLen);
@@ -8968,7 +9178,7 @@ function updateKeyedMap() {
           (this._rows && compare(this._key, this._items[start], newItems[start])));
         start++
       ) {
-        if (this._rows) setSignal(this._rows[start], newItems[start]);
+        if (this._rows) write(this._rows[start], newItems[start]);
       }
       // skip common suffix — counted only; retained entries land in one pass
       // at commit instead of being staged and copied twice
@@ -9069,19 +9279,19 @@ function updateKeyedMap() {
         indexes && (indexes[i] = this._indexes[i]);
       }
       for (j = start; j <= newEnd; j++) {
-        if (rows) setSignal(rows[j], newItems[j]);
-        if (indexes) setSignal(indexes[j], j);
+        if (rows) write(rows[j], newItems[j]);
+        if (indexes) write(indexes[j], j);
       }
       for (j = newEnd + 1; j < newLen; j++) {
         temp[j] = this._mappings[j - dif];
         tempNodes[j] = this._nodes[j - dif];
         if (rows) {
           rows[j] = this._rows[j - dif];
-          setSignal(rows[j], newItems[j]);
+          write(rows[j], newItems[j]);
         }
         if (indexes) {
           indexes[j] = this._indexes[j - dif];
-          if (dif !== 0) setSignal(indexes[j], j);
+          if (dif !== 0) write(indexes[j], j);
         }
       }
       this._mappings = temp;

package/dist/observe/core/attribution.js

@@ -7,12 +7,13 @@ import { OBSERVE, liveRootOwners, emitDiagnostic, ownerPath, reportDiagnostic, i
 /** A fallback shown for less than this is a flash: feedback for a wait too short to need it. */ const FALLBACK_FLASH_MS = 150;
 
 /**
- * Under an owner the observer marked as its own (`OBSERVE.exclude`), or
- * framework plumbing itself (`CONFIG_PLUMBING` — the HMR memo between a
- * component's root and its body, which is nobody's node): the engine records
- * nothing about the node. Plumbing is a bit read and excludes the node alone,
- * not what it owns; the observer exclusion is cached per node once any
- * exists, before that a flag read.
+ * Under an owner the observer marked as its own (`OBSERVE.exclude`, and not
+ * re-admitted by a nearer `OBSERVE.include`), or framework plumbing itself
+ * (`CONFIG_PLUMBING` — the HMR memo between a component's root and its
+ * body, which is nobody's node): the engine records nothing about the node.
+ * Plumbing is a bit read and excludes the node alone, not what it owns; the
+ * observer exclusion is cached per node once any exists, before that a flag
+ * read.
  */ function excludedNode(e) {
     if ((e.C & CONFIG_PLUMBING) !== 0) return true;
     if (!anyExcluded()) return false;
@@ -373,15 +374,22 @@ function popFrame(e) {
             return;
         }
     }
-    const n = {
+    // The initial navigation is the document's: its request is the time origin
+    // unless the router says otherwise, and it left nowhere.
+        const n = e.initial === true;
+    const t = {
         kind: e.kind,
-        at: e.at ?? now()
+        at: e.at ?? (n ? 0 : now())
     };
-    if (e.from !== undefined) n.from = e.from;
-    const t = enclosingInteraction();
-    if (t !== undefined) n.interaction = t;
-    originFrames.push(n);
-    openNavigation(n, e);
+    if (!n && e.from !== undefined) t.from = e.from;
+    // Declared beats ambient: a router that awaited before writing hands back
+    // the origin it captured in the request (`undefined` when the request ran
+    // under none — still a declaration); what is on the stack now is whatever
+    // happened to be running.
+        const o = "interaction" in e ? interactionOf(e.interaction) : enclosingInteraction();
+    if (o !== undefined) t.interaction = o;
+    originFrames.push(t);
+    openNavigation(t, e);
 }
 
 function originEnd() {
@@ -415,7 +423,8 @@ function originEnd() {
             if (e.to !== undefined && e.to !== n) t.push(e.to);
             const o = navStates.get(e)?.event.redirects;
             if (o !== undefined) t.push(`redirected from ${o.map(e => e.to ?? e.name ?? "?").join(" → ")}`);
-            return `navigation to ${n}${t.length > 0 ? ` (${t.join(", ")})` : ""}`;
+            const i = navStates.get(e)?.event.initial === true;
+            return `${i ? "initial " : ""}navigation to ${n}${t.length > 0 ? ` (${t.join(", ")})` : ""}`;
         }
 
       default:
@@ -1778,8 +1787,10 @@ function checkLongHold(e, n) {
     // derived override promotes rather than reverts. Same predicate the hold
     // census uses to skip them.
     if (!options.optimisticReverts || isCompanion(e)) return;
-    const i = e.Fe;
-    if (i && i(n, t)) return;
+    // Method call, as every commit path does: store slot nodes share one
+    // comparator that reads `this._host` (#3687).
+        const i = e.Fe;
+    if (i && i.call(e, n, t)) return;
     const s = nodeName(e);
     // The two values are user data: quoted only under `values: "full"`; the
     // other levels say what happened without saying what was shown.
@@ -1841,17 +1852,17 @@ function checkLongHold(e, n) {
     for (const t of e) {
         n.owners++;
         // Iterative: a deep tree must not grow the call stack.
-                let e = t._n;
+                let e = t.On;
         for (;;) {
             while (e !== null) {
                 n.owners++;
                 if (typeof e.Se === "function") meet(e);
-                if (e._n !== null) i.push(e);
-                e = e.Fn;
+                if (e.On !== null) i.push(e);
+                e = e._n;
             }
             const t = i.pop();
             if (t === undefined) break;
-            e = t._n;
+            e = t.On;
         }
     }
     for (let e = 0; e < o.length; e++) {
@@ -2070,6 +2081,7 @@ function openNavigation(e, n) {
         writes: 0,
         origin: e
     };
+    if (n.initial === true) t.initial = true;
     if (e.from !== undefined) t.from = e.from;
     if (e.interaction !== undefined) t.interaction = e.interaction;
     const o = {
@@ -2295,7 +2307,10 @@ function settleNavigation(e, n, t) {
     o.settledMs = now() - o.at;
     o.outcome = n;
     if (t !== undefined) o.hold = t;
-    for (const e of folds) e.navigation?.(o);
+    // The initial declaration is not a navigation the person waited on: its
+    // `settledMs` is document start → router built, which would read as the
+    // route's responsiveness in the feedback tables. Consumers get the record.
+        if (o.initial !== true) for (const e of folds) e.navigation?.(o);
     records.emit("navigation", o, undefined);
     trackGraph(o);
     // The interaction that performed it may have been waiting only on this.

package/dist/observe/core/constants.js

@@ -180,20 +180,29 @@ const CONFIG_HAS_LANE = 1 << 10;
  * 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`. */ const CONFIG_HELD_CHILDREN = 1 << 20;
+ * 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. */ const CONFIG_HELD_CHILDREN = 1 << 20;
 
 /** 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). */ const CONFIG_LANE_FRAME = 1 << 26;
+ * 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. */ const CONFIG_LANE_FRAME = 1 << 26;
 
 /** In-flight async node whose inputs were PUBLISHED while it was pending: a
  * batch or transaction committed with the node still `STATUS_PENDING` (an