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

package/dist/observe/core/attribution.js

@@ -1,9 +1,11 @@
 import { setAttributionHooks } from "./attribution-hooks.js";
 
-import { NOT_PENDING, CONFIG_PLUMBING, CONFIG_DERIVED_OVERRIDE } from "./constants.js";
+import { NOT_PENDING, CONFIG_PLUMBING, CONFIG_OVERRIDE, CONFIG_GUESS, CONFIG_VERDICT } from "./constants.js";
 
 import { OBSERVE, liveRootOwners, emitDiagnostic, ownerPath, reportDiagnostic, isSuppressed, anyExcluded, isExcluded, GRAPH_SIZE_WARN_AT, noteFanOut } from "./dev.js";
 
+import { blockersOf, GlobalQueue } from "./scheduler.js";
+
 /** A fallback shown for less than this is a flash: feedback for a wait too short to need it. */ const FALLBACK_FLASH_MS = 150;
 
 /**
@@ -15,11 +17,11 @@ import { OBSERVE, liveRootOwners, emitDiagnostic, ownerPath, reportDiagnostic, i
  * 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 ((e.i & CONFIG_PLUMBING) !== 0) return true;
     if (!anyExcluded()) return false;
     const n = e;
-    if (n.$e === undefined) n.$e = isExcluded(e);
-    return n.$e;
+    if (n.he === undefined) n.he = isExcluded(e);
+    return n.he;
 }
 
 let attributionActive = false;
@@ -42,7 +44,7 @@ const defaultOptions = {
         count: 120,
         windowMs: 1e3
     },
-    wideDeps: 30,
+    wideDeps: 200,
     hotTime: {
         budgetMs: 8,
         windowMs: 1e3
@@ -119,7 +121,7 @@ function nodeName(e) {
 }
 
 /** The record vocabulary for a computation's kind: effects carry a `_type`, memos do not. */ function nodeKind(e) {
-    return e.He ? "effect" : "memo";
+    return e.u ? "effect" : "memo";
 }
 
 /**
@@ -224,17 +226,24 @@ const interactionStack = [];
 
 function interactionStart(e) {
     interactionStack.push(currentInteraction);
+    // No `ref.event`: the WeakMap answers undefined.
+        const n = eventInteractions.get(e.event);
+    if (n?.joinable && openInteractions.has(n)) {
+        n.open = true;
+        currentInteraction = n.event.origin;
+        return;
+    }
     // One clock read: the frame opens now; the interaction began at `ref.at`
     // when the runtime dated it (the event's own timestamp), else now too.
-        const n = now();
-    const t = {
+        const t = now();
+    const o = {
         kind: "interaction",
         name: e.type,
-        at: e.at ?? n
+        at: e.at ?? t
     };
-    if (e.target) t.target = targetLabel(e.target);
-    currentInteraction = t;
-    openInteraction(t, n);
+    if (e.target) o.target = targetLabel(e.target);
+    currentInteraction = o;
+    openInteraction(o, t, e.event);
 }
 
 function interactionEnd(e) {
@@ -318,7 +327,7 @@ const effectFrames = new WeakMap;
     const n = effectStack[effectStack.length - 1];
     if (n !== undefined) effectFrames.set(e, {
         node: n,
-        causes: n.Ke
+        causes: n.me
     });
 }
 
@@ -336,7 +345,7 @@ function pushFrame(e, n, t, o) {
     if (s !== undefined) i.interaction = s;
     if (o !== undefined) {
         const e = o;
-        if (e.Ye !== undefined) i.run = e.Ye;
+        if (e.ge !== undefined) i.run = e.ge;
         // The frame → node map is filled by the first write inside the callback
         // (noteEffectOrigin), not here: most callbacks never write.
                 effectStack.push(o);
@@ -433,12 +442,6 @@ function originEnd() {
 }
 
 /** Record a root change (setSignal / refresh / async landing) on the node. */
-/** Live subscriber count, walked on demand — the core keeps no counter. */ function countSubscribers(e) {
-    let n = 0;
-    for (let t = e.u; t !== null; t = t.Pe) n++;
-    return n;
-}
-
 /**
  * HUGE_FAN_OUT from the engine's lower `fanOut` threshold (see dev.ts): a
  * committed root invalidation reaching hundreds of subscribers re-runs all
@@ -447,12 +450,20 @@ function originEnd() {
  * was a post-construction field that forked node shapes). Stops at
  * GRAPH_SIZE_WARN_AT, where the always-on core check takes over, so the two
  * never fire for the same write; the once-per-node dedupe is the core's.
+ * HMR plumbing subscribers (the refresh memo of every mounted instance, on
+ * a component's registration signal) are not counted toward `fanOut`; the
+ * handover is on the full list, which is what the core counts.
  */ function checkFanOut(e, n) {
     const t = options.fanOut;
     if (typeof t !== "number") return;
-    const o = countSubscribers(e);
-    if (o < t || o >= GRAPH_SIZE_WARN_AT) return;
-    noteFanOut(e, o, n);
+    let o = 0;
+    let i = 0;
+    for (let n = e.t; n !== null; n = n.o) {
+        o++;
+        if (!(n.l.i & CONFIG_PLUMBING)) i++;
+    }
+    if (i < t || o >= GRAPH_SIZE_WARN_AT) return;
+    noteFanOut(e, i, n);
 }
 
 function stampWrite(e, n, t = NO_VALUES, o = NO_VALUES) {
@@ -472,8 +483,8 @@ function stampWrite(e, n, t = NO_VALUES, o = NO_VALUES) {
     i.origin = n === "async" ? asyncOrigin(e) : currentOrigin();
     i.at = now();
     i.stack = captureStack();
-    const s = e.ze;
-    e.ze = i;
+    const s = e.we;
+    e.we = i;
     noteNavigationWrite(s, i);
     noteInteractionWrite(i.origin, excludedNode(e));
     if (n === "write") trackEffectWrite(e, i, o);
@@ -484,7 +495,7 @@ function stampWrite(e, n, t = NO_VALUES, o = NO_VALUES) {
 }
 
 /** Record a derived change (memo produced a new value) with its causes. */ function stampDerived(e, n) {
-    e.ze = {
+    e.we = {
         seq: ++changeSeq,
         kind: "derived",
         name: nodeName(e),
@@ -499,19 +510,19 @@ function stampWrite(e, n, t = NO_VALUES, o = NO_VALUES) {
  * run's links. A refresh() stamp on the node itself also counts — that is a
  * self-invalidation, not a dep change.
  */ function collectCauses(e) {
-    const n = e.Xe ?? 0;
+    const n = e.ve ?? 0;
     const t = [];
-    const o = e.ze;
+    const o = e.we;
     if (o !== undefined && o.seq > n && o.kind === "refresh") t.push(o);
-    for (let o = e.Ee; o !== null; o = o.Ie) {
-        const e = o.De.ze;
+    for (let o = e.G; o !== null; o = o._) {
+        const e = o.I.we;
         if (e !== undefined && e.seq > n) t.push(e);
     }
     return t;
 }
 
 /** Advance the node's seen-cursor to the present. Call after every run. */ function markSeen(e) {
-    e.Xe = changeSeq;
+    e.ve = changeSeq;
 }
 
 /**
@@ -523,32 +534,39 @@ function stampWrite(e, n, t = NO_VALUES, o = NO_VALUES) {
  * still owed) and not part of the subscription diff.
  */ function captureDeps(e) {
     const n = [];
-    for (let t = e.Ee; t !== null; t = t.Ie) {
-        n.push(t.De);
-        if (t === e.Je) break;
+    for (let t = e.G; t !== null; t = t._) {
+        n.push(t.I);
+        if (t === e.p) break;
     }
     return n;
 }
 
 /**
  * Wide-scope warning — the coarse-read / helper-leak signature: one scope
- * subscribed to dozens of sources re-runs when ANY of them change. Fired from
+ * subscribed to hundreds of sources re-runs when ANY of them change. Fired from
  * recordRerun for re-runs and directly from recompute for creation runs (a
- * memo can be born too wide). Re-warns only on 50% further growth.
+ * memo can be born too wide). Re-warns only on 50% further growth. Counts
+ * what the scope's author can act on: HMR plumbing sources are not counted,
+ * and a framework scope wide by construction (CONFIG_WIDE) is not judged —
+ * the always-on HUGE_FAN_IN still is.
  */ function checkDepWidth(e) {
     const n = options.wideDeps;
-    if (n === false) return;
+    // Only dev sets CONFIG_WIDE (see constants.ts).
+        if (n === false || false) return;
     let t = 0;
     const o = [];
-    for (let n = e.Ee; n !== null; n = n.Ie) {
-        t++;
-        if (o.length < 12) o.push(nodeName(n.De));
-        if (n === e.Je) break;
+    for (let n = e.G; n !== null; n = n._) {
+        // HMR plumbing is a dev-only hop the scope cannot read past: not a source.
+        if (!(n.I.i & CONFIG_PLUMBING)) {
+            t++;
+            if (o.length < 12) o.push(nodeName(n.I));
+        }
+        if (n === e.p) break;
  // the validated prefix, as captureDeps
         }
     const i = e;
-    if (t < n || t < (i.en ?? 0) * 1.5) return;
-    i.en = t;
+    if (t < n || t < (i.ke ?? 0) * 1.5) return;
+    i.ke = t;
     const s = `[WIDE_SCOPE_DEPS] ${nodeKind(e)} "${nodeName(e)}" is subscribed to ${t} sources — ` + `it re-runs when any of them change. Narrow its reads or split it into smaller memos. ` + `Sources: ${o.join(", ")}${t > o.length ? ", …" : ""}`;
     reportDiagnostic(emitDiagnostic({
         code: "WIDE_SCOPE_DEPS",
@@ -577,14 +595,14 @@ const HOT_FANOUT_FIRST_MILESTONE = 5;
     if (t === false) return;
     const o = e;
     const i = Date.now();
-    if (o.nn === undefined || i - o.nn > t.windowMs) {
-        o.nn = i;
-        o.tn = 0;
-        o.sn = false;
-    }
-    o.tn = (o.tn ?? 0) + 1;
-    if (o.sn || o.tn < t.count) return;
-    o.sn = true;
+    if (o.ye === undefined || i - o.ye > t.windowMs) {
+        o.ye = i;
+        o.$e = 0;
+        o.be = false;
+    }
+    o.$e = (o.$e ?? 0) + 1;
+    if (o.be || o.$e < t.count) return;
+    o.be = true;
     // Root-cause key: the set of originating writes behind this scope's latest
     // re-run. Scopes hot from the SAME roots share one aggregation window.
         const s = new Set;
@@ -601,10 +619,10 @@ const HOT_FANOUT_FIRST_MILESTONE = 5;
         hotCauses.set(r, a);
     }
     a.scopes++;
-    a.runs += o.tn;
+    a.runs += o.$e;
     if (a.scopes === 1) {
         const s = n.map(e => `"${e.name}" (${e.kind})`).join(", ");
-        const r = `[HOT_SCOPE_RERUNS] ${nodeKind(e)} "${nodeName(e)}" re-ran ${o.tn} times ` + `in ${Math.max(1, i - o.nn)}ms — a hot signal is likely leaking into this ` + `scope. Latest cause: ${s || "(untracked pull)"}`;
+        const r = `[HOT_SCOPE_RERUNS] ${nodeKind(e)} "${nodeName(e)}" re-ran ${o.$e} times ` + `in ${Math.max(1, i - o.ye)}ms — a hot signal is likely leaking into this ` + `scope. Latest cause: ${s || "(untracked pull)"}`;
         reportDiagnostic(emitDiagnostic({
             code: "HOT_SCOPE_RERUNS",
             kind: "perf",
@@ -612,7 +630,7 @@ const HOT_FANOUT_FIRST_MILESTONE = 5;
             message: r,
             nodeName: nodeName(e),
             data: {
-                runs: o.tn,
+                runs: o.$e,
                 windowMs: t.windowMs,
                 causes: n.map(e => e.name)
             }
@@ -650,16 +668,16 @@ const HOT_FANOUT_FIRST_MILESTONE = 5;
     if (o === false) return;
     const i = e;
     const s = now();
-    if (i.rn === undefined || s - i.rn > o.windowMs) {
-        i.rn = s;
-        i.an = 0;
-        i.cn = false;
-    }
-    i.an = (i.an ?? 0) + n;
-    if (i.cn || i.an < o.budgetMs) return;
-    i.cn = true;
+    if (i.Fe === undefined || s - i.Fe > o.windowMs) {
+        i.Fe = s;
+        i.Le = 0;
+        i.Ce = false;
+    }
+    i.Le = (i.Le ?? 0) + n;
+    if (i.Ce || i.Le < o.budgetMs) return;
+    i.Ce = true;
     const r = t.map(e => `"${e.name}" (${e.kind})`).join(", ");
-    const a = `[HOT_SCOPE_TIME] ${nodeKind(e)} "${nodeName(e)}" spent ` + `${i.an.toFixed(1)}ms of compute inside one ${o.windowMs}ms window ` + `(budget ${o.budgetMs}ms). Latest cause: ${r || "(untracked pull)"}`;
+    const a = `[HOT_SCOPE_TIME] ${nodeKind(e)} "${nodeName(e)}" spent ` + `${i.Le.toFixed(1)}ms of compute inside one ${o.windowMs}ms window ` + `(budget ${o.budgetMs}ms). Latest cause: ${r || "(untracked pull)"}`;
     reportDiagnostic(emitDiagnostic({
         code: "HOT_SCOPE_TIME",
         kind: "perf",
@@ -667,7 +685,7 @@ const HOT_FANOUT_FIRST_MILESTONE = 5;
         message: a,
         nodeName: nodeName(e),
         data: {
-            spentMs: i.an,
+            spentMs: i.Le,
             budgetMs: o.budgetMs,
             windowMs: o.windowMs,
             causes: t.map(e => e.name)
@@ -682,31 +700,34 @@ const HOT_FANOUT_FIRST_MILESTONE = 5;
  * names it while it happens, with the input that keeps triggering it. The
  * fix is upstream: an equality boundary on the part of the input the scope
  * depends on, or a narrower read. Plain runs only — a held or overlay run
- * may be replayed and is never blamed as waste.
+ * may be replayed and is never blamed as waste. A run that committed
+ * `undefined` arrives here as changed (see `recomputeEnd`): its work is a
+ * side effect (a projection's draft writes, a write from inside a memo), not
+ * its output.
  */ function checkWastedRecompute(e, n, t, o, i, s) {
     const r = options.wastedRecompute;
     if (r === false || t !== "plain") return;
     // This runs on every re-run: fields on the node (one property read each,
     // like hotRuns) and the run's own `at` — no clock read, no map lookup.
         const a = e;
-    if (a.dn === undefined || n - a.dn > r.windowMs) {
-        a.dn = n;
-        a.fn = 0;
-        a.un = 0;
-        a.ln = 0;
-        a.hn = false;
-    }
-    a.fn = a.fn + 1;
+    if (a.Me === undefined || n - a.Me > r.windowMs) {
+        a.Me = n;
+        a.He = 0;
+        a.We = 0;
+        a.Ge = 0;
+        a.Ue = false;
+    }
+    a.He = a.He + 1;
     if (!o) {
-        a.un = a.un + 1;
-        a.ln = a.ln + i;
+        a.We = a.We + 1;
+        a.Ge = a.Ge + i;
     }
-    if (a.hn || a.fn < r.minRuns || a.un / a.fn < r.ratio || a.ln < r.budgetMs) return;
-    a.hn = true;
+    if (a.Ue || a.He < r.minRuns || a.We / a.He < r.ratio || a.Ge < r.budgetMs) return;
+    a.Ue = true;
     const c = {
-        runs: a.fn,
-        wasted: a.un,
-        wastedMs: a.ln
+        runs: a.He,
+        wasted: a.We,
+        wastedMs: a.Ge
     };
     const d = s.map(e => `"${e.name}" (${e.kind})`).join(", ");
     const f = `[WASTED_RECOMPUTE] ${nodeKind(e)} "${nodeName(e)}" re-ran ${c.runs} times in ` + `${r.windowMs}ms and ${c.wasted} of those produced the same value — ` + `${c.wastedMs.toFixed(1)}ms of compute the equality gate then discarded. Its inputs ` + `change without changing its result: put an equality boundary upstream (a memo over the ` + `part of the input it reads, or an \`equals\` on the source), or read a narrower slice ` + `(the property, not the object). Latest cause: ${d || "(untracked pull)"}`;
@@ -729,14 +750,14 @@ const HOT_FANOUT_FIRST_MILESTONE = 5;
 function recordRerun(e, n, t, o, i, s) {
     const r = n.causes;
     const a = e;
-    const c = a.Ke;
+    const c = a.me;
     const d = n.interaction;
     if (excludedNode(e)) {
         // The observer's own computation: keep the per-node bookkeeping its
         // effect phase reads (see effectRunStart) and record nothing.
-        a.pn = d;
-        a.Ye = undefined;
-        a.Ke = r;
+        a.qe = d;
+        a.ge = undefined;
+        a.me = r;
         return;
     }
     // The facts every run leaves on the node, record or not: the run sequence
@@ -745,10 +766,10 @@ function recordRerun(e, n, t, o, i, s) {
     // cause list of its own, so it takes this run's interaction and causes
     // (see effectRunStart / pushFrame).
         const f = ++runSeq;
-    const u = a.mn = (a.mn ?? 0) + 1;
-    a.pn = d;
-    a.Ye = f;
-    a.Ke = r;
+    const u = a.Be = (a.Be ?? 0) + 1;
+    a.qe = d;
+    a.ge = f;
+    a.me = r;
     noteInteractionRun(d, t.selfMs, false);
     if (openFlush !== null) noteFlushRun(openFlush, false, d);
     // The checks read the facts, not the record, so they run with or without
@@ -865,8 +886,10 @@ function shallowEquivalent(e, n) {
         for (let e = 0; e < t.length; e++) if (t[e] !== o[e]) return false;
         return true;
     }
-    const o = Object.keys(e);
-    if (o.length > UNSTABLE_KEY_CAP || o.length !== Object.keys(n).length) return false;
+    // Every own key, symbols included: a symbol-keyed box holding a fresh value
+    // each run (web's `dynamic` boxes its in-flight promise) is not equivalent.
+        const o = Reflect.ownKeys(e);
+    if (o.length > UNSTABLE_KEY_CAP || o.length !== Reflect.ownKeys(n).length) return false;
     for (const t of o) {
         if (!(t in n) || e[t] !== n[t]) return false;
     }
@@ -887,15 +910,15 @@ function shallowEquivalent(e, n) {
     const i = e;
     if (n === t || // paranoia: changed runs should never hit this
     !isPlainShape(n) || !isPlainShape(t) || !shallowEquivalent(n, t)) {
-        i.gn = 0;
-        i.wn = false;
+        i.xe = 0;
+        i.Ke = false;
         return;
     }
-    i.gn = (i.gn ?? 0) + 1;
-    if (i.wn || i.gn < o) return;
-    i.wn = true;
+    i.xe = (i.xe ?? 0) + 1;
+    if (i.Ke || i.xe < o) return;
+    i.Ke = true;
     const s = Array.isArray(t) ? "array" : "object";
-    const r = `[UNSTABLE_MEMO_OUTPUT] memo "${nodeName(e)}" produced a new-but-equivalent ${s} on ` + `${i.gn} consecutive runs — its equality gate never closes, so every ` + `subscriber re-runs on every upstream change. Return stable references or pass an ` + `\`equals\` option.`;
+    const r = `[UNSTABLE_MEMO_OUTPUT] memo "${nodeName(e)}" produced a new-but-equivalent ${s} on ` + `${i.xe} consecutive runs — its equality gate never closes, so every ` + `subscriber re-runs on every upstream change. Return stable references or pass an ` + `\`equals\` option.`;
     reportDiagnostic(emitDiagnostic({
         code: "UNSTABLE_MEMO_OUTPUT",
         kind: "perf",
@@ -903,7 +926,7 @@ function shallowEquivalent(e, n) {
         message: r,
         nodeName: nodeName(e),
         data: {
-            runs: i.gn,
+            runs: i.xe,
             shape: s
         }
     }, e));
@@ -1042,17 +1065,17 @@ const copyReported = new WeakSet;
     const s = i !== undefined && i.kind === "effect" ? effectFrames.get(i) : undefined;
     const r = s === undefined ? 0 : devId(s.node);
     recordNodes.set(n, e);
-    o.vn = o.vn === undefined || o.vn === r ? r : null;
-    if (s !== undefined && t !== undefined && t === s.node.ce) {
+    o.Ve = o.Ve === undefined || o.Ve === r ? r : null;
+    if (s !== undefined && t !== undefined && t === s.node.Ae) {
         copyWrites.add(n);
-        o.kn = o.Sn === r ? (o.kn ?? 0) + 1 : 1;
-        o.Sn = r;
-        if (o.kn >= 2 && o.vn === r) checkCopyEffect(s.node, e);
-    } else o.kn = 0;
+        o.je = o.Ye === r ? (o.je ?? 0) + 1 : 1;
+        o.Ye = r;
+        if (o.je >= 2 && o.Ve === r) checkCopyEffect(s.node, e);
+    } else o.je = 0;
 }
 
 /** The effect's source whose current value the compute output is, if any (the prop-to-state port). */ function passthroughSource(e) {
-    for (let n = e.Ee; n !== null; n = n.Ie) if (n.De.ce === e.ce) return nodeName(n.De);
+    for (let n = e.G; n !== null; n = n._) if (n.I.Ae === e.Ae) return nodeName(n.I);
     return undefined;
 }
 
@@ -1125,7 +1148,7 @@ function checkCopyEffect(e, n) {
     c.count++;
     const d = copyWrites.has(s);
     const f = recordNodes.get(s);
-    const u = f !== undefined && f.vn === devId(i.node);
+    const u = f !== undefined && f.Ve === devId(i.node);
     // Derivable outright: the value is the compute output and nothing else
     // writes the signal. A copy INTO a signal that has other writers is the
     // "reset editable state from a source" shape — the tear is real, but a memo
@@ -1141,7 +1164,7 @@ function checkCopyEffect(e, n) {
         copyReported.add(f);
     }
     if (h === "warn") c.warned = true;
-    const p = e.He ? "effect" : "memo";
+    const p = e.u ? "effect" : "memo";
     const m = nodeName(i.node);
     const g = l ? copyRepair(i.node, s.name) : d ? `The written value is the effect's compute output, but "${s.name}" has other ` + `writers — editable state reset from a source. If the reset is the intent, the tear ` + `is its cost; if "${s.name}" only ever mirrors the source, drop the local copy ` + `and read the source.` : u ? `Nothing else writes "${s.name}" — it is derived state: make it a memo over what ` + `the effect reads and every reader gets it in the same flush.` : `If "${s.name}" is computed from what the effect reads, make it a memo so readers ` + `get it in the same flush; if the write reads something outside the graph (layout, ` + `time), the tear is the cost of measuring.`;
     const w = `[EFFECT_RELAY_TEAR] ${p} "${nodeName(e)}" ran twice for one write of ` + `"${r.name}": once in the flush where "${r.name}" changed, and again after ` + `effect "${m}" relayed it by writing "${s.name}" — the first frame showed the ` + `new "${r.name}" with the stale "${s.name}"` + (c.count > 1 ? ` (${c.count} times so far)` : "") + `. ${g}`;
@@ -1232,7 +1255,7 @@ const listIdentityWarned = new WeakSet;
 function recordId(e) {
     if (e === null || typeof e !== "object") return undefined;
     const n = e;
-    return n.id ?? n.key ?? n.yn ?? undefined;
+    return n.id ?? n.key ?? n.ze ?? undefined;
 }
 
 function checkListIdentity(e, n, t, o, i) {
@@ -1389,7 +1412,7 @@ function trackFlightStart(e, n) {
     const o = t - n.origin;
     for (const n of folds) n.flightLanded?.(e, o);
     if (records.observed("flight")) emitFlight(e, n, t, "landed");
-    const i = e.ze;
+    const i = e.we;
     // Only a stamp this landing produced may carry the measurement — a stale
     // async record from a previous landing must not be re-labeled.
         if (i !== undefined && i.kind === "async" && i.seq > n.startSeq) landedFlights.set(i, {
@@ -1425,8 +1448,8 @@ function checkWaterfall(e, n, t) {
     }
     if (i < 2) return;
     const r = e;
-    if ((r.Nn ?? 0) >= i) return;
-    r.Nn = i;
+    if ((r.Xe ?? 0) >= i) return;
+    r.Xe = i;
     const a = [ ...n.slice(n.length - (i - 1)), {
         name: nodeName(e),
         ms: t
@@ -1460,10 +1483,10 @@ let activeHold = null;
 
 let holdLog = [];
 
-/** Companions are optimistic nodes too; `_parentSource` marks them. So is a
- * memo carrying a DERIVED override (lanes stage, #3479) — a lane pass's
- * result, not a write anyone made: neither is an acknowledgement. */ function isCompanion(e) {
-    return !!e.o && e.o.$n !== undefined || (e.C & CONFIG_DERIVED_OVERRIDE) !== 0;
+/** A lane's derivation (L2: a node carrying the lane's value that is not a
+ * written guess — lanes.ts) is a lane pass's result, not a write anyone
+ * made: not an acknowledgement. */ function isCompanion(e) {
+    return (e.i & (CONFIG_OVERRIDE | CONFIG_GUESS)) === CONFIG_OVERRIDE;
 }
 
 const HOLD_CENSUS_CAP = 1e4;
@@ -1484,13 +1507,14 @@ function acknowledge(e, n, t, o) {
     }); else if (r !== undefined) s.reader ??= r;
 }
 
-function censusRegistrations(e, n) {
+/** The declarations made against the hold: the guesses of its lanes
+ * (lanes.ts `_laneGuesses`) and its `affects()` marks (`_marks`). */ function censusRegistrations(e, n) {
     const t = {
         left: HOLD_CENSUS_CAP
     };
-    for (const o of e.bn) if (!isCompanion(o)) acknowledge(n, "optimistic", nodeName(o), reachesEffect(o, t));
-    for (const t of e.En) acknowledge(n, "optimistic", t?._name ?? "store", null);
-    for (const o of e.A) acknowledge(n, "affects", nodeName(o), reachesEffect(o, t));
+    const o = GlobalQueue.Qe?.(e);
+    if (o !== undefined) for (const e of o) acknowledge(n, "optimistic", nodeName(e), reachesEffect(e, t));
+    if (e.T !== null) for (const o of e.T) acknowledge(n, "affects", nodeName(o), reachesEffect(o, t));
 }
 
 /**
@@ -1504,9 +1528,9 @@ function censusRegistrations(e, n) {
     const o = [ e ];
     while (o.length > 0 && n.left-- > 0) {
         const e = o.pop();
-        for (let n = e.u; n !== null; n = n.Pe) {
-            const e = n.Ae;
-            if (e.He) return e;
+        for (let n = e.t; n !== null; n = n.o) {
+            const e = n.l;
+            if (e.u) return e;
             if (!t.has(e)) {
                 t.add(e);
                 o.push(e);
@@ -1516,7 +1540,10 @@ function censusRegistrations(e, n) {
     return null;
 }
 
-/** Companions an effect reads, anywhere downstream of the hold's nodes. */ function censusCompanions(e, n) {
+/** Verdict readers an effect reads, anywhere downstream of the hold's nodes
+ * (L2: a pass that entered an `isPending`/`latest` window is marked
+ * CONFIG_VERDICT; the observe tier notes which windows — verdict.ts
+ * `_devWindows`). The reader acknowledges the node it derives from. */ function censusCompanions(e, n) {
     const t = new Set;
     const o = [ ...e ];
     const i = {
@@ -1526,14 +1553,16 @@ function censusRegistrations(e, n) {
         const e = o.pop();
         if (t.has(e)) continue;
         t.add(e);
-        const s = e.o;
-        if (s) {
-            let t;
-            if (s.xe !== undefined && (t = reachesEffect(s.xe, i))) acknowledge(n, "isPending", nodeName(e), t);
-            if (s.Me !== undefined && (t = reachesEffect(s.Me, i))) acknowledge(n, "latest", nodeName(e), t);
-            for (let e = s.i ?? null; e !== null; e = e.ge ?? null) o.push(e);
+        for (let t = e.t; t !== null; t = t.o) {
+            const s = t.l;
+            if (s.i & CONFIG_VERDICT) {
+                const t = s.Ze ?? 0;
+                const o = s.u ? s : reachesEffect(s, i);
+                if (t & 1 && o !== null) acknowledge(n, "isPending", nodeName(e), o);
+                if (t & 2 && o !== null) acknowledge(n, "latest", nodeName(e), o);
+            }
+            o.push(s);
         }
-        for (let n = e.u; n !== null; n = n.Pe) o.push(n.Ae);
     }
 }
 
@@ -1561,8 +1590,8 @@ function trackHoldStart(e) {
     if (options.holds === false) return;
     const n = holdState(e);
     n.flushes++;
-    if (e.tt.length > 0) n.action = true;
-    for (const [t, o] of e.ae) if (o.size > 0) n.blockers.add(t);
+    if (e.tt > 0) n.action = true;
+    for (const t of blockersOf(e)) n.blockers.add(t);
     censusRegistrations(e, n);
     activeHold = n;
 }
@@ -1599,9 +1628,9 @@ function trackHoldSettled(e) {
     let i;
     let s;
     let r = -Infinity;
-    for (const n of e.In) {
-        if (typeof n.Se === "function" || isCompanion(n)) continue;
-        const e = n.ze;
+    for (const n of e.Je) {
+        if (typeof n.ee === "function" || isCompanion(n)) continue;
+        const e = n.we;
         if (e === undefined || e.kind !== "write") continue;
         if (o === null) o = n;
         const a = {
@@ -1628,7 +1657,7 @@ function trackHoldSettled(e) {
         return;
     }
     censusRegistrations(e, n);
-    censusCompanions([ ...e.In, ...n.blockers ], n);
+    censusCompanions([ ...e.Je, ...n.blockers ], n);
     const a = now();
     // The hold began no later than its first parked flush; an interaction stamp
     // reaches further back (dispatch). A node rewritten mid-hold keeps only its
@@ -1789,7 +1818,7 @@ function checkLongHold(e, n) {
     if (!options.optimisticReverts || isCompanion(e)) return;
     // Method call, as every commit path does: store slot nodes share one
     // comparator that reads `this._host` (#3687).
-        const i = e.Fe;
+        const i = e.en;
     if (i && i.call(e, n, t)) return;
     const s = nodeName(e);
     // The two values are user data: quoted only under `values: "full"`; the
@@ -1816,7 +1845,16 @@ function checkLongHold(e, n) {
 }
 
 // --- Graph growth -----------------------------------------------------------------
-/** Per route: the graph's size at its last `visits` settles, oldest first. */ const routeCounts = new Map;
+/**
+ * Per route: at its last `visits` compared settles, oldest first, the
+ * graph's size and the part of it that was already alive when that
+ * navigation opened.
+ */ const routeCounts = new Map;
+
+/**
+ * The route the app last arrived on: a navigation that stays on it (only
+ * its params or query change) continues the visit and is not compared.
+ */ let visitRoute;
 
 /**
  * The live graph's size — a walk, not a counter: nothing is charged at node
@@ -1831,51 +1869,78 @@ function checkLongHold(e, n) {
  * millisecond. Dormant nodes are spliced out of their chain and are not
  * counted unless a subscription still reaches them.
  */ function graphSize() {
-    const e = liveRootOwners();
-    const n = {
-        roots: e.length,
+    return walkGraph();
+}
+
+/**
+ * The walk behind `graphSize()`. Given `before` alone, it adds every node it
+ * meets to that set: what is alive as a navigation opens. Given `before` and
+ * `survived`, it also counts into `survived` the nodes it meets that are in
+ * the set, and an edge when both its ends are: what outlived the navigation.
+ * Nothing is retained — the set is weak.
+ */ function walkGraph(e, n) {
+    const t = liveRootOwners();
+    const o = {
+        roots: 0,
         owners: 0,
         computations: 0,
         signals: 0,
         edges: 0
     };
-    const t = new Set;
+    const i = new Set;
     // A worklist, not recursion: a subscriber chain can be thousands deep.
-        const o = [];
-    const i = [];
+        const s = [];
+    const r = [];
+    const count = (t, i) => {
+        o[i]++;
+        if (n !== undefined) {
+            if (e.has(t)) n[i]++;
+        } else if (e !== undefined) e.add(t);
+    };
     const meet = e => {
-        if (t.has(e)) return;
-        t.add(e);
-        if (typeof e.Se === "function") n.computations++; else n.signals++;
-        o.push(e);
+        if (i.has(e)) return;
+        i.add(e);
+        count(e, typeof e.ee === "function" ? "computations" : "signals");
+        s.push(e);
     };
-    for (const t of e) {
-        n.owners++;
+    for (const e of t) {
+        count(e, "roots");
+        count(e, "owners");
         // Iterative: a deep tree must not grow the call stack.
-                let e = t.On;
+                let n = e.nn;
         for (;;) {
-            while (e !== null) {
-                n.owners++;
-                if (typeof e.Se === "function") meet(e);
-                if (e.On !== null) i.push(e);
-                e = e._n;
+            while (n !== null) {
+                count(n, "owners");
+                if (typeof n.ee === "function") meet(n);
+                if (n.nn !== null) r.push(n);
+                n = n.tn;
             }
-            const t = i.pop();
-            if (t === undefined) break;
-            e = t.On;
+            const e = r.pop();
+            if (e === undefined) break;
+            n = e.nn;
         }
     }
-    for (let e = 0; e < o.length; e++) {
-        const t = o[e];
+    for (let t = 0; t < s.length; t++) {
+        const i = s[t];
         // Whoever reads this node: owned computations are already known; an
         // ownerless one is met only here.
-                for (let e = t.u; e !== null; e = e.Pe) meet(e.Ae);
-        if (typeof t.Se === "function") for (let e = t.Ee; e !== null; e = e.Ie) {
-            n.edges++;
-            meet(e.De);
+                for (let e = i.t; e !== null; e = e.o) meet(e.l);
+        if (typeof i.ee === "function") for (let t = i.G; t !== null; t = t._) {
+            o.edges++;
+            meet(t.I);
+            if (n !== undefined && e.has(i) && e.has(t.I)) n.edges++;
         }
     }
-    return n;
+    return o;
+}
+
+/**
+ * openNavigation, while the growth check is on: what is alive as a
+ * navigation opens, for its settle to tell apart from what it created.
+ */ function snapshotGraph() {
+    const e = new WeakSet;
+    walkGraph(e);
+    return e;
 }
 
 /**
@@ -1886,60 +1951,96 @@ function checkLongHold(e, n) {
  * `createRoot` in an effect with no dispose, a subscription a component
  * registered outside its owner. Nothing here runs per node; the walk is
  * the cost, at navigation cadence.
+ *
+ * A count taken at an arrival also holds everything the visit just created,
+ * so a page whose correctly owned content is bigger each visit climbs too.
+ * What tells the two apart is what outlived the navigation: the nodes alive
+ * when it opened (`NavState.before`) that are still alive at its settle. A
+ * visit's own content is not among them; what an earlier visit left behind
+ * is, whatever the content does. A series reports only when both climb.
  */ const GRAPH_SERIES = [ "owners", "computations", "signals", "edges" ];
 
 function trackGraph(e) {
-    const n = options.graphGrowth;
-    if (n === false && !records.observed("graph")) return;
-    const t = graphSize();
-    const o = e.name ?? e.to;
-    const i = {
+    const n = e.event;
+    const t = e.before;
+    e.before = undefined;
+    const o = options.graphGrowth;
+    if (o === false && !records.observed("graph")) return;
+    const i = t && {
+        roots: 0,
+        owners: 0,
+        computations: 0,
+        signals: 0,
+        edges: 0
+    };
+    const s = walkGraph(t, i);
+    const r = n.name ?? n.to;
+    const a = {
         at: now(),
-        ...t,
-        navigation: e
+        ...s,
+        navigation: n
     };
-    if (o !== undefined) i.route = o;
-    records.emit("graph", i, undefined);
-    if (n === false || o === undefined) return;
-    let s = routeCounts.get(o);
-    if (s === undefined) routeCounts.set(o, s = []);
-    s.push(t);
-    if (s.length > n.visits) s.shift();
-    if (s.length < n.visits) return;
-    // Any series climbing on every visit to the ratio is growth; which ones
-    // did says what leaked — computations with owners flat is an ownerless
-    // effect per visit, edges alone is a subscription per visit to something
-    // long-lived, owners is an undisposed root.
-        const r = GRAPH_SERIES.filter(e => {
-        for (let n = 1; n < s.length; n++) if (s[n][e] <= s[n - 1][e]) return false;
-        return s[s.length - 1][e] >= s[0][e] * n.ratio;
+    if (r !== undefined) a.route = r;
+    records.emit("graph", a, undefined);
+    if (o === false || r === undefined) return;
+    // A navigation that stays on the route pattern continues the visit: the
+    // page it kept outlived the move by design, so comparing it would read the
+    // page itself as growth. Only arrivals that enter the route are compared —
+    // a leak made during a visit is still alive when the next one starts. A
+    // superseded navigation never showed, so the app is still where it was.
+        const c = visitRoute;
+    if (n.outcome !== "superseded") visitRoute = r;
+    // The initial declaration is not a visit (it settles before route content
+    // mounts — the same gate the feedback folds apply as `event.initial !== true`);
+    // `initial` is `true | undefined`, set only by openNavigation, so truthiness is exact.
+    // A navigation opened before the check was on has no snapshot to compare.
+        if (n.initial || r === c || i === undefined) return;
+    let d = routeCounts.get(r);
+    if (d === undefined) routeCounts.set(r, d = []);
+    d.push({
+        size: s,
+        survived: i
     });
-    if (r.length === 0) return;
+    if (d.length > o.visits) d.shift();
+    if (d.length < o.visits) return;
+    const f = d.map(e => e.size);
+    const u = d.map(e => e.survived);
+    const climbs = (e, n) => {
+        for (let t = 1; t < e.length; t++) if (e[t][n] <= e[t - 1][n]) return false;
+        return e[e.length - 1][n] >= e[0][n] * o.ratio;
+    };
+    // Any series climbing on every visit to the ratio — in the totals and in
+    // what outlived each navigation — is growth; which ones did says what
+    // leaked — computations with owners flat is an ownerless effect per visit,
+    // edges alone is a subscription per visit to something long-lived, owners
+    // is an undisposed root.
+        const l = GRAPH_SERIES.filter(e => climbs(f, e) && climbs(u, e));
+    if (l.length === 0) return;
     // The count is the whole graph's, so a leak shows at every route's settle;
     // the first route to complete its climb reports, naming the others seen.
-        const a = [ ...routeCounts.keys() ];
-    const c = r.map(e => `${e} ${s.map(n => n[e]).join(" → ")}`).join("; ");
-    const d = r.includes("owners") ? "a createRoot() in an effect or handler with no dispose, or a Portal or panel mounted per visit" : r.includes("computations") ? "an effect or memo created with no owner (a module-level or callback createEffect) that only its sources keep alive" : "a subscription per visit to something long-lived — a global store or signal read by a computation that outlives the visit";
-    const f = `[GRAPH_GROWTH] the live graph grew on ${n.visits} consecutive visits to ${o}: ${c} ` + `(${t.roots} roots)${a.length > 1 ? `, across visits to ${a.join(", ")}` : ""}. Each ` + `visit left something behind that the next did not reclaim — the shape says ${d}. Dispose ` + `what a visit creates (onCleanup, or return the disposer from onSettled) and own it under the ` + `route's component so leaving the route tears it down.`;
-    const u = {
-        route: o,
-        grew: r,
-        history: s.map(e => ({
-            ...e
-        })),
-        roots: t.roots,
-        routes: a
+        const h = [ ...routeCounts.keys() ];
+    const join = (e, n) => e.map(e => e[n]).join(" → ");
+    const p = l.map(e => `${e} ${join(u, e)} (of ${join(f, e)})`).join("; ");
+    const m = l.includes("owners") ? "a createRoot() in an effect or handler with no dispose, or a Portal or panel mounted per visit" : l.includes("computations") ? "an effect or memo created with no owner (a module-level or callback createEffect) that only its sources keep alive" : "a subscription per visit to something long-lived — a global store or signal read by a computation that outlives the visit";
+    const g = `[GRAPH_GROWTH] the live graph grew on ${o.visits} consecutive visits to ${r}, and so did ` + `the part that outlived each navigation there: ${p} ` + `(${s.roots} roots)${h.length > 1 ? `, across visits to ${h.join(", ")}` : ""}. Each ` + `visit left something behind that the next did not reclaim — the shape says ${m}. Dispose ` + `what a visit creates (onCleanup, or return the disposer from onSettled) and own it under the ` + `route's component so leaving the route tears it down.`;
+    const w = {
+        route: r,
+        grew: l,
+        history: f,
+        survived: u,
+        roots: s.roots,
+        routes: h
     };
-    if (e.interaction !== undefined) u.interaction = {
-        type: e.interaction.name,
-        target: e.interaction.target
+    if (n.interaction !== undefined) w.interaction = {
+        type: n.interaction.name,
+        target: n.interaction.target
     };
     reportDiagnostic(emitDiagnostic({
         code: "GRAPH_GROWTH",
         kind: "perf",
         severity: "warn",
-        message: f,
-        data: u
+        message: g,
+        data: w
     }, null));
     // Judged once for the graph, not once per route: the next verdict needs
     // another `visits` climbing settles.
@@ -1953,10 +2054,13 @@ function trackGraph(e) {
  * One source abandoning flight after flight inside a window: every input
  * asked again and the earlier answers were thrown away — the
  * request-per-keystroke signature `feedback().flights[].abandoned` counts,
- * as a finding while it happens. Warned once per window per source.
+ * as a finding while it happens. Warned once per window per source. A
+ * framework node superseding its own flights by design (CONFIG_SUPERSEDES)
+ * is not judged; its flights are still recorded.
  */ function checkAbandonedFlights(e, n) {
     const t = options.abandonedFlights;
-    if (t === false || excludedNode(e)) return;
+    // Only dev sets CONFIG_SUPERSEDES (see constants.ts).
+        if (t === false || false || excludedNode(e)) return;
     const o = Date.now();
     let i = abandonWindows.get(e);
     if (i === undefined || o - i.start > t.windowMs) {
@@ -2053,6 +2157,14 @@ let navigationLog = [];
 
 /** Drains completed since enable() — the clock `writeDrain` reads. */ let drainSeq = 0;
 
+/**
+ * Navigations settled in a landing, waiting for their graph count: the hook
+ * fires before the landing's commits dispose the frame parked for the page
+ * left, which the walk would still reach through the sources both pages read
+ * (#3989). `land()` runs only inside `flush()`'s drain, so `flushEnd` counts
+ * them, after those commits — the instant a one-drain navigation is counted.
+ */ const landedGraphs = [];
+
 /**
  * Copy what the router currently says onto the frame (what writes stamped —
  * `formatOrigin` reads it) and the event. Called when the frame opens, when a
@@ -2091,6 +2203,8 @@ function openNavigation(e, n) {
         held: false,
         writeDrain: drainSeq
     };
+    // The initial declaration is never compared (see `trackGraph`).
+        if (options.graphGrowth !== false && n.initial !== true) o.before = snapshotGraph();
     syncNavigation(o);
     navStates.set(e, o);
     openNavs.add(o);
@@ -2151,8 +2265,8 @@ function closeNavigation(e) {
 
 /** holdStart: `t`'s staged writes are parked — their navigations settle with `t`. */ function markNavigationsHeld(e) {
     if (openNavs.size === 0) return;
-    for (const n of e.In) {
-        const e = n.ze?.origin;
+    for (const n of e.Je) {
+        const e = n.we?.origin;
         if (e?.kind !== "navigation") continue;
         const t = navStates.get(e);
         if (t !== undefined) t.held = true;
@@ -2161,14 +2275,14 @@ function closeNavigation(e) {
 
 /** transitionSettled: `t` commits — the navigations whose writes it staged are done. */ function settleNavigations(e, n) {
     if (openNavs.size === 0) return;
-    for (const t of e.In) {
-        const e = t.ze?.origin;
+    for (const t of e.Je) {
+        const e = t.we?.origin;
         if (e?.kind !== "navigation") continue;
         const o = navStates.get(e);
         if (o === undefined || !openNavs.has(o)) continue;
         // A navigation whose frame is still open when its transition commits
         // (`until()` inside the frame) settles here too: its writes are through.
-                settleNavigation(o, o.held ? "held" : "committed", n);
+                settleNavigation(o, o.held ? "held" : "committed", n, true);
     }
 }
 
@@ -2295,37 +2409,42 @@ function trackFallback(e, n, t, o) {
     drainSeq++;
     // The swaps this drain committed have rendered.
         displayFallbacks();
+    // Landed first: they settled before anything this drain settles below.
+        for (let e = 0; e < landedGraphs.length; e++) trackGraph(landedGraphs[e]);
+    landedGraphs.length = 0;
     for (const e of openNavs) if (e.open === 0 && !e.held) settleNavigation(e, "committed");
     for (const e of openInteractions) maybeSettleInteraction(e);
 }
 
-function settleNavigation(e, n, t) {
+function settleNavigation(e, n, t, o) {
     if (!openNavs.has(e)) return;
     openNavs.delete(e);
     syncNavigation(e);
-    const o = e.event;
-    o.settledMs = now() - o.at;
-    o.outcome = n;
-    if (t !== undefined) o.hold = t;
+    const i = e.event;
+    i.settledMs = now() - i.at;
+    i.outcome = n;
+    if (t !== undefined) i.hold = t;
     // 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);
+        if (i.initial !== true) for (const e of folds) e.navigation?.(i);
+    records.emit("navigation", i, undefined);
+    if (o) landedGraphs.push(e); else trackGraph(e);
     // The interaction that performed it may have been waiting only on this.
-        const i = openInteractionOf(o.interaction);
-    if (i !== undefined) maybeSettleInteraction(i);
+        const s = openInteractionOf(i.interaction);
+    if (s !== undefined) maybeSettleInteraction(s);
 }
 
 const interactionStates = new WeakMap;
 
+/** `InteractionRef.event` → the record its frames join (while `joinable`). Weak: the Event is never held. */ const eventInteractions = new WeakMap;
+
 /** Opened, not yet settled. */ const openInteractions = new Set;
 
 let interactionLog = [];
 
-function openInteraction(e, n) {
-    const t = {
+function openInteraction(e, n, t) {
+    const o = {
         name: e.name,
         at: e.at,
         handlerMs: 0,
@@ -2337,26 +2456,37 @@ function openInteraction(e, n) {
         navigations: [],
         origin: e
     };
-    if (e.target !== undefined) t.target = e.target;
+    if (e.target !== undefined) o.target = e.target;
     // The runtime may date the frame from the event's own timestamp (before
     // any queued task ran); the gap to here is the input delay the browser's
     // INP counts first.
-        if (n > t.at) t.inputDelayMs = n - t.at;
-    const o = {
-        event: t,
+        if (n > o.at) o.inputDelayMs = n - o.at;
+    const i = {
+        event: o,
         open: true,
         opened: n,
         writeDrain: drainSeq,
         heldIn: new Set,
         held: false,
         excludedWrites: 0,
-        awaiting: false,
-        actioned: false
+        awaiting: 0,
+        actioned: false,
+        joinable: t !== undefined
     };
-    interactionStates.set(e, o);
-    openInteractions.add(o);
-    interactionLog.push(t);
+    interactionStates.set(e, i);
+    openInteractions.add(i);
+    interactionLog.push(o);
     if (interactionLog.length > options.historyLimit) interactionLog.shift();
+    if (t !== undefined) {
+        eventInteractions.set(t, i);
+        // A microtask is too early: native dispatch runs microtasks between
+        // listeners. The callback must not close over `key`: a throttled timer
+        // would hold the Event strongly long past its dispatch.
+                setTimeout(() => {
+            i.joinable = false;
+            if (openInteractions.has(i)) maybeSettleInteraction(i, i.settleAt);
+        });
+    }
 }
 
 /**
@@ -2377,19 +2507,19 @@ function openInteraction(e, n) {
     // screen could have shown the wait.
         const i = n !== null && (typeof n === "object" || typeof n === "function") && typeof n.then === "function" ? n : null;
     if (i !== null) {
-        t.awaiting = true;
+        t.awaiting++;
         let e = false;
         let n;
         const settle = () => {
             if (e) return;
             e = true;
             if (n !== undefined) clearTimeout(n);
-            if (!openInteractions.has(t)) return;
-            t.awaiting = false;
-            const i = now();
-            t.event.continuationMs = i - o;
+            if (!openInteractions.has(t) || --t.awaiting > 0) return;
+            const o = now();
+            // From the last handler's return: the frames of one event share a record.
+                        t.event.continuationMs = o - (t.opened + t.event.handlerMs);
             checkUntrackedAsyncHandler(t);
-            maybeSettleInteraction(t, i);
+            maybeSettleInteraction(t, o);
         };
         n = setTimeout(settle, ASYNC_HANDLER_CAP_MS);
         // A pending cap must not hold a Node process (tests, SSR harnesses) open.
@@ -2467,8 +2597,8 @@ function openInteraction(e, n) {
 
 /** holdStart: `t` parked writes — the interactions that performed them wait for `t`. */ function markInteractionsHeld(e) {
     if (openInteractions.size === 0) return;
-    for (const n of e.In) {
-        const t = openInteractionOf(n.ze?.origin);
+    for (const n of e.Je) {
+        const t = openInteractionOf(n.we?.origin);
         if (t !== undefined) {
             t.heldIn.add(e);
             t.held = true;
@@ -2491,12 +2621,16 @@ function openInteraction(e, n) {
 
 function maybeSettleInteraction(e, n = now()) {
     const t = e.event;
-    if (e.open || e.awaiting || e.heldIn.size > 0) return;
+    if (e.open || e.awaiting > 0 || e.heldIn.size > 0) return;
     // A drain must have committed the last write (the handler's, or a redirect
     // hop's after the click's own drain) — the handler returning is not the
     // screen having it.
         if (t.writes > 0 && drainSeq <= e.writeDrain) return;
     for (const e of t.navigations) if (e.outcome === undefined) return;
+    if (e.joinable) {
+        e.settleAt = n;
+        return;
+    }
     openInteractions.delete(e);
     // Every write went to an excluded subject and nothing of the app's ran: the
     // click was on the observer's own UI (a devtools panel's button). Not a
@@ -2551,7 +2685,7 @@ const engineHooks = {
             prevDeps: n || !wantsRerun() ? null : captureDeps(e),
             // Mirror recompute's own prev-value resolution: an earlier run in the
             // same flush may still be holding in _pendingValue.
-            prevValue: e._e !== NOT_PENDING ? e._e : e.ce,
+            prevValue: e.Oe !== NOT_PENDING ? e.Oe : e.Ae,
             // A create run inherits the interaction of whatever is building it: the
             // enclosing recompute (a parent's fn creating children) or, at the top
             // of the recompute stack, the effect callback / handler frame.
@@ -2577,8 +2711,8 @@ const engineHooks = {
         // committed compute output is an unchanged run. `undefined` outputs are
         // exempt — a side-effect-only compute's work IS its effect phase, and
         // identity of `undefined` proves nothing.
-                if (t && r.causes !== null && e.He) {
-            const n = e._e !== NOT_PENDING ? e._e : e.ce;
+                if (t && r.causes !== null && e.u) {
+            const n = e.Oe !== NOT_PENDING ? e.Oe : e.Ae;
             if (n !== undefined && n === r.prevValue) t = false;
         }
         // Unstable-output check: memos only, non-create, plain runs with a
@@ -2586,7 +2720,12 @@ const engineHooks = {
         // plain-flush memo commits and in `_value` for direct ones. Overlay runs
         // are excluded — an optimistic re-derive legitimately produces fresh
         // equivalents while the lane settles.
-                if (r.causes !== null && t && !o && !i && !e.He) checkUnstableOutput(e, r.prevValue, e._e !== NOT_PENDING ? e._e : e.ce);
+                if (r.causes !== null && t && !o && !i && !e.u) checkUnstableOutput(e, r.prevValue, e.Oe !== NOT_PENDING ? e.Oe : e.Ae);
+        // The same exemption for memos: a run that committed `undefined` did its
+        // work as a side effect (a projection's draft writes or reconcile, a
+        // write from inside a memo), so core's `undefined === undefined` gate
+        // proves nothing. Reported as changed, so no consumer counts it as waste.
+                if (!t && (e.Oe !== NOT_PENDING ? e.Oe : e.Ae) === undefined) t = true;
         if (r.causes !== null) recordRerun(e, r, {
             selfMs: c,
             totalMs: a
@@ -2598,7 +2737,7 @@ const engineHooks = {
             noteInteractionRun(r.interaction, c, true);
             // The first effect callback runs with no re-run record to inherit from;
             // hand it the interaction that built the node (see effectRunStart).
-                        e.pn = r.interaction;
+                        e.qe = r.interaction;
             if (openFlush !== null) noteFlushRun(openFlush, true, r.interaction);
             if (records.observed("create")) {
                 const n = {
@@ -2628,9 +2767,9 @@ const engineHooks = {
         trackFlightStart(e, n);
     },
     asyncStart(e) {
-        asyncStartSeq = e.ze?.seq ?? 0;
-        asyncStartTime = e.Ge;
-        asyncStartValue = e.ce;
+        asyncStartSeq = e.we?.seq ?? 0;
+        asyncStartTime = e.Ie;
+        asyncStartValue = e.Ae;
     },
     asyncEnd(e, n, t, o) {
         if (o) {
@@ -2640,7 +2779,7 @@ const engineHooks = {
             // (or `_time`, for a same-reference commit under `equals: false`), and
             // a transition hold parks the value in `_pendingValue`. A landing the
             // equality gate swallowed moves none of them and must leave no stamp.
-            const o = e.ce !== asyncStartValue || e.Ge !== asyncStartTime || e._e === t;
+            const o = e.Ae !== asyncStartValue || e.Ie !== asyncStartTime || e.Oe === t;
             if (o) stampWrite(e, "async", n === undefined ? NO_VALUES : n, t);
             // Flight over either way — an equality-swallowed landing still spent
             // the wall time (finalizeFlight only chains through a fresh stamp).
@@ -2650,12 +2789,12 @@ const engineHooks = {
         // Landed through setSignal: reclassify its "write" stamp as an async
         // landing — but only if it actually stamped (the value changed) since
         // asyncStart; a no-change landing must leave no fresh stamp behind.
-                const i = e.ze;
+                const i = e.we;
         if (i !== undefined && i.seq > asyncStartSeq && i.kind === "write") stampWrite(e, "async", NO_VALUES, t);
         finalizeFlight(e);
     },
     effectRunStart(e) {
-        pushFrame("effect", nodeName(e), e.pn, e);
+        pushFrame("effect", nodeName(e), e.qe, e);
         // The frame's own `at` doubles as the record's start: set only while
         // listened, so a listener arriving mid-callback finds no start and the
         // end emits nothing for it — and an unlistened callback pays no clock read.
@@ -2759,8 +2898,10 @@ const holds = [];
     stagedFallbacks.delete(DRAIN);
     trackingGen++;
     openNavs.clear();
+    landedGraphs.length = 0;
     openInteractions.clear();
     routeCounts.clear();
+    visitRoute = undefined;
     drainSeq = 0;
     originFrames.length = 0;
     effectStack.length = 0;