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

package/dist/dev.attribution.js

@@ -1,18 +1,24 @@
 import {
-  bL as OBSERVE,
-  bV as setAttributionHooks,
-  bW as liveRootOwners,
-  b as NOT_PENDING,
-  ay as emitDiagnostic,
-  bX as ownerPath,
-  ax as reportDiagnostic,
-  bY as isSuppressed,
-  bZ as CONFIG_PLUMBING,
-  b_ as anyExcluded,
-  b$ as isExcluded,
-  q as CONFIG_DERIVED_OVERRIDE,
-  c0 as GRAPH_SIZE_WARN_AT,
-  c1 as noteFanOut,
+  bv as OBSERVE,
+  bF as setAttributionHooks,
+  bG as liveRootOwners,
+  N as NOT_PENDING,
+  ap as emitDiagnostic,
+  bH as ownerPath,
+  aD as reportDiagnostic,
+  bI as isSuppressed,
+  bJ as blockersOf,
+  bK as CONFIG_PLUMBING,
+  bL as anyExcluded,
+  bM as isExcluded,
+  bN as CONFIG_WIDE,
+  a as CONFIG_OVERRIDE,
+  C as CONFIG_GUESS,
+  G as GlobalQueue,
+  b as CONFIG_VERDICT,
+  bO as GRAPH_SIZE_WARN_AT,
+  bP as noteFanOut,
+  bQ as CONFIG_SUPERSEDES,
   aV as $REFRESH
 } from "./dev-shared.js";
 
@@ -48,7 +54,7 @@ const defaultOptions = {
   stacks: false,
   historyLimit: 200,
   hotRuns: { count: 120, windowMs: 1000 },
-  wideDeps: 30,
+  wideDeps: 200,
   hotTime: { budgetMs: 8, windowMs: 1000 },
   unstableMemos: 4,
   wastedRecompute: { minRuns: 5, ratio: 0.8, budgetMs: 2, windowMs: 1000 },
@@ -192,13 +198,20 @@ function targetLabel(target) {
 }
 function interactionStart(ref) {
   interactionStack.push(currentInteraction);
+  // No `ref.event`: the WeakMap answers undefined.
+  const joined = eventInteractions.get(ref.event);
+  if (joined?.joinable && openInteractions.has(joined)) {
+    joined.open = true;
+    currentInteraction = joined.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 opened = now();
   const origin = { kind: "interaction", name: ref.type, at: ref.at ?? opened };
   if (ref.target) origin.target = targetLabel(ref.target);
   currentInteraction = origin;
-  openInteraction(origin, opened);
+  openInteraction(origin, opened, ref.event);
 }
 function interactionEnd(returned) {
   const closing = currentInteraction;
@@ -385,12 +398,6 @@ function formatOrigin(origin) {
   }
 }
 /** Record a root change (setSignal / refresh / async landing) on the node. */
-/** Live subscriber count, walked on demand — the core keeps no counter. */
-function countSubscribers(node) {
-  let n = 0;
-  for (let s = node._subs; s !== null; s = s._nextSub) 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
@@ -399,12 +406,20 @@ function countSubscribers(node) {
  * 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(node, kind) {
   const limit = options.fanOut;
   if (typeof limit !== "number") return;
-  const subs = countSubscribers(node);
-  if (subs < limit || subs >= GRAPH_SIZE_WARN_AT) return;
+  let all = 0;
+  let subs = 0;
+  for (let s = node._subs; s !== null; s = s._nextSub) {
+    all++;
+    if (!(s._sub._config & CONFIG_PLUMBING)) subs++;
+  }
+  if (subs < limit || all >= GRAPH_SIZE_WARN_AT) return;
   noteFanOut(node, subs, kind);
 }
 function stampWrite(node, kind, prev = NO_VALUES, value = NO_VALUES) {
@@ -483,18 +498,25 @@ function captureDeps(el) {
 }
 /**
  * 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(el) {
   const limit = options.wideDeps;
-  if (limit === false) return;
+  // Only dev sets CONFIG_WIDE (see constants.ts).
+  if (limit === false || el._config & CONFIG_WIDE) return;
   let count = 0;
   const names = [];
   for (let l = el._deps; l !== null; l = l._nextDep) {
-    count++;
-    if (names.length < 12) names.push(nodeName(l._dep));
+    // HMR plumbing is a dev-only hop the scope cannot read past: not a source.
+    if (!(l._dep._config & CONFIG_PLUMBING)) {
+      count++;
+      if (names.length < 12) names.push(nodeName(l._dep));
+    }
     if (l === el._depsTail) break; // the validated prefix, as captureDeps
   }
   const node = el;
@@ -650,7 +672,10 @@ function checkHotTime(el, selfMs, causes) {
  * 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(el, at, phase, changed, selfMs, causes) {
   const cfg = options.wastedRecompute;
@@ -851,8 +876,10 @@ function shallowEquivalent(a, b) {
     for (let i = 0; i < arrA.length; i++) if (arrA[i] !== arrB[i]) return false;
     return true;
   }
-  const keys = Object.keys(a);
-  if (keys.length > UNSTABLE_KEY_CAP || keys.length !== Object.keys(b).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 keys = Reflect.ownKeys(a);
+  if (keys.length > UNSTABLE_KEY_CAP || keys.length !== Reflect.ownKeys(b).length) return false;
   for (const key of keys) {
     if (!(key in b) || a[key] !== b[key]) return false;
   }
@@ -1486,14 +1513,11 @@ function checkWaterfall(el, chain, ms) {
 const holdStates = new WeakMap();
 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. */
+/** 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(node) {
-  return (
-    (!!node._x && node._x._parentSource !== undefined) ||
-    (node._config & CONFIG_DERIVED_OVERRIDE) !== 0
-  );
+  return (node._config & (CONFIG_OVERRIDE | CONFIG_GUESS)) === CONFIG_OVERRIDE;
 }
 const HOLD_CENSUS_CAP = 10_000;
 function acknowledge(state, kind, source, reader) {
@@ -1509,15 +1533,17 @@ function acknowledge(state, kind, source, reader) {
     );
   else if (path !== undefined) existing.reader ??= path;
 }
+/** The declarations made against the hold: the guesses of its lanes
+ * (lanes.ts `_laneGuesses`) and its `affects()` marks (`_marks`). */
 function censusRegistrations(t, state) {
   const budget = { left: HOLD_CENSUS_CAP };
-  for (const node of t._optimisticNodes)
-    if (!isCompanion(node))
+  const guesses = GlobalQueue._laneGuesses?.(t);
+  if (guesses !== undefined)
+    for (const node of guesses)
       acknowledge(state, "optimistic", nodeName(node), reachesEffect(node, budget));
-  for (const store of t._optimisticStores)
-    acknowledge(state, "optimistic", store?._name ?? "store", null);
-  for (const node of t._affectsNodes)
-    acknowledge(state, "affects", nodeName(node), reachesEffect(node, budget));
+  if (t._marks !== null)
+    for (const node of t._marks)
+      acknowledge(state, "affects", nodeName(node), reachesEffect(node, budget));
 }
 /**
  * Does anything that paints read `companion` — an effect, through however many
@@ -1542,7 +1568,10 @@ function reachesEffect(companion, budget) {
   }
   return null;
 }
-/** Companions an effect reads, anywhere downstream of the hold's nodes. */
+/** 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(roots, state) {
   const visited = new Set();
   const stack = [...roots];
@@ -1551,20 +1580,16 @@ function censusCompanions(roots, state) {
     const node = stack.pop();
     if (visited.has(node)) continue;
     visited.add(node);
-    const x = node._x;
-    if (x) {
-      let reader;
-      if (x._pendingSignal !== undefined && (reader = reachesEffect(x._pendingSignal, budget)))
-        acknowledge(state, "isPending", nodeName(node), reader);
-      if (
-        x._latestValueComputed !== undefined &&
-        (reader = reachesEffect(x._latestValueComputed, budget))
-      )
-        acknowledge(state, "latest", nodeName(node), reader);
-      for (let child = x._child ?? null; child !== null; child = child._nextChild ?? null)
-        stack.push(child);
+    for (let s = node._subs; s !== null; s = s._nextSub) {
+      const sub = s._sub;
+      if (sub._config & CONFIG_VERDICT) {
+        const windows = sub._devWindows ?? 0;
+        const reader = sub._type ? sub : reachesEffect(sub, budget);
+        if (windows & 1 && reader !== null) acknowledge(state, "isPending", nodeName(node), reader);
+        if (windows & 2 && reader !== null) acknowledge(state, "latest", nodeName(node), reader);
+      }
+      stack.push(sub);
     }
-    for (let s = node._subs; s !== null; s = s._nextSub) stack.push(s._sub);
   }
 }
 function holdState(t) {
@@ -1590,9 +1615,8 @@ function trackHoldStart(t) {
   if (options.holds === false) return;
   const state = holdState(t);
   state.flushes++;
-  if (t._actions.length > 0) state.action = true;
-  for (const [source, reporters] of t._asyncReporters)
-    if (reporters.size > 0) state.blockers.add(source);
+  if (t._open > 0) state.action = true;
+  for (const source of blockersOf(t)) state.blockers.add(source);
   censusRegistrations(t, state);
   activeHold = state;
 }
@@ -1628,7 +1652,7 @@ function trackHoldSettled(t) {
   let interaction;
   let origin;
   let lastJoinAt = -Infinity;
-  for (const node of t._pendingNodes) {
+  for (const node of t._nodes) {
     if (typeof node._fn === "function" || isCompanion(node)) continue;
     const change = node._devChange;
     if (change === undefined || change.kind !== "write") continue;
@@ -1658,7 +1682,7 @@ function trackHoldSettled(t) {
     return;
   }
   censusRegistrations(t, state);
-  censusCompanions([...t._pendingNodes, ...state.blockers], state);
+  censusCompanions([...t._nodes, ...state.blockers], state);
   const end = 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
@@ -1889,8 +1913,17 @@ function checkOptimisticRevert(el, shown, truth, how) {
   );
 }
 // --- Graph growth -----------------------------------------------------------------
-/** Per route: the graph's size at its last `visits` settles, oldest first. */
+/**
+ * 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
  * creation, disposal, write or re-run; the engine asks at a navigation's
@@ -1905,26 +1938,42 @@ const routeCounts = new Map();
  * counted unless a subscription still reaches them.
  */
 function graphSize() {
+  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(before, survived) {
   const roots = liveRootOwners();
-  const size = { roots: roots.length, owners: 0, computations: 0, signals: 0, edges: 0 };
+  const size = { roots: 0, owners: 0, computations: 0, signals: 0, edges: 0 };
   const seen = new Set();
   // A worklist, not recursion: a subscriber chain can be thousands deep.
   const work = [];
   const stack = [];
+  const count = (node, key) => {
+    size[key]++;
+    if (survived !== undefined) {
+      if (before.has(node)) survived[key]++;
+    } else if (before !== undefined) before.add(node);
+  };
   const meet = node => {
     if (seen.has(node)) return;
     seen.add(node);
-    if (typeof node._fn === "function") size.computations++;
-    else size.signals++;
+    count(node, typeof node._fn === "function" ? "computations" : "signals");
     work.push(node);
   };
   for (const root of roots) {
-    size.owners++;
+    count(root, "roots");
+    count(root, "owners");
     // Iterative: a deep tree must not grow the call stack.
     let child = root._firstChild;
     for (;;) {
       while (child !== null) {
-        size.owners++;
+        count(child, "owners");
         if (typeof child._fn === "function") meet(child);
         if (child._firstChild !== null) stack.push(child);
         child = child._nextSibling;
@@ -1943,10 +1992,20 @@ function graphSize() {
       for (let link = node._deps; link !== null; link = link._nextDep) {
         size.edges++;
         meet(link._dep);
+        if (survived !== undefined && before.has(node) && before.has(link._dep)) survived.edges++;
       }
   }
   return size;
 }
+/**
+ * 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 before = new WeakSet();
+  walkGraph(before);
+  return before;
+}
 /**
  * settleNavigation: the app has finished moving to a route — count the live
  * graph. One record per settle for a listener; the growth check compares
@@ -1955,43 +2014,77 @@ function graphSize() {
  * `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(navigation) {
+function trackGraph(state) {
+  const navigation = state.event;
+  const before = state.before;
+  state.before = undefined;
   const cfg = options.graphGrowth;
   if (cfg === false && !records.observed("graph")) return;
-  const size = graphSize();
+  const survived = before && {
+    roots: 0,
+    owners: 0,
+    computations: 0,
+    signals: 0,
+    edges: 0
+  };
+  const size = walkGraph(before, survived);
   const route = navigation.name ?? navigation.to;
   const event = { at: now(), ...size, navigation };
   if (route !== undefined) event.route = route;
   records.emit("graph", event, undefined);
   if (cfg === false || route === 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 left = visitRoute;
+  if (navigation.outcome !== "superseded") visitRoute = route;
+  // 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 (navigation.initial || route === left || survived === undefined) return;
   let history = routeCounts.get(route);
   if (history === undefined) routeCounts.set(route, (history = []));
-  history.push(size);
+  history.push({ size, survived });
   if (history.length > cfg.visits) history.shift();
   if (history.length < cfg.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 grew = GRAPH_SERIES.filter(key => {
-    for (let i = 1; i < history.length; i++)
-      if (history[i][key] <= history[i - 1][key]) return false;
-    return history[history.length - 1][key] >= history[0][key] * cfg.ratio;
-  });
+  const totals = history.map(h => h.size);
+  const kept = history.map(h => h.survived);
+  const climbs = (series, key) => {
+    for (let i = 1; i < series.length; i++) if (series[i][key] <= series[i - 1][key]) return false;
+    return series[series.length - 1][key] >= series[0][key] * cfg.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 grew = GRAPH_SERIES.filter(key => climbs(totals, key) && climbs(kept, key));
   if (grew.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 routes = [...routeCounts.keys()];
-  const series = grew.map(key => `${key} ${history.map(h => h[key]).join(" → ")}`).join("; ");
+  const join = (series, key) => series.map(h => h[key]).join(" → ");
+  const series = grew.map(key => `${key} ${join(kept, key)} (of ${join(totals, key)})`).join("; ");
   const shape = grew.includes("owners")
     ? "a createRoot() in an effect or handler with no dispose, or a Portal or panel mounted per visit"
     : grew.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 message =
-    `[GRAPH_GROWTH] the live graph grew on ${cfg.visits} consecutive visits to ${route}: ${series} ` +
+    `[GRAPH_GROWTH] the live graph grew on ${cfg.visits} consecutive visits to ${route}, and so did ` +
+    `the part that outlived each navigation there: ${series} ` +
     `(${size.roots} roots)${routes.length > 1 ? `, across visits to ${routes.join(", ")}` : ""}. Each ` +
     `visit left something behind that the next did not reclaim — the shape says ${shape}. Dispose ` +
     `what a visit creates (onCleanup, or return the disposer from onSettled) and own it under the ` +
@@ -1999,7 +2092,8 @@ function trackGraph(navigation) {
   const data = {
     route,
     grew,
-    history: history.map(h => ({ ...h })),
+    history: totals,
+    survived: kept,
     roots: size.roots,
     routes
   };
@@ -2019,11 +2113,14 @@ const abandonWindows = new WeakMap();
  * 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(el, abandoned) {
   const cfg = options.abandonedFlights;
-  if (cfg === false || excludedNode(el)) return;
+  // Only dev sets CONFIG_SUPERSEDES (see constants.ts).
+  if (cfg === false || el._config & CONFIG_SUPERSEDES || excludedNode(el)) return;
   const at = Date.now();
   let win = abandonWindows.get(el);
   if (win === undefined || at - win.start > cfg.windowMs) {
@@ -2129,6 +2226,14 @@ const openNavs = new Set();
 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
@@ -2163,6 +2268,8 @@ function openNavigation(frame, ref) {
     held: false,
     writeDrain: drainSeq
   };
+  // The initial declaration is never compared (see `trackGraph`).
+  if (options.graphGrowth !== false && ref.initial !== true) state.before = snapshotGraph();
   syncNavigation(state);
   navStates.set(frame, state);
   openNavs.add(state);
@@ -2221,7 +2328,7 @@ function noteNavigationWrite(prior, record) {
 /** holdStart: `t`'s staged writes are parked — their navigations settle with `t`. */
 function markNavigationsHeld(t) {
   if (openNavs.size === 0) return;
-  for (const node of t._pendingNodes) {
+  for (const node of t._nodes) {
     const origin = node._devChange?.origin;
     if (origin?.kind !== "navigation") continue;
     const state = navStates.get(origin);
@@ -2231,14 +2338,14 @@ function markNavigationsHeld(t) {
 /** transitionSettled: `t` commits — the navigations whose writes it staged are done. */
 function settleNavigations(t, hold) {
   if (openNavs.size === 0) return;
-  for (const node of t._pendingNodes) {
+  for (const node of t._nodes) {
     const origin = node._devChange?.origin;
     if (origin?.kind !== "navigation") continue;
     const state = navStates.get(origin);
     if (state === undefined || !openNavs.has(state)) continue;
     // A navigation whose frame is still open when its transition commits
     // (`until()` inside the frame) settles here too: its writes are through.
-    settleNavigation(state, state.held ? "held" : "committed", hold);
+    settleNavigation(state, state.held ? "held" : "committed", hold, true);
   }
 }
 let openFlush = null;
@@ -2354,11 +2461,14 @@ function trackFlushEnd() {
   drainSeq++;
   // The swaps this drain committed have rendered.
   displayFallbacks();
+  // Landed first: they settled before anything this drain settles below.
+  for (let i = 0; i < landedGraphs.length; i++) trackGraph(landedGraphs[i]);
+  landedGraphs.length = 0;
   for (const state of openNavs)
     if (state.open === 0 && !state.held) settleNavigation(state, "committed");
   for (const state of openInteractions) maybeSettleInteraction(state);
 }
-function settleNavigation(state, outcome, hold) {
+function settleNavigation(state, outcome, hold, landed) {
   if (!openNavs.has(state)) return;
   openNavs.delete(state);
   syncNavigation(state);
@@ -2371,16 +2481,19 @@ function settleNavigation(state, outcome, hold) {
   // route's responsiveness in the feedback tables. Consumers get the record.
   if (event.initial !== true) for (const f of folds) f.navigation?.(event);
   records.emit("navigation", event, undefined);
-  trackGraph(event);
+  if (landed) landedGraphs.push(state);
+  else trackGraph(state);
   // The interaction that performed it may have been waiting only on this.
   const under = openInteractionOf(event.interaction);
   if (under !== undefined) maybeSettleInteraction(under);
 }
 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(frame, opened) {
+function openInteraction(frame, opened, key) {
   const event = {
     name: frame.name,
     at: frame.at,
@@ -2406,13 +2519,24 @@ function openInteraction(frame, opened) {
     heldIn: new Set(),
     held: false,
     excludedWrites: 0,
-    awaiting: false,
-    actioned: false
+    awaiting: 0,
+    actioned: false,
+    joinable: key !== undefined
   };
   interactionStates.set(frame, state);
   openInteractions.add(state);
   interactionLog.push(event);
   if (interactionLog.length > options.historyLimit) interactionLog.shift();
+  if (key !== undefined) {
+    eventInteractions.set(key, state);
+    // 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(() => {
+      state.joinable = false;
+      if (openInteractions.has(state)) maybeSettleInteraction(state, state.settleAt);
+    });
+  }
 }
 /**
  * How long the record waits on a handler's returned promise before settling
@@ -2438,17 +2562,17 @@ function closeInteraction(frame, returned) {
       ? returned
       : null;
   if (thenable !== null) {
-    state.awaiting = true;
+    state.awaiting++;
     let done = false;
     let timer;
     const settle = () => {
       if (done) return;
       done = true;
       if (timer !== undefined) clearTimeout(timer);
-      if (!openInteractions.has(state)) return;
-      state.awaiting = false;
+      if (!openInteractions.has(state) || --state.awaiting > 0) return;
       const at = now();
-      state.event.continuationMs = at - end;
+      // From the last handler's return: the frames of one event share a record.
+      state.event.continuationMs = at - (state.opened + state.event.handlerMs);
       checkUntrackedAsyncHandler(state);
       maybeSettleInteraction(state, at);
     };
@@ -2528,7 +2652,7 @@ function noteInteractionNavigation(event) {
 /** holdStart: `t` parked writes — the interactions that performed them wait for `t`. */
 function markInteractionsHeld(t) {
   if (openInteractions.size === 0) return;
-  for (const node of t._pendingNodes) {
+  for (const node of t._nodes) {
     const state = openInteractionOf(node._devChange?.origin);
     if (state !== undefined) {
       state.heldIn.add(t);
@@ -2551,12 +2675,16 @@ function settleInteractionsHeld(t, hold) {
 }
 function maybeSettleInteraction(state, end = now()) {
   const event = state.event;
-  if (state.open || state.awaiting || state.heldIn.size > 0) return;
+  if (state.open || state.awaiting > 0 || state.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 (event.writes > 0 && drainSeq <= state.writeDrain) return;
   for (const nav of event.navigations) if (nav.outcome === undefined) return;
+  if (state.joinable) {
+    state.settleAt = end;
+    return;
+  }
   openInteractions.delete(state);
   // 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
@@ -2653,6 +2781,12 @@ const engineHooks = {
         frame.prevValue,
         el._pendingValue !== NOT_PENDING ? el._pendingValue : el._value
       );
+    // 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 (!changed && (el._pendingValue !== NOT_PENDING ? el._pendingValue : el._value) === undefined)
+      changed = true;
     if (frame.causes !== null)
       recordRerun(
         el,
@@ -2832,8 +2966,10 @@ function resetTracking() {
   stagedFallbacks.delete(DRAIN);
   trackingGen++;
   openNavs.clear();
+  landedGraphs.length = 0;
   openInteractions.clear();
   routeCounts.clear();
+  visitRoute = undefined;
   drainSeq = 0;
   originFrames.length = 0;
   effectStack.length = 0;