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

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.u & 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.me === undefined) n.me = isExcluded(e);
+    return n.me;
 }
 
 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.i ? "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.ge
     });
 }
 
@@ -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.we !== undefined) i.run = e.we;
         // 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.l) {
+        o++;
+        if (!(n.o.u & 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.ve;
+    e.ve = 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.ve = {
         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.ke ?? 0;
     const t = [];
-    const o = e.ze;
+    const o = e.ve;
     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._; o !== null; o = o.p) {
+        const e = o.I.ve;
         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.ke = 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._; t !== null; t = t.p) {
+        n.push(t.I);
+        if (t === e.S) 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._; n !== null; n = n.p) {
+        // HMR plumbing is a dev-only hop the scope cannot read past: not a source.
+        if (!(n.I.u & CONFIG_PLUMBING)) {
+            t++;
+            if (o.length < 12) o.push(nodeName(n.I));
+        }
+        if (n === e.S) 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.ye ?? 0) * 1.5) return;
+    i.ye = 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.$e === undefined || i - o.$e > t.windowMs) {
+        o.$e = i;
+        o.be = 0;
+        o.Fe = false;
+    }
+    o.be = (o.be ?? 0) + 1;
+    if (o.Fe || o.be < t.count) return;
+    o.Fe = 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.be;
     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.be} times ` + `in ${Math.max(1, i - o.$e)}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.be,
                 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.Le === undefined || s - i.Le > o.windowMs) {
+        i.Le = s;
+        i.Ce = 0;
+        i.Me = false;
+    }
+    i.Ce = (i.Ce ?? 0) + n;
+    if (i.Me || i.Ce < o.budgetMs) return;
+    i.Me = 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.Ce.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.Ce,
             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.He === undefined || n - a.He > r.windowMs) {
+        a.He = n;
+        a.We = 0;
+        a.Ge = 0;
+        a.qe = 0;
+        a.Be = false;
+    }
+    a.We = a.We + 1;
     if (!o) {
-        a.un = a.un + 1;
-        a.ln = a.ln + i;
+        a.Ge = a.Ge + 1;
+        a.qe = a.qe + i;
     }
-    if (a.hn || a.fn < r.minRuns || a.un / a.fn < r.ratio || a.ln < r.budgetMs) return;
-    a.hn = true;
+    if (a.Be || a.We < r.minRuns || a.Ge / a.We < r.ratio || a.qe < r.budgetMs) return;
+    a.Be = true;
     const c = {
-        runs: a.fn,
-        wasted: a.un,
-        wastedMs: a.ln
+        runs: a.We,
+        wasted: a.Ge,
+        wastedMs: a.qe
     };
     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.ge;
     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.xe = d;
+        a.we = undefined;
+        a.ge = 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.Ke = (a.Ke ?? 0) + 1;
+    a.xe = d;
+    a.we = f;
+    a.ge = 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.Ve = 0;
+        i.je = false;
         return;
     }
-    i.gn = (i.gn ?? 0) + 1;
-    if (i.wn || i.gn < o) return;
-    i.wn = true;
+    i.Ve = (i.Ve ?? 0) + 1;
+    if (i.je || i.Ve < o) return;
+    i.je = 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.Ve} 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.Ve,
             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.Ye = o.Ye === undefined || o.Ye === r ? r : null;
+    if (s !== undefined && t !== undefined && t === s.node.pe) {
         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.ze = o.Xe === r ? (o.ze ?? 0) + 1 : 1;
+        o.Xe = r;
+        if (o.ze >= 2 && o.Ye === r) checkCopyEffect(s.node, e);
+    } else o.ze = 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._; n !== null; n = n.p) if (n.I.pe === e.pe) 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.Ye === 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.i ? "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.Qe ?? 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.ve;
     // 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.Ze ?? 0) >= i) return;
+    r.Ze = 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.u & (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.Je?.(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.l) {
+            const e = n.o;
+            if (e.i) 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.l) {
+            const s = t.o;
+            if (s.u & CONFIG_VERDICT) {
+                const t = s.en ?? 0;
+                const o = s.i ? 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.nn) {
+        if (typeof n.re === "function" || isCompanion(n)) continue;
+        const e = n.ve;
         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.nn, ...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.tn;
     if (i && i.call(e, n, t)) return;
     const s = nodeName(e);
     // The two values are user data: quoted only under `values: "full"`; the
@@ -1846,33 +1875,33 @@ function checkLongHold(e, n) {
     const meet = e => {
         if (t.has(e)) return;
         t.add(e);
-        if (typeof e.Se === "function") n.computations++; else n.signals++;
+        if (typeof e.re === "function") n.computations++; else n.signals++;
         o.push(e);
     };
     for (const t of e) {
         n.owners++;
         // Iterative: a deep tree must not grow the call stack.
-                let e = t.On;
+                let e = t.sn;
         for (;;) {
             while (e !== null) {
                 n.owners++;
-                if (typeof e.Se === "function") meet(e);
-                if (e.On !== null) i.push(e);
-                e = e._n;
+                if (typeof e.re === "function") meet(e);
+                if (e.sn !== null) i.push(e);
+                e = e.rn;
             }
             const t = i.pop();
             if (t === undefined) break;
-            e = t.On;
+            e = t.sn;
         }
     }
     for (let e = 0; e < o.length; e++) {
         const t = o[e];
         // 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) {
+                for (let e = t.t; e !== null; e = e.l) meet(e.o);
+        if (typeof t.re === "function") for (let e = t._; e !== null; e = e.p) {
             n.edges++;
-            meet(e.De);
+            meet(e.I);
         }
     }
     return n;
@@ -1900,7 +1929,10 @@ function trackGraph(e) {
     };
     if (o !== undefined) i.route = o;
     records.emit("graph", i, undefined);
-    if (n === false || o === undefined) return;
+    // 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.
+        if (n === false || o === undefined || e.initial) return;
     let s = routeCounts.get(o);
     if (s === undefined) routeCounts.set(o, s = []);
     s.push(t);
@@ -1953,10 +1985,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) {
@@ -2151,8 +2186,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.nn) {
+        const e = n.ve?.origin;
         if (e?.kind !== "navigation") continue;
         const t = navStates.get(e);
         if (t !== undefined) t.held = true;
@@ -2161,8 +2196,8 @@ 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.nn) {
+        const e = t.ve?.origin;
         if (e?.kind !== "navigation") continue;
         const o = navStates.get(e);
         if (o === undefined || !openNavs.has(o)) continue;
@@ -2320,12 +2355,14 @@ function settleNavigation(e, n, t) {
 
 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 +2374,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 +2425,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 +2515,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.nn) {
+        const t = openInteractionOf(n.ve?.origin);
         if (t !== undefined) {
             t.heldIn.add(e);
             t.held = true;
@@ -2491,12 +2539,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 +2603,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.Ae !== NOT_PENDING ? e.Ae : e.pe,
             // 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 +2629,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.i) {
+            const n = e.Ae !== NOT_PENDING ? e.Ae : e.pe;
             if (n !== undefined && n === r.prevValue) t = false;
         }
         // Unstable-output check: memos only, non-create, plain runs with a
@@ -2586,7 +2638,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.i) checkUnstableOutput(e, r.prevValue, e.Ae !== NOT_PENDING ? e.Ae : e.pe);
+        // 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.Ae !== NOT_PENDING ? e.Ae : e.pe) === undefined) t = true;
         if (r.causes !== null) recordRerun(e, r, {
             selfMs: c,
             totalMs: a
@@ -2598,7 +2655,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.xe = r.interaction;
             if (openFlush !== null) noteFlushRun(openFlush, true, r.interaction);
             if (records.observed("create")) {
                 const n = {
@@ -2628,9 +2685,9 @@ const engineHooks = {
         trackFlightStart(e, n);
     },
     asyncStart(e) {
-        asyncStartSeq = e.ze?.seq ?? 0;
-        asyncStartTime = e.Ge;
-        asyncStartValue = e.ce;
+        asyncStartSeq = e.ve?.seq ?? 0;
+        asyncStartTime = e.Ne;
+        asyncStartValue = e.pe;
     },
     asyncEnd(e, n, t, o) {
         if (o) {
@@ -2640,7 +2697,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.pe !== asyncStartValue || e.Ne !== asyncStartTime || e.Ae === 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 +2707,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.ve;
         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.xe, 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.