@solidjs/signals 2.0.0-rc.7 → 2.0.0-rc.9

package/dist/dev.attribution.js

@@ -0,0 +1,2485 @@
+import {
+  bK as setAttributionHooks,
+  b as NOT_PENDING,
+  ax as reportDiagnostic,
+  ay as emitDiagnostic,
+  bL as isSuppressed,
+  bM as recordSubject,
+  bN as anyExcluded,
+  bO as isExcluded,
+  q as CONFIG_DERIVED_OVERRIDE,
+  bP as GRAPH_SIZE_WARN_AT,
+  bF as ownerPath,
+  bQ as subjectOf,
+  aT as $REFRESH
+} from "./dev-shared.js";
+
+/**
+ * Under an owner the observer marked as its own (`OBSERVE.exclude`): the
+ * engine records nothing about the node. Cached per node once any exclusion
+ * exists; before that the answer is a flag read.
+ */
+function excludedNode(el) {
+  if (!anyExcluded()) return false;
+  const node = el;
+  if (node._devExcluded === undefined) node._devExcluded = isExcluded(el);
+  return node._devExcluded;
+}
+let changeSeq = 0;
+let runSeq = 0;
+const defaultOptions = {
+  log: true,
+  stacks: false,
+  historyLimit: 200,
+  hotRuns: { count: 120, windowMs: 1000 },
+  wideDeps: 30,
+  hotTime: { budgetMs: 8, windowMs: 1000 },
+  unstableMemos: 4,
+  wideWrites: 250,
+  waterfalls: { minFlightMs: 50 },
+  holds: { infoMs: 100, warnMs: 200 },
+  longHolds: { infoMs: 500, warnMs: 1000 }
+};
+let options = { ...defaultOptions };
+let history = [];
+const recordListeners = {
+  rerun: new Set(),
+  interaction: new Set(),
+  hold: new Set(),
+  navigation: new Set()
+};
+function emitRecord(type, record) {
+  for (const listener of recordListeners[type]) listener(record);
+}
+function clearListeners() {
+  for (const type in recordListeners) recordListeners[type].clear();
+}
+/** @internal The engine's clock: `performance.now()` where it exists. */
+const now = typeof performance !== "undefined" ? () => performance.now() : () => Date.now();
+const frames = [];
+const folds = [];
+/** @internal */
+function registerFold(hooks) {
+  folds.push(hooks);
+}
+/** @internal Root cause names of a cause chain — the writes/landings/refreshes the chain bottoms out in. */
+function rootsOf(causes, out) {
+  for (const c of causes) {
+    if (c.kind === "derived" && c.causes && c.causes.length > 0) rootsOf(c.causes, out);
+    else out.add(c.name);
+  }
+}
+function nodeName(node) {
+  return node._name ?? "anonymous";
+}
+function preview(v) {
+  if (v === null) return "null";
+  switch (typeof v) {
+    case "undefined":
+      return "undefined";
+    case "string":
+      return JSON.stringify(v.length > 40 ? v.slice(0, 40) + "…" : v);
+    case "number":
+    case "boolean":
+    case "bigint":
+      return String(v);
+    case "function":
+      return "[function]";
+    case "symbol":
+      return v.toString();
+    default:
+      return Array.isArray(v) ? `Array(${v.length})` : `[${v.constructor?.name ?? "object"}]`;
+  }
+}
+function captureStack() {
+  if (!options.stacks) return undefined;
+  const raw = new Error().stack?.split("\n") ?? [];
+  // Drop the message line and every frame inside the reactive core; the first
+  // remaining frames are the user code that performed the write.
+  return raw
+    .slice(1)
+    .filter(line => !/(?:^|[/\\])(?:packages[/\\])?signals[/\\](src|dist)[/\\]/.test(line))
+    .slice(0, 3)
+    .map(line => line.trim());
+}
+/** Sentinel for "no value transition to record" (refresh() stamps). */
+const NO_VALUES = Symbol("no-values");
+// --- Provenance -------------------------------------------------------------
+//
+// Who performed a write is not a graph fact — the graph only sees the write.
+// The engine keeps an ambient answer: a stack of imperative frames the core
+// announces (effect callbacks, action steps) and the interaction the web
+// runtime declares around event dispatch. A write stamps the innermost frame;
+// frames nested under an interaction carry it. Effects run in a later flush
+// than the click that caused them, so their frame inherits the interaction
+// from the run's cause chain instead (recorded at recomputeEnd).
+const EXTERNAL_ORIGIN = { kind: "external" };
+const originFrames = [];
+/** Per action invocation (keyed by its iterator): the interaction its first step ran under. */
+const actionInteractions = new WeakMap();
+/**
+ * The interaction frame the core's `withInteraction` opened (via the
+ * `interactionStart`/`interactionEnd` hooks) for the duration of a handler.
+ * Frames nest strictly, so the enclosing one is kept on a stack to restore.
+ * The core pins the engine per frame: an `interactionEnd` can arrive after
+ * `disable()` cleared the stack, so popping an empty stack is tolerated.
+ */
+let currentInteraction = null;
+const interactionStack = [];
+function interactionStart(ref) {
+  interactionStack.push(currentInteraction);
+  const origin = { kind: "interaction", name: ref.type, at: ref.at ?? now() };
+  if (ref.target) origin.target = ref.target;
+  currentInteraction = origin;
+  openInteraction(origin);
+}
+function interactionEnd() {
+  const closing = currentInteraction;
+  currentInteraction = interactionStack.length ? interactionStack.pop() : null;
+  if (closing !== null) closeInteraction(closing);
+}
+/** The interaction an origin runs under (itself, when it is one). */
+function interactionOf(origin) {
+  if (origin === undefined) return undefined;
+  return origin.kind === "interaction" ? origin : origin.interaction;
+}
+/** The interaction a cause list traces back to — root writes only, derived links walked. */
+function interactionIn(causes) {
+  for (const c of causes) {
+    const found =
+      c.kind === "derived"
+        ? c.causes !== undefined
+          ? interactionIn(c.causes)
+          : undefined
+        : interactionOf(c.origin);
+    if (found !== undefined) return found;
+  }
+  return undefined;
+}
+function currentOrigin() {
+  const frame = originFrames[originFrames.length - 1];
+  if (frame !== undefined) return frame;
+  return currentInteraction ?? EXTERNAL_ORIGIN;
+}
+/** The root origin a cause list traces back to — the stamp of the nearest root write, derived links walked. */
+function originIn(causes) {
+  for (const c of causes) {
+    const found =
+      c.kind === "derived" ? (c.causes !== undefined ? originIn(c.causes) : undefined) : c.origin;
+    if (found !== undefined && found.kind !== "external") return found;
+  }
+  return undefined;
+}
+/**
+ * The `currentOrigin` hook: what a runtime recording its own fact right now
+ * (a server-function call) should stamp it with. Inside a recompute the
+ * fact belongs to the change that caused the run — a `createAsync` calling
+ * the server on a navigation's write is the navigation's, and through it the
+ * click's — walked down past create runs the way `trackFlightStart` does,
+ * since a node born inside a parent's run inherits the parent's causality.
+ * Outside one — or when the causes were themselves external (a memo a
+ * handler pulls, stale from a timer's write) — it is the write's answer
+ * (`currentOrigin`), minus the external sentinel: "none known" is
+ * `undefined` on a record, as `HoldEvent.origin` has it. The objects
+ * returned are the engine's own frames, so the caller's record joins
+ * `InteractionEvent.origin` / `NavigationEvent.origin` by identity.
+ */
+function ambientOrigin() {
+  for (let i = frames.length - 1; i >= 0; i--) {
+    const causes = frames[i].causes;
+    if (causes !== null) {
+      const cause = originIn(causes);
+      if (cause !== undefined) return cause;
+      break;
+    }
+  }
+  const origin = currentOrigin();
+  return origin === EXTERNAL_ORIGIN ? undefined : origin;
+}
+const effectFrames = new WeakMap();
+/** The interaction the innermost open frame runs under, else the ambient one. */
+function enclosingInteraction() {
+  const top = originFrames[originFrames.length - 1];
+  return (top !== undefined ? interactionOf(top) : undefined) ?? currentInteraction ?? undefined;
+}
+function pushFrame(kind, name, interaction, effect) {
+  const frame = { kind };
+  if (name) frame.name = name;
+  const under = interaction ?? currentInteraction ?? undefined;
+  if (under !== undefined) frame.interaction = under;
+  if (effect !== undefined) {
+    const node = effect;
+    if (node._devRunSeq !== undefined) frame.run = node._devRunSeq;
+    effectFrames.set(frame, { node: effect, causes: node._devRunCauses });
+  }
+  originFrames.push(frame);
+}
+function popFrame(kind) {
+  // Frames are strictly nested; a mismatch means enable() landed mid-frame
+  // (the opener never pushed) — leave the stack alone rather than pop a stranger.
+  const top = originFrames[originFrames.length - 1];
+  if (top !== undefined && top.kind === kind) originFrames.pop();
+}
+/**
+ * `withOrigin` opened a declared frame. The frame object IS the origin every
+ * write inside stamps, and the key the navigation record hangs off (see
+ * "Navigations" below), so a hold or re-run that later resolves a write's
+ * origin lands on the same record. It runs under the interaction of the frame
+ * it opened inside — a `navigate()` from an action step, whose ambient
+ * interaction is long gone but whose frame remembers it — else the ambient
+ * one (a link click's handler).
+ */
+function originStart(ref) {
+  // A redirect hop re-enters the pending navigation's frame — the same object,
+  // so its writes stamp the same origin and replace the pending write without
+  // superseding it (see "Navigations").
+  if (ref.redirect !== undefined && ref.redirect > 0) {
+    const pending = lastOpenNavigation();
+    if (pending !== undefined) {
+      redirectNavigation(pending, ref);
+      originFrames.push(pending.event.origin);
+      return;
+    }
+  }
+  const frame = { kind: ref.kind, at: ref.at ?? now() };
+  if (ref.from !== undefined) frame.from = ref.from;
+  const under = enclosingInteraction();
+  if (under !== undefined) frame.interaction = under;
+  originFrames.push(frame);
+  openNavigation(frame, ref);
+}
+function originEnd() {
+  const top = originFrames[originFrames.length - 1];
+  popFrame("navigation");
+  if (top !== undefined && top.kind === "navigation") closeNavigation(top);
+}
+/** `click on button#next "Next →"`, `effect "syncTitle"`, `action "save"`, `navigation to /users/:id`, … */
+function formatOrigin(origin) {
+  switch (origin.kind) {
+    case "interaction":
+      return `${origin.name} on ${origin.target ?? "an element"}`;
+    case "effect":
+      return `effect${origin.name ? ` "${origin.name}"` : ""}`;
+    case "action":
+      return `action${origin.name ? ` "${origin.name}"` : ""}`;
+    case "async":
+      return `async landing${origin.name ? ` on "${origin.name}"` : ""}`;
+    case "navigation": {
+      // The route pattern is the name consumers group by; the concrete path
+      // follows when it adds information, then the destinations a redirect
+      // chain abandoned on the way.
+      const name = origin.name ?? origin.to;
+      if (name === undefined) return "navigation";
+      const notes = [];
+      if (origin.to !== undefined && origin.to !== name) notes.push(origin.to);
+      const redirects = navStates.get(origin)?.event.redirects;
+      if (redirects !== undefined)
+        notes.push(
+          `redirected from ${redirects.map(hop => hop.to ?? hop.name ?? "?").join(" → ")}`
+        );
+      return `navigation to ${name}${notes.length > 0 ? ` (${notes.join(", ")})` : ""}`;
+    }
+    default:
+      return "outside the reactive system";
+  }
+}
+/** 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;
+}
+/**
+ * Written-fan-out warning — the engine's lower-bar sibling of the always-on
+ * HUGE_FAN_OUT (see dev.ts): a committed root invalidation reaching hundreds
+ * of subscribers re-runs all of them this flush. Counts the subscriber list
+ * itself (an engine-only walk, on the write; the core keeps no per-node
+ * count — a live `_subCount` was a post-construction field that forked node
+ * shapes). Once per node; re-warns only when the subscriber count has
+ * doubled since the last warning. Stops at GRAPH_SIZE_WARN_AT, where
+ * HUGE_FAN_OUT takes over, so the two never fire for the same write.
+ */
+function checkWideWrite(node, kind) {
+  const limit = options.wideWrites;
+  if (typeof limit !== "number") return;
+  const subs = countSubscribers(node);
+  const attributed = node;
+  if (subs < limit || subs >= GRAPH_SIZE_WARN_AT) return;
+  if (subs < (attributed._devWideWriteWarnedAt ?? 0) * 2) return;
+  attributed._devWideWriteWarnedAt = subs;
+  const verb =
+    kind === "refresh" ? "refresh of" : kind === "async" ? "async landing on" : "write to";
+  const message =
+    `[WIDE_WRITE] ${verb} "${nodeName(node)}" reached ${subs} subscribers — every one ` +
+    `re-runs this flush. If consumers ask keyed questions of this value (for example every ` +
+    `row comparing against one selected id), invert it: keep the answer in a store used as a ` +
+    `map keyed by id, so each consumer reads its own key and only the keys that flipped update.`;
+  reportDiagnostic(
+    emitDiagnostic(
+      {
+        code: "WIDE_WRITE",
+        kind: "perf",
+        severity: "warn",
+        message,
+        nodeName: nodeName(node),
+        data: { subscribers: subs, write: kind }
+      },
+      node
+    )
+  );
+}
+function stampWrite(node, kind, prev = NO_VALUES, value = NO_VALUES) {
+  const record = { seq: ++changeSeq, kind, name: nodeName(node) };
+  if (value !== NO_VALUES) {
+    record.prev = prev === NO_VALUES ? undefined : preview(prev);
+    record.value = preview(value);
+  }
+  record.origin = kind === "async" ? asyncOrigin(node) : currentOrigin();
+  record.at = now();
+  record.stack = captureStack();
+  const prior = node._devChange;
+  node._devChange = record;
+  noteNavigationWrite(prior, record);
+  noteInteractionWrite(record.origin, excludedNode(node));
+  if (kind === "write") trackEffectWrite(node, record, value);
+  // stampWrite is the single funnel for committed root invalidations (sync
+  // writes, refresh(), async landings), which makes it the one place the
+  // written-fan-out check needs to live.
+  checkWideWrite(node, kind);
+}
+/** Record a derived change (memo produced a new value) with its causes. */
+function stampDerived(node, causes) {
+  node._devChange = {
+    seq: ++changeSeq,
+    kind: "derived",
+    name: nodeName(node),
+    causes
+  };
+}
+/**
+ * Collect the deps whose committed change is newer than this node's previous
+ * run. Called at recompute entry, while `_deps` still holds the previous
+ * run's links. A refresh() stamp on the node itself also counts — that is a
+ * self-invalidation, not a dep change.
+ */
+function collectCauses(el) {
+  const seen = el._devSeenSeq ?? 0;
+  const causes = [];
+  const self = el._devChange;
+  if (self !== undefined && self.seq > seen && self.kind === "refresh") causes.push(self);
+  for (let l = el._deps; l !== null; l = l._nextDep) {
+    const change = l._dep._devChange;
+    if (change !== undefined && change.seq > seen) causes.push(change);
+  }
+  return causes;
+}
+/** Advance the node's seen-cursor to the present. Call after every run. */
+function markSeen(el) {
+  el._devSeenSeq = changeSeq;
+}
+/**
+ * Snapshot the dep identities of the node's last pass (call before a run
+ * replaces them, or after it to read the fresh set). The validated prefix
+ * [`_deps`..`_depsTail`] is that pass's set; links past the tail are a
+ * previous pass's, kept linked while the frame they fed is still the
+ * committed one (A30 — a staged memo pass, or an effect pass whose run is
+ * still owed) and not part of the subscription diff.
+ */
+function captureDeps(el) {
+  const deps = [];
+  for (let l = el._deps; l !== null; l = l._nextDep) {
+    deps.push(l._dep);
+    if (l === el._depsTail) break;
+  }
+  return deps;
+}
+/**
+ * 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
+ * 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.
+ */
+function checkDepWidth(el) {
+  const limit = options.wideDeps;
+  if (limit === false) 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));
+    if (l === el._depsTail) break; // the validated prefix, as captureDeps
+  }
+  const node = el;
+  if (count < limit || count < (node._devWideWarnedAt ?? 0) * 1.5) return;
+  node._devWideWarnedAt = count;
+  const kind = el._type ? "effect" : "memo";
+  const message =
+    `[WIDE_SCOPE_DEPS] ${kind} "${nodeName(el)}" is subscribed to ${count} sources — ` +
+    `it re-runs when any of them change. Narrow its reads or split it into smaller memos. ` +
+    `Sources: ${names.join(", ")}${count > names.length ? ", …" : ""}`;
+  reportDiagnostic(
+    emitDiagnostic(
+      {
+        code: "WIDE_SCOPE_DEPS",
+        kind: "perf",
+        severity: "warn",
+        message,
+        nodeName: nodeName(el),
+        data: { depCount: count, deps: names }
+      },
+      el
+    )
+  );
+}
+const hotCauses = new Map();
+const HOT_FANOUT_FIRST_MILESTONE = 5;
+/**
+ * Hot-scope warning — flags a scope that re-ran more than `count` times
+ * inside one `windowMs` window. Warned once per window, with the most recent
+ * cause chain named so the leaking signal is identified in the message.
+ * Fan-out spam is folded per root cause (see HotCauseWindow above).
+ */
+function checkHotRuns(el, event) {
+  const cfg = options.hotRuns;
+  if (cfg === false) return;
+  const node = el;
+  const now = Date.now();
+  if (node._devWinStart === undefined || now - node._devWinStart > cfg.windowMs) {
+    node._devWinStart = now;
+    node._devWinCount = 0;
+    node._devHotWarned = false;
+  }
+  node._devWinCount = (node._devWinCount ?? 0) + 1;
+  if (node._devHotWarned || node._devWinCount < cfg.count) return;
+  node._devHotWarned = 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 roots = new Set();
+  rootsOf(event.causes, roots);
+  const causeKey = roots.size > 0 ? [...roots].sort().join(", ") : "(untracked)";
+  let window = hotCauses.get(causeKey);
+  if (window === undefined || now - window.winStart > cfg.windowMs) {
+    window = { winStart: now, scopes: 0, runs: 0, nextMilestone: HOT_FANOUT_FIRST_MILESTONE };
+    hotCauses.set(causeKey, window);
+  }
+  window.scopes++;
+  window.runs += node._devWinCount;
+  if (window.scopes === 1) {
+    const rootCause = event.causes.map(c => `"${c.name}" (${c.kind})`).join(", ");
+    const message =
+      `[HOT_SCOPE_RERUNS] ${event.nodeKind} "${event.nodeName}" re-ran ${node._devWinCount} times ` +
+      `in ${Math.max(1, now - node._devWinStart)}ms — a hot signal is likely leaking into this ` +
+      `scope. Latest cause: ${rootCause || "(untracked pull)"}`;
+    reportDiagnostic(
+      emitDiagnostic(
+        {
+          code: "HOT_SCOPE_RERUNS",
+          kind: "perf",
+          severity: "warn",
+          message,
+          nodeName: event.nodeName,
+          data: {
+            runs: node._devWinCount,
+            windowMs: cfg.windowMs,
+            causes: event.causes.map(c => c.name)
+          }
+        },
+        el
+      )
+    );
+    return;
+  }
+  // Additional scopes hot from the same cause: silent until a milestone —
+  // the culprit is the cause, and it has already been named once.
+  if (window.scopes < window.nextMilestone) return;
+  window.nextMilestone *= 10;
+  const message =
+    `[HOT_SCOPE_FANOUT] ${window.scopes} scopes have gone hot (${window.runs} re-runs) within ` +
+    `${cfg.windowMs}ms, all driven by ${causeKey} — one hot cause is re-running a large part ` +
+    `of the graph. Per-scope warnings are suppressed; fix the cause. If consumers ask keyed ` +
+    `questions of it, invert it: a store used as a map keyed by id, one key per consumer.`;
+  // The subject is the shared CAUSE, not this victim scope — no single owner
+  // path locates it, so the event carries none.
+  reportDiagnostic(
+    emitDiagnostic(
+      {
+        code: "HOT_SCOPE_FANOUT",
+        kind: "perf",
+        severity: "warn",
+        message,
+        nodeName: causeKey,
+        data: { cause: causeKey, scopes: window.scopes, runs: window.runs, windowMs: cfg.windowMs }
+      },
+      null
+    )
+  );
+}
+/**
+ * Time-budget warning — the counterpart of checkHotRuns for the
+ * few-but-expensive scope: warns when one scope's summed self-time within a
+ * window exceeds the budget. Warned once per window.
+ */
+function checkHotTime(el, event) {
+  const cfg = options.hotTime;
+  if (cfg === false) return;
+  const node = el;
+  const at = now();
+  if (node._devTimeWinStart === undefined || at - node._devTimeWinStart > cfg.windowMs) {
+    node._devTimeWinStart = at;
+    node._devTimeWinMs = 0;
+    node._devTimeWarned = false;
+  }
+  node._devTimeWinMs = (node._devTimeWinMs ?? 0) + event.selfMs;
+  if (node._devTimeWarned || node._devTimeWinMs < cfg.budgetMs) return;
+  node._devTimeWarned = true;
+  const rootCause = event.causes.map(c => `"${c.name}" (${c.kind})`).join(", ");
+  const message =
+    `[HOT_SCOPE_TIME] ${event.nodeKind} "${event.nodeName}" spent ` +
+    `${node._devTimeWinMs.toFixed(1)}ms of compute inside one ${cfg.windowMs}ms window ` +
+    `(budget ${cfg.budgetMs}ms). Latest cause: ${rootCause || "(untracked pull)"}`;
+  reportDiagnostic(
+    emitDiagnostic(
+      {
+        code: "HOT_SCOPE_TIME",
+        kind: "perf",
+        severity: "warn",
+        message,
+        nodeName: event.nodeName,
+        data: {
+          spentMs: node._devTimeWinMs,
+          budgetMs: cfg.budgetMs,
+          windowMs: cfg.windowMs,
+          causes: event.causes.map(c => c.name)
+        }
+      },
+      el
+    )
+  );
+}
+function recordRerun(el, frame, timing, changed, phase, held) {
+  const causes = frame.causes;
+  const prevDeps = frame.prevDeps;
+  const node = el;
+  const prevCauses = node._devRunCauses;
+  if (excludedNode(el)) {
+    // The observer's own computation: keep the per-node bookkeeping its
+    // effect phase reads (see effectRunStart) and record nothing.
+    node._devRunInteraction = frame.interaction;
+    node._devRunSeq = undefined;
+    node._devRunCauses = causes;
+    return;
+  }
+  // Subscription diff: `prevDeps` was captured at run entry; `_deps` now
+  // holds the fresh set. A changed set is the "helper edit changed distant
+  // call sites" signal — surfaced per-event and in the console format.
+  const newDeps = captureDeps(el);
+  const prevSet = new Set(prevDeps);
+  const newSet = new Set(newDeps);
+  const depsAdded = [];
+  const depsRemoved = [];
+  for (const d of newDeps) if (!prevSet.has(d)) depsAdded.push(nodeName(d));
+  for (const d of prevDeps) if (!newSet.has(d)) depsRemoved.push(nodeName(d));
+  const event = {
+    run: ++runSeq,
+    at: frame.start,
+    nodeRuns: (node._devRunCount = (node._devRunCount ?? 0) + 1),
+    nodeKind: el._type ? "effect" : "memo",
+    nodeName: nodeName(el),
+    nodeId: devId(el),
+    causes,
+    depCount: newDeps.length,
+    depsAdded,
+    depsRemoved,
+    selfMs: timing.selfMs,
+    totalMs: timing.totalMs,
+    changed,
+    phase,
+    held
+  };
+  const interaction = frame.interaction;
+  if (interaction !== undefined) event.interaction = interaction;
+  // The effect phase runs later in the flush with no cause list of its own:
+  // it inherits this run's interaction and is joined to this run's causes
+  // (see effectRunStart / pushFrame).
+  node._devRunInteraction = interaction;
+  node._devRunSeq = event.run;
+  node._devRunCauses = causes;
+  // The record is serializable and never carries the node; keep the node
+  // beside it for `OBSERVE.subjectOf` and the engine's own joins (effect
+  // cycles, relay tears, `why()`), for as long as anyone holds the record.
+  recordSubject(event, el);
+  history.push(event);
+  if (history.length > options.historyLimit) history.shift();
+  for (const f of folds) f.rerun?.(el, event);
+  noteInteractionRun(interaction, timing.selfMs, false);
+  if (event.nodeKind === "effect") checkEffectCycle(el, causes);
+  checkRelayTear(el, causes, prevCauses);
+  checkHotRuns(el, event);
+  checkHotTime(el, event);
+  checkDepWidth(el);
+  emitRecord("rerun", event);
+  if (options.log) logRerun(event);
+}
+function formatCause(cause, depth, out) {
+  const pad = "  ".repeat(depth + 1);
+  let line = `${pad}← ${cause.kind === "derived" ? "memo" : "signal"} "${cause.name}" ${cause.kind === "derived" ? "changed" : cause.kind} (#${cause.seq})`;
+  if (cause.prev !== undefined) line += ` ${cause.prev} → ${cause.value}`;
+  if (cause.origin !== undefined && cause.origin.kind !== "external") {
+    line += ` — ${formatOrigin(cause.origin)}`;
+    const under = cause.origin.interaction;
+    if (under !== undefined) line += ` (under ${formatOrigin(under)})`;
+  }
+  out.push(line);
+  if (cause.stack) for (const frame of cause.stack) out.push(`${pad}    ${frame}`);
+  if (cause.causes && depth < 10) {
+    for (const upstream of cause.causes) formatCause(upstream, depth + 1, out);
+  }
+}
+function formatRerun(event) {
+  const out = [
+    `[why-run] ${event.nodeKind} "${event.nodeName}" ran (run ${event.nodeRuns}, ` +
+      `${event.selfMs.toFixed(2)}ms${event.changed ? "" : ", unchanged"}` +
+      `${event.phase === "plain" ? "" : `, ${event.phase}`}${event.held ? ", held" : ""})` +
+      (event.causes.length === 0 ? " — no tracked cause (pull or retry)" : "")
+  ];
+  for (const cause of event.causes) formatCause(cause, 0, out);
+  if (event.depsAdded.length > 0 || event.depsRemoved.length > 0) {
+    const delta = [
+      ...event.depsAdded.map(n => `+"${n}"`),
+      ...event.depsRemoved.map(n => `-"${n}"`)
+    ].join(" ");
+    out.push(`  deps changed: ${delta} (${event.depCount} total)`);
+  }
+  return out.join("\n");
+}
+/**
+ * Console face of a re-run: the headline as a collapsed group with the
+ * why-chain and dep delta inside, so a busy console stays scannable (one line
+ * per run, evidence a click away). Consoles without grouping get the text.
+ */
+function logRerun(event) {
+  const text = formatRerun(event);
+  const nl = text.indexOf("\n");
+  if (nl === -1 || typeof console.groupCollapsed !== "function") {
+    console.log(text);
+    return;
+  }
+  console.groupCollapsed(text.slice(0, nl));
+  console.log(text.slice(nl + 1));
+  console.groupEnd();
+}
+/**
+ * Values eligible for the unstable-output check: plain objects and arrays
+ * only. Promises, iterators, Dates, Maps, class instances etc. all have no
+ * (or unrepresentative) own enumerable keys, so a shallow compare would
+ * false-positive on them — a fresh Promise is a genuinely new value.
+ */
+function isPlainShape(v) {
+  if (v === null || typeof v !== "object") return false;
+  if (Array.isArray(v)) return true;
+  const proto = Object.getPrototypeOf(v);
+  return proto === Object.prototype || proto === null;
+}
+/** Shallow structural equivalence, capped so hot paths stay cheap. */
+const UNSTABLE_KEY_CAP = 64;
+function shallowEquivalent(a, b) {
+  const aArr = Array.isArray(a);
+  if (aArr !== Array.isArray(b)) return false;
+  if (aArr) {
+    const arrA = a;
+    const arrB = b;
+    if (arrA.length !== arrB.length || arrA.length > UNSTABLE_KEY_CAP) return false;
+    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;
+  for (const key of keys) {
+    if (!(key in b) || a[key] !== b[key]) return false;
+  }
+  return true;
+}
+/**
+ * Unstable-output warning — the fan-out amplifier signature: a memo whose
+ * committed value is referentially new but structurally identical run after
+ * run has an equality gate that never closes, so ALL its subscribers re-run
+ * on EVERY upstream change. Checked only on plain (non-overlay) changed runs;
+ * a genuinely different value (or a non-plain shape) resets the streak.
+ */
+function checkUnstableOutput(el, prevValue, newValue) {
+  const limit = options.unstableMemos;
+  // typeof guard: an explicit `unstableMemos: undefined` in enable() options
+  // clobbers the default through the spread — treat any non-number as off.
+  if (typeof limit !== "number") return;
+  const node = el;
+  if (
+    prevValue === newValue || // paranoia: changed runs should never hit this
+    !isPlainShape(prevValue) ||
+    !isPlainShape(newValue) ||
+    !shallowEquivalent(prevValue, newValue)
+  ) {
+    node._devUnstableRuns = 0;
+    node._devUnstableWarned = false;
+    return;
+  }
+  node._devUnstableRuns = (node._devUnstableRuns ?? 0) + 1;
+  if (node._devUnstableWarned || node._devUnstableRuns < limit) return;
+  node._devUnstableWarned = true;
+  const shape = Array.isArray(newValue) ? "array" : "object";
+  const message =
+    `[UNSTABLE_MEMO_OUTPUT] memo "${nodeName(el)}" produced a new-but-equivalent ${shape} on ` +
+    `${node._devUnstableRuns} 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",
+        severity: "warn",
+        message,
+        nodeName: nodeName(el),
+        data: { runs: node._devUnstableRuns, shape }
+      },
+      el
+    )
+  );
+}
+const EFFECT_CYCLE_MAX_HOPS = 6;
+const reportedCycles = new Set();
+let nextDevId = 0;
+const devIds = new WeakMap();
+function devId(node) {
+  let id = devIds.get(node);
+  if (id === undefined) devIds.set(node, (id = ++nextDevId));
+  return id;
+}
+function rootWrites(causes, out) {
+  for (const c of causes) {
+    if (c.kind === "derived") {
+      if (c.causes !== undefined) rootWrites(c.causes, out);
+    } else out.push(c);
+  }
+}
+/**
+ * The effect writes leading from an earlier run of `target` to the run whose
+ * `causes` these are, in causal order (target's own write first), or null.
+ */
+function findEffectCycle(target, causes, visited, hops) {
+  const roots = [];
+  rootWrites(causes, roots);
+  for (const write of roots) {
+    const origin = write.origin;
+    if (origin === undefined || origin.kind !== "effect") continue;
+    const info = effectFrames.get(origin);
+    if (info === undefined) continue;
+    if (info.node === target) return [{ effect: info.node, write }];
+    if (hops >= EFFECT_CYCLE_MAX_HOPS || visited.has(info.node) || info.causes === undefined)
+      continue;
+    visited.add(info.node);
+    const rest = findEffectCycle(target, info.causes, visited, hops + 1);
+    if (rest !== null) {
+      rest.push({ effect: info.node, write });
+      return rest;
+    }
+  }
+  return null;
+}
+/** Names of the memos between a direct cause of a run and `write`, root-first. */
+function derivedPath(causes, write, path) {
+  for (const c of causes) {
+    if (c === write) return true;
+    if (c.kind === "derived" && c.causes !== undefined) {
+      path.unshift(c.name);
+      if (derivedPath(c.causes, write, path)) return true;
+      path.shift();
+    }
+  }
+  return false;
+}
+function describeWrite(write) {
+  if (write.kind === "refresh") return `refreshed "${write.name}"`;
+  const values = write.prev !== undefined ? ` (${write.prev} → ${write.value})` : "";
+  return `wrote "${write.name}"${values}`;
+}
+function checkEffectCycle(el, causes) {
+  const links = findEffectCycle(el, causes, new Set([el]), 0);
+  if (links === null) return;
+  const key = links
+    .map(link => devId(link.effect))
+    .sort((a, b) => a - b)
+    .join(",");
+  if (reportedCycles.has(key)) return;
+  reportedCycles.add(key);
+  const flushes = links.length + 1;
+  let message;
+  if (links.length === 1) {
+    const [{ write }] = links;
+    const path = [];
+    derivedPath(causes, write, path);
+    const via = path.length > 0 ? ` through ${path.map(n => `memo "${n}"`).join(" → ")}` : "";
+    message =
+      `[EFFECT_WRITES_OWN_SOURCE] effect "${nodeName(el)}" re-ran because of its own write: it ` +
+      `${describeWrite(write)}, which fed back into its inputs${via}. Two flushes to settle, ` +
+      `and the screen rendered the pre-write value in between. The written value is a function ` +
+      `of what the effect reads — compute it in a memo (or normalize where the source is ` +
+      `written) instead of correcting it after the fact.`;
+  } else {
+    const names = links.map(link => `"${nodeName(link.effect)}"`);
+    const steps = links
+      .map(
+        (link, i) => `effect ${names[i]}${i > 0 ? " re-ran and" : ""} ${describeWrite(link.write)}`
+      )
+      .join("; ");
+    message =
+      `[EFFECT_WRITES_OWN_SOURCE] effects ${[...names, names[0]].join(" → ")} relay writes in a ` +
+      `cycle: ${steps}; which fed back into effect ${names[0]}'s inputs — ${flushes} flushes to ` +
+      `settle after each change, each rendering an intermediate state. Every relayed value is a ` +
+      `function of the original inputs: derive them in memos and drop the writes.`;
+  }
+  const severity = links.length === 1 ? "warn" : "info";
+  const entry = emitDiagnostic(
+    {
+      code: "EFFECT_WRITES_OWN_SOURCE",
+      kind: "perf",
+      severity,
+      message,
+      nodeName: nodeName(el),
+      data: {
+        effects: links.map(link => nodeName(link.effect)),
+        writes: links.map(link => ({
+          effect: nodeName(link.effect),
+          kind: link.write.kind,
+          name: link.write.name,
+          prev: link.write.prev,
+          value: link.write.value
+        })),
+        flushes
+      }
+    },
+    el
+  );
+  if (severity === "warn") reportDiagnostic(entry);
+}
+const RELAY_WARN_AT = 3;
+const relays = new Map();
+const copyWrites = new WeakSet();
+const copyReported = new WeakSet();
+/** The node each root write record was stamped on (records are serializable and cannot hold it). */
+const recordNodes = new WeakMap();
+/**
+ * Write-side bookkeeping for the relay heuristics: who has written this
+ * signal, and whether an effect just copied its compute output into it.
+ */
+function trackEffectWrite(node, record, value) {
+  const n = node;
+  const origin = record.origin;
+  const info =
+    origin !== undefined && origin.kind === "effect" ? effectFrames.get(origin) : undefined;
+  const writer = info === undefined ? 0 : devId(info.node);
+  recordNodes.set(record, node);
+  n._devSoleWriter = n._devSoleWriter === undefined || n._devSoleWriter === writer ? writer : null;
+  if (info !== undefined && value !== undefined && value === info.node._value) {
+    copyWrites.add(record);
+    n._devCopyRuns = n._devCopyFrom === writer ? (n._devCopyRuns ?? 0) + 1 : 1;
+    n._devCopyFrom = writer;
+    if (n._devCopyRuns >= 2 && n._devSoleWriter === writer) checkCopyEffect(info.node, node);
+  } else n._devCopyRuns = 0;
+}
+/** The effect's source whose current value the compute output is, if any (the prop-to-state port). */
+function passthroughSource(effect) {
+  for (let l = effect._deps; l !== null; l = l._nextDep)
+    if (l._dep._value === effect._value) return nodeName(l._dep);
+  return undefined;
+}
+/** The repair for a write that is the effect's compute output. */
+function copyRepair(effect, target) {
+  const source = passthroughSource(effect);
+  return source !== undefined
+    ? `The written value is "${source}" itself: read "${source}" where "${target}" is read ` +
+        `(or createMemo it if a stable derivation is needed) and delete the effect.`
+    : `The written value is the effect's compute output — by contract a pure function of ` +
+        `what it tracks: make "${target}" a memo of that computation and delete the effect.`;
+}
+function checkCopyEffect(effect, target) {
+  if (copyReported.has(target)) return;
+  copyReported.add(target);
+  const name = nodeName(target);
+  const message =
+    `[EFFECT_RELAY_TEAR] effect "${nodeName(effect)}" writes its compute output into ` +
+    `"${name}" on every run, and nothing else writes "${name}" — it is derived state kept ` +
+    `one flush late: everything reading it paints a frame behind everything reading the ` +
+    `source. ${copyRepair(effect, name)}`;
+  reportDiagnostic(
+    emitDiagnostic(
+      {
+        code: "EFFECT_RELAY_TEAR",
+        kind: "perf",
+        severity: "warn",
+        message,
+        nodeName: nodeName(effect),
+        data: {
+          relay: nodeName(effect),
+          wrote: name,
+          copy: true,
+          passthrough: passthroughSource(effect) ?? null,
+          soleWriter: true
+        }
+      },
+      effect
+    )
+  );
+}
+/**
+ * `victim` re-ran with `causes`; its previous run had `prevCauses`. A tear is
+ * a re-run whose root writes ALL came from effects (no independent outside
+ * cause) and at least one of which was made by a run that shares a root
+ * write with the victim's previous run.
+ */
+function checkRelayTear(victim, causes, prevCauses) {
+  if (prevCauses === undefined || causes.length === 0) return;
+  const roots = [];
+  rootWrites(causes, roots);
+  if (roots.length === 0) return;
+  let relay;
+  let write;
+  let shared;
+  for (const root of roots) {
+    const origin = root.origin;
+    if (origin === undefined || origin.kind !== "effect") return;
+    const info = effectFrames.get(origin);
+    // Own-source cycles are EFFECT_WRITES_OWN_SOURCE's; a create-run relay
+    // is initial sync, not a tear for one change.
+    if (info === undefined || info.node === victim || info.causes === undefined) return;
+    if (shared === undefined) {
+      const relayRoots = [];
+      rootWrites(info.causes, relayRoots);
+      const prevRoots = [];
+      rootWrites(prevCauses, prevRoots);
+      const hit = relayRoots.find(r => prevRoots.includes(r));
+      if (hit !== undefined) {
+        shared = hit;
+        relay = info;
+        write = root;
+      }
+    }
+  }
+  if (shared === undefined || relay === undefined || write === undefined) return;
+  const key = `${devId(relay.node)}:${write.name}`;
+  let state = relays.get(key);
+  if (state === undefined) relays.set(key, (state = { count: 0, warned: false }));
+  state.count++;
+  const copy = copyWrites.has(write);
+  const target = recordNodes.get(write);
+  const soleWriter = target !== undefined && target._devSoleWriter === devId(relay.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
+  // is not the answer, so it stays advisory like any other non-derivable tear.
+  const derivable = copy && soleWriter;
+  const severity = derivable || state.count >= RELAY_WARN_AT ? "warn" : "info";
+  // First sighting always reports (advisory); afterwards only the escalation.
+  if (state.count > 1 && (severity !== "warn" || state.warned)) return;
+  // One verdict per derivable signal: the copy report (checkCopyEffect) and
+  // the tear report carry the same repair.
+  if (derivable && target !== undefined) {
+    if (copyReported.has(target)) return;
+    copyReported.add(target);
+  }
+  if (severity === "warn") state.warned = true;
+  const victimKind = victim._type ? "effect" : "memo";
+  const relayName = nodeName(relay.node);
+  const repair = derivable
+    ? copyRepair(relay.node, write.name)
+    : copy
+      ? `The written value is the effect's compute output, but "${write.name}" has other ` +
+        `writers — editable state reset from a source. If the reset is the intent, the tear ` +
+        `is its cost; if "${write.name}" only ever mirrors the source, drop the local copy ` +
+        `and read the source.`
+      : soleWriter
+        ? `Nothing else writes "${write.name}" — it is derived state: make it a memo over what ` +
+          `the effect reads and every reader gets it in the same flush.`
+        : `If "${write.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 message =
+    `[EFFECT_RELAY_TEAR] ${victimKind} "${nodeName(victim)}" ran twice for one write of ` +
+    `"${shared.name}": once in the flush where "${shared.name}" changed, and again after ` +
+    `effect "${relayName}" relayed it by writing "${write.name}" — the first frame showed the ` +
+    `new "${shared.name}" with the stale "${write.name}"` +
+    (state.count > 1 ? ` (${state.count} times so far)` : "") +
+    `. ${repair}`;
+  const entry = emitDiagnostic(
+    {
+      code: "EFFECT_RELAY_TEAR",
+      kind: "perf",
+      severity,
+      message,
+      nodeName: nodeName(victim),
+      data: {
+        victim: nodeName(victim),
+        root: shared.name,
+        relay: relayName,
+        wrote: write.name,
+        copy,
+        passthrough: copy ? (passthroughSource(relay.node) ?? null) : null,
+        soleWriter,
+        occurrences: state.count
+      }
+    },
+    victim
+  );
+  if (severity === "warn") reportDiagnostic(entry);
+}
+// --- Immutable updates in stores ---------------------------------------------
+//
+// `draft.user = { ...draft.user, name }` / `draft.items = [...draft.items,
+// x]` / `draft.items = draft.items.filter(...)` — the React habit of
+// producing a fresh container to change one leaf. The store tracks leaves, so
+// a fresh container is pure cost: every reader of `user` (any path below it)
+// re-runs for the one leaf that moved, where a draft mutation would re-run
+// only the readers of `name`. The store's notify sees both containers at the
+// write and reports a leaf census (identity on unwrapped values, capped); the
+// verdict is the whole detector: a replacement whose leaves are mostly the
+// SAME values is a spread-copy, and one whose leaves are mostly different is
+// new data (reconcile's job — and UNSTABLE_LIST_IDENTITY's, downstream). Once
+// per store path.
+const immutableReported = new Set();
+function checkImmutableUpdate(path, isArray, total, same, prevTotal, owner) {
+  if (immutableReported.has(path) || total < 2) return;
+  // Push/filter/splice copies change the length by a little; a wholesale
+  // resize is a different operation even if some items survive.
+  if (isArray && Math.abs(prevTotal - total) > Math.max(1, total >> 2)) return;
+  // At least half the leaves carried over unchanged, and at least one did.
+  if (same === 0 || same * 2 < total) return;
+  const changed = total - same;
+  const shape = isArray ? "array" : "object";
+  const repair = isArray
+    ? `mutate the draft in place (push/splice/index assignment) so only the touched ` +
+      `indices notify`
+    : `assign the leaf on the draft (\`${path}.<key> = …\`) so only readers of that key re-run`;
+  const message =
+    `[IMMUTABLE_UPDATE_IN_STORE] "${path}" was replaced with a fresh ${shape} whose ` +
+    `${isArray ? "items" : "leaves"} are mostly the same values (${same} of ${total} unchanged` +
+    `${changed > 0 ? `, ${changed} changed` : ""}) — a spread-copy update. The store already ` +
+    `tracks ${isArray ? "items" : "leaves"}; a new container makes every reader of "${path}" ` +
+    `re-run for the ${changed === 1 ? "one that" : "few that"} moved. Instead, ${repair}. For ` +
+    `data arriving from outside (a fetch result), merge it with reconcile(data, key)(${path}).`;
+  // The subject is the store's own owner, not the writer's context: the
+  // finding is about the store, and its writes legitimately arrive from
+  // outside the graph (an event handler, an adapter). Falls back to the
+  // ambient context (emitDiagnostic's default) when the store recorded none.
+  const entry = emitDiagnostic(
+    {
+      code: "IMMUTABLE_UPDATE_IN_STORE",
+      kind: "perf",
+      severity: "warn",
+      message,
+      nodeName: path,
+      data: { path, shape, total, unchanged: same, changed }
+    },
+    owner
+  );
+  // Paths are not unique across stores: an excluded owner's store (an
+  // adapter's own "store.list") must not spend the app's once-per-path slot.
+  if (isSuppressed(entry)) return;
+  immutableReported.add(path);
+  reportDiagnostic(entry);
+}
+// --- Unstable list identity -----------------------------------------------------
+//
+// `<For>` keyed by identity (the default) treats every new object as a new
+// row. When a re-fetch hands back fresh objects for the same records, or a
+// spread-copy rebuilds the array, most rows are disposed and recreated —
+// DOM, state, focus, and all — for data that did not change. mapArray knows
+// exactly which items exited and entered; pairing them (by `id` when the
+// items carry one, else by position) and sampling shallow equivalence turns
+// that into a verdict: churn that replaced equivalent records is unstable
+// identity, not a new list. A key function that still churns has the same
+// disease one level up (its keys are not stable). Once per list.
+const LIST_CHURN_SAMPLE = 8;
+const listIdentityWarned = new WeakSet();
+function recordId(item) {
+  if (item === null || typeof item !== "object") return undefined;
+  const o = item;
+  return o.id ?? o.key ?? o._id ?? undefined;
+}
+function checkListIdentity(el, removed, created, newLen, keyed) {
+  if (listIdentityWarned.has(el)) return;
+  // Most of the list turned over, and the turnover was a swap (rows out ≈ rows in).
+  if (created.length < 2 || created.length * 2 < newLen) return;
+  if (Math.abs(removed.length - created.length) > Math.max(1, created.length >> 2)) return;
+  // Pair exited with entered: by record id when present, else by position.
+  const byId = new Map();
+  for (const item of removed) {
+    const id = recordId(item);
+    if (id !== undefined) byId.set(id, item);
+  }
+  let sampled = 0;
+  let equivalent = 0;
+  const step = Math.max(1, Math.floor(created.length / LIST_CHURN_SAMPLE));
+  for (let i = 0; i < created.length && sampled < LIST_CHURN_SAMPLE; i += step) {
+    const item = created[i];
+    const id = recordId(item);
+    const prev = id !== undefined ? byId.get(id) : removed[i];
+    if (prev === undefined || !isPlainShape(prev) || !isPlainShape(item)) continue;
+    sampled++;
+    if (shallowEquivalent(prev, item)) equivalent++;
+  }
+  if (sampled === 0 || equivalent * 2 < sampled) return;
+  listIdentityWarned.add(el);
+  const name = nodeName(el);
+  const repair = keyed
+    ? `The key function returned different keys for equivalent records — return a stable ` +
+      `field (\`keyed: item => item.id\`), not the object or a computed value that changes ` +
+      `with the fetch.`
+    : `Key the list by a stable field (\`keyed: item => item.id\`), or merge the data into ` +
+      `a store with reconcile(data, "id") so the same records keep the same identity.`;
+  const message =
+    `[UNSTABLE_LIST_IDENTITY] list "${name}" recreated ${created.length} of ${newLen} rows on ` +
+    `an update where the entering items are equivalent to the ones they replaced ` +
+    `(${equivalent} of ${sampled} sampled pairs identical field-for-field) — fresh objects ` +
+    `for the same records, so identity keying threw away every row's DOM and state and ` +
+    `rebuilt it. ${repair}`;
+  reportDiagnostic(
+    emitDiagnostic(
+      {
+        code: "UNSTABLE_LIST_IDENTITY",
+        kind: "perf",
+        severity: "warn",
+        message,
+        nodeName: name,
+        data: {
+          removed: removed.length,
+          created: created.length,
+          length: newLen,
+          sampled,
+          equivalent,
+          keyed
+        }
+      },
+      el
+    )
+  );
+}
+/** Provenance of an async landing: the flight, under the interaction that started it. */
+function asyncOrigin(el) {
+  const origin = { kind: "async", name: nodeName(el) };
+  const interaction = liveFlights.get(el)?.interaction;
+  if (interaction !== undefined) origin.interaction = interaction;
+  return origin;
+}
+// WeakMaps: an errored/abandoned flight must not leak its node or block GC.
+const liveFlights = new WeakMap();
+const landedFlights = new WeakMap();
+/**
+ * Flight-object identity → earliest known start. Fed by markFlight() (the
+ * cooperative preload/cache declaration — populated even while attribution
+ * is disabled, so navigation-time marks survive a later enable()) and by
+ * first sightings at registration.
+ */
+const flightOrigins = new WeakMap();
+let waterfallLog = [];
+/** Deepest landed-flight cause reachable through a cause list (derived links included). */
+function flightCauseIn(causes) {
+  let best = null;
+  for (const c of causes) {
+    let found = null;
+    if (c.kind === "async") found = landedFlights.get(c) ?? null;
+    else if (c.kind === "derived" && c.causes) found = flightCauseIn(c.causes);
+    if (found !== null && (best === null || found.chain.length > best.chain.length)) best = found;
+  }
+  return best;
+}
+function trackFlightStart(el, flight) {
+  const at = now();
+  const origin = flightOrigins.get(flight) ?? at;
+  if (origin === at) flightOrigins.set(flight, at);
+  // Census: a flight still in the air when the node starts another was
+  // superseded — its answer will be discarded.
+  for (const f of folds) f.flightStart?.(el, liveFlights.has(el));
+  // Nearest enclosing frame with causes: create runs carry null (a node born
+  // inside a parent's recompute inherits the parent's causality — the
+  // boundary-reveal case, and the lazy sibling whose first pull is gated
+  // behind an earlier not-ready read), so walk down to the first re-run frame.
+  let causes = null;
+  for (let i = frames.length - 1; i >= 0; i--) {
+    if (frames[i].causes !== null) {
+      causes = frames[i].causes;
+      break;
+    }
+  }
+  const live = { origin, startSeq: changeSeq, chain: [] };
+  // Provenance: the flight belongs to whatever interaction caused the
+  // recompute that started it (a create run under a click's handler — a
+  // freshly mounted async node — inherits the ambient interaction instead).
+  const interaction = causes !== null ? interactionIn(causes) : (currentInteraction ?? undefined);
+  if (interaction !== undefined) live.interaction = interaction;
+  if (options.waterfalls !== false && causes !== null) {
+    let parent = flightCauseIn(causes);
+    // The sequentiality test. A marked/previously-seen flight whose origin
+    // predates the upstream landing was in the air alongside it: parallel.
+    if (parent !== null && origin < parent.landedAt) parent = null;
+    if (parent !== null) live.chain = [...parent.chain, { name: parent.name, ms: parent.ms }];
+  }
+  liveFlights.set(el, live);
+}
+/**
+ * Flight landed (whether or not the value committed — the wall time was
+ * spent either way). Attach the measurement to the landing's fresh "async"
+ * stamp so downstream flights can chain through it, then judge the chain.
+ */
+function finalizeFlight(el) {
+  const flight = liveFlights.get(el);
+  if (flight === undefined) return;
+  liveFlights.delete(el);
+  const landedAt = now();
+  const ms = landedAt - flight.origin;
+  for (const f of folds) f.flightLanded?.(el, ms);
+  const record = el._devChange;
+  // Only a stamp this landing produced may carry the measurement — a stale
+  // async record from a previous landing must not be re-labeled.
+  if (record !== undefined && record.kind === "async" && record.seq > flight.startSeq)
+    landedFlights.set(record, { name: nodeName(el), ms, chain: flight.chain, landedAt });
+  checkWaterfall(el, flight.chain, ms);
+}
+function checkWaterfall(el, chain, ms) {
+  const cfg = options.waterfalls;
+  if (cfg === false) return;
+  if (chain.length > 0) {
+    waterfallLog.push({
+      chain: [...chain, { name: nodeName(el), ms }],
+      sequentialMs: chain.reduce((sum, l) => sum + l.ms, ms)
+    });
+    if (waterfallLog.length > options.historyLimit) waterfallLog.shift();
+  }
+  // The verdict: trailing run of links that were each a real wait. A fast
+  // tail (settled preload/cache hit) or a fast upstream breaks the sequence.
+  if (ms < cfg.minFlightMs) return;
+  let seq = 1;
+  let totalMs = ms;
+  for (let i = chain.length - 1; i >= 0 && chain[i].ms >= cfg.minFlightMs; i--) {
+    seq++;
+    totalMs += chain[i].ms;
+  }
+  if (seq < 2) return;
+  const node = el;
+  if ((node._devWaterfallWarnedAt ?? 0) >= seq) return;
+  node._devWaterfallWarnedAt = seq;
+  const links = [...chain.slice(chain.length - (seq - 1)), { name: nodeName(el), ms }];
+  const path = links.map(l => `"${l.name}" (${l.ms.toFixed(0)}ms)`).join(" → ");
+  const message =
+    `[ASYNC_WATERFALL] ${seq} sequential async flights — ${path} — ` +
+    `${totalMs.toFixed(0)}ms serialized: each began only after the previous resolved ` +
+    `(as far as this graph can see). If a later request doesn't need the earlier ` +
+    `response, derive both from the same inputs so they start together; if the ` +
+    `dependency is intrinsic, preload the dependent data or join the requests ` +
+    `server-side. If this work WAS already started elsewhere (a preloader or request ` +
+    `cache), have that layer stamp its promises with attribution.markFlight() ` +
+    `from "@solidjs/signals/attribution".`;
+  // Depth 2 is advisory-only (structured consumers see it; the console does
+  // not): a 2-chain can be an intrinsic data dependency or an unmarked
+  // preload. A 3+ chain that survived the origin test is near-certainly
+  // structural — that one earns the console.
+  const severity = seq > 2 ? "warn" : "info";
+  const entry = emitDiagnostic(
+    {
+      code: "ASYNC_WATERFALL",
+      kind: "perf",
+      severity,
+      message,
+      nodeName: nodeName(el),
+      data: { chain: links.map(l => ({ name: l.name, ms: l.ms })), sequentialMs: totalMs }
+    },
+    el
+  );
+  if (severity === "warn") reportDiagnostic(entry);
+}
+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. */
+function isCompanion(node) {
+  return (
+    (!!node._x && node._x._parentSource !== undefined) ||
+    (node._config & CONFIG_DERIVED_OVERRIDE) !== 0
+  );
+}
+const HOLD_CENSUS_CAP = 10_000;
+function acknowledge(state, kind, source, reader) {
+  const key = `${kind}:${source}`;
+  const existing = state.acknowledgements.get(key);
+  const path = reader !== null ? ownerPath(reader) : undefined;
+  // A later census (a merged transition, the settle pass) may find the
+  // reader an earlier one missed.
+  if (existing === undefined)
+    state.acknowledgements.set(
+      key,
+      path !== undefined ? { kind, source, reader: path } : { kind, source }
+    );
+  else if (path !== undefined) existing.reader ??= path;
+}
+function censusRegistrations(t, state) {
+  const budget = { left: HOLD_CENSUS_CAP };
+  for (const node of t._optimisticNodes)
+    if (!isCompanion(node))
+      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));
+}
+/**
+ * Does anything that paints read `companion` — an effect, through however many
+ * memos? A subscriber alone is not acknowledgement: memos compute eagerly, so a
+ * router's `createMemo(() => isPending(location))` subscribes to the companion
+ * whether or not the app ever renders the memo. Only an effect is the screen.
+ * Returns the first effect found (the reader), or null.
+ */
+function reachesEffect(companion, budget) {
+  const seen = new Set([companion]);
+  const stack = [companion];
+  while (stack.length > 0 && budget.left-- > 0) {
+    const node = stack.pop();
+    for (let s = node._subs; s !== null; s = s._nextSub) {
+      const sub = s._sub;
+      if (sub._type) return sub;
+      if (!seen.has(sub)) {
+        seen.add(sub);
+        stack.push(sub);
+      }
+    }
+  }
+  return null;
+}
+/** Companions an effect reads, anywhere downstream of the hold's nodes. */
+function censusCompanions(roots, state) {
+  const visited = new Set();
+  const stack = [...roots];
+  const budget = { left: HOLD_CENSUS_CAP };
+  while (stack.length > 0 && visited.size < HOLD_CENSUS_CAP) {
+    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) stack.push(s._sub);
+  }
+}
+function holdState(t) {
+  let state = holdStates.get(t);
+  if (state === undefined) {
+    state = {
+      start: now(),
+      flushes: 0,
+      blockers: new Set(),
+      acknowledgements: new Map(),
+      painted: 0,
+      action: false
+    };
+    holdStates.set(t, state);
+  }
+  return state;
+}
+function trackHoldStart(t) {
+  // Navigations and interactions learn they are held regardless of hold
+  // tracking: their settle must wait for the transition either way (see flushEnd).
+  markNavigationsHeld(t);
+  markInteractionsHeld(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);
+  censusRegistrations(t, state);
+  activeHold = state;
+}
+function trackHoldMerge(target, outgoing) {
+  mergeInteractionsHeld(target, outgoing);
+  const from = holdStates.get(outgoing);
+  if (from === undefined) return;
+  holdStates.delete(outgoing);
+  const into = holdState(target);
+  if (from.start < into.start) into.start = from.start;
+  into.flushes += from.flushes;
+  into.painted += from.painted;
+  into.action ||= from.action;
+  for (const b of from.blockers) into.blockers.add(b);
+  for (const [key, a] of from.acknowledgements)
+    if (!into.acknowledgements.has(key)) into.acknowledgements.set(key, a);
+}
+function trackHoldSettled(t) {
+  const state = holdStates.get(t);
+  if (state === undefined) {
+    // No hold was recorded (the transition completed in its first flush, or
+    // hold tracking is off): navigations and interactions staged in it still
+    // settle here.
+    settleNavigations(t, undefined);
+    settleInteractionsHeld(t, undefined);
+    return;
+  }
+  holdStates.delete(t);
+  // Root writes only: a memo in _pendingNodes is a derived hold, and the
+  // question is whether the USER's input went unanswered.
+  const heldWrites = [];
+  let subject = null;
+  let interaction;
+  let origin;
+  let lastJoinAt = -Infinity;
+  for (const node of t._pendingNodes) {
+    if (typeof node._fn === "function" || isCompanion(node)) continue;
+    const change = node._devChange;
+    if (change === undefined || change.kind !== "write") continue;
+    if (subject === null) subject = node;
+    const held = { name: nodeName(node), prev: change.prev, value: change.value };
+    if (change.origin !== undefined) held.origin = change.origin;
+    heldWrites.push(held);
+    // Earliest interaction among the held writes: the user has been waiting
+    // since the first thing they did that this transaction is holding.
+    const under = interactionOf(change.origin);
+    if (under !== undefined && (interaction === undefined || under.at < interaction.at))
+      interaction = under;
+    // The declared frame the writes belong to — earliest navigation, by the
+    // same reasoning.
+    if (
+      change.origin?.kind === "navigation" &&
+      (origin === undefined || change.origin.at < origin.at)
+    )
+      origin = change.origin;
+    // Latest write: a signal written twice while held carries the later
+    // stamp, so this is the user's final input, not their first.
+    if (change.at !== undefined && change.at > lastJoinAt) lastJoinAt = change.at;
+  }
+  if (heldWrites.length === 0) {
+    settleNavigations(t, undefined);
+    settleInteractionsHeld(t, undefined);
+    return;
+  }
+  censusRegistrations(t, state);
+  censusCompanions([...t._pendingNodes, ...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
+  // latest record, so the surviving interaction may be a later one — the
+  // flush clock keeps the first wait from being forgotten.
+  const at = Math.min(state.start, interaction !== undefined ? interaction.at : Infinity);
+  const holdMs = end - at;
+  const event = {
+    at,
+    holdMs,
+    tailMs: lastJoinAt === -Infinity ? holdMs : Math.min(holdMs, end - lastJoinAt),
+    flushes: state.flushes,
+    heldWrites,
+    blockers: [...state.blockers].map(nodeName),
+    acknowledgements: [...state.acknowledgements.values()],
+    paintedDuringHold: state.painted,
+    action: state.action
+  };
+  if (interaction !== undefined) event.interaction = interaction;
+  if (origin !== undefined) event.origin = origin;
+  holdLog.push(event);
+  if (holdLog.length > options.historyLimit) holdLog.shift();
+  // Bottom-up delivery: the hold, then the navigations it held, then the
+  // interactions those belong to — each record complete when its parent is.
+  emitRecord("hold", event);
+  settleNavigations(t, event);
+  settleInteractionsHeld(t, event);
+  for (const f of folds) f.hold?.(event);
+  if (isSilentHold(event)) checkSilentHold(event, subject);
+  else checkLongHold(event, subject);
+}
+/** `isLongHold` — the tail outlasted `longHolds.infoMs`. */
+/** @internal */
+function isLongHold(event) {
+  const cfg = options.longHolds;
+  return cfg !== false && cfg !== undefined && event.tailMs >= cfg.infoMs;
+}
+function describeHeldWrites(event) {
+  return event.heldWrites
+    .map(w => (w.prev !== undefined ? `"${w.name}" (${w.prev} → ${w.value})` : `"${w.name}"`))
+    .join(", ");
+}
+function describeBlockers(event, lead) {
+  return event.blockers.length > 0
+    ? ` ${lead} ${event.blockers.map(b => `"${b}"`).join(", ")}`
+    : "";
+}
+/**
+ * The boundary repair, shared by LONG_HOLD and a long SILENT_HOLD: a wait
+ * this long should show a fallback, not a stale screen. A `Loading` boundary
+ * lifts the write out of the hold only when it has not revealed yet or its
+ * `on` prop changed — a revealed boundary with no `on` IS the stale screen.
+ */
+function boundaryRepair(event) {
+  const key = event.heldWrites[0]?.name ?? "key";
+  return (
+    `A wait this long is past what a stale screen should carry: show a fallback instead. Put ` +
+    `the reader behind a Loading boundary keyed on what changed — <Loading on={${key}()} ` +
+    `fallback={…}> — so the write commits at once and the fallback shows where the data lands; ` +
+    `a boundary that has already revealed keeps the old content unless \`on\` changes. If the ` +
+    `data itself is the problem, preload it or cache it so the wait never gets this long.`
+  );
+}
+function holdData(event) {
+  const data = {
+    holdMs: event.holdMs,
+    tailMs: event.tailMs,
+    flushes: event.flushes,
+    heldWrites: event.heldWrites.map(w => w.name),
+    blockers: event.blockers,
+    action: event.action
+  };
+  if (event.interaction !== undefined)
+    data.interaction = { type: event.interaction.name, target: event.interaction.target };
+  if (event.origin?.kind === "navigation") data.navigation = navigationData(event.origin);
+  return data;
+}
+/**
+ * Who the verdict sentence starts from: the interaction, with the navigation
+ * it performed in parentheses — `click on a.nav (navigation to /users/:id)`;
+ * the navigation alone when nothing user-dispatched is known (a redirect);
+ * empty when neither is.
+ */
+function holdActor(event) {
+  const via = event.origin !== undefined ? formatOrigin(event.origin) : "";
+  if (event.interaction !== undefined)
+    return `${formatOrigin(event.interaction)}${via ? ` (${via})` : ""}`;
+  return via;
+}
+function checkSilentHold(event, subject) {
+  const cfg = options.holds;
+  if (cfg === false) return;
+  if (event.holdMs < cfg.infoMs) return;
+  const ms = event.holdMs.toFixed(0);
+  const writes = describeHeldWrites(event);
+  const waitedOn = describeBlockers(event, "waiting on");
+  // With the interaction (or navigation) stamped the sentence starts from
+  // what the user did; without it, from the writes.
+  const actor = holdActor(event);
+  const who = actor ? `${actor} ` : "";
+  let message = event.action
+    ? `[SILENT_HOLD] ${who}${who ? "started an action that" : "an action"} held ${writes} for ` +
+      `${ms}ms${waitedOn} and the screen showed nothing for the whole round-trip: no optimistic ` +
+      `value, no isPending() reader, no affects() mark, and no effect ran while it was held. ` +
+      `Pair the action with a createOptimistic/createOptimisticStore write for the expected ` +
+      `outcome (it reverts on failure), or co-write a createOptimistic(false) "saving" flag ` +
+      `the UI reads.`
+    : `[SILENT_HOLD] ${who}${who ? "wrote" : "writes to"} ${writes}${who ? "; the write was" : " were"} ` +
+      `held ${ms}ms${waitedOn} and the screen showed nothing for the wait: no ` +
+      `isPending()/latest() reader downstream, no optimistic value, no affects() mark, and no ` +
+      `effect ran while it was held — the interaction was dead for ${ms}ms. Show the wait: ` +
+      `read isPending(() => ${event.blockers[0] ?? "source"}()) to render a busy state, or ` +
+      `latest(${event.heldWrites[0].name}) to reveal the new input immediately while the data ` +
+      `catches up. The hold itself is correct — do not "fix" this by moving the write off the ` +
+      `async path.`;
+  const long = isLongHold(event);
+  if (long) message += ` ${boundaryRepair(event)}`;
+  const severity = event.holdMs >= cfg.warnMs ? "warn" : "info";
+  const data = holdData(event);
+  data.long = long;
+  const entry = emitDiagnostic(
+    {
+      code: "SILENT_HOLD",
+      kind: "responsiveness",
+      severity,
+      message,
+      nodeName: nodeName(subject),
+      data
+    },
+    subject
+  );
+  if (severity === "warn") reportDiagnostic(entry);
+}
+function checkLongHold(event, subject) {
+  const cfg = options.longHolds;
+  if (cfg === false || cfg === undefined) return;
+  if (event.tailMs < cfg.infoMs) return;
+  const tail = event.tailMs.toFixed(0);
+  const writes = describeHeldWrites(event);
+  const waitedOn = describeBlockers(event, "waiting on");
+  const actor = holdActor(event);
+  const who = actor ? `${actor} ` : "";
+  const answered =
+    event.acknowledgements.length > 0
+      ? `${event.acknowledgements.map(a => `"${a.kind}:${a.source}"`).join(", ")} said it was pending`
+      : `an effect painted meanwhile`;
+  const sinceLast =
+    event.tailMs < event.holdMs - 1
+      ? ` after the last input (${event.holdMs.toFixed(0)}ms in all)`
+      : "";
+  const message =
+    `[LONG_HOLD] ${who}${who ? "wrote" : "writes to"} ${writes}; the screen kept the old ` +
+    `content for ${tail}ms${sinceLast}${waitedOn} — ${answered}, but the hold ran on well past ` +
+    `the point where "loading" over stale content reads as broken. ${boundaryRepair(event)}`;
+  const severity = event.tailMs >= cfg.warnMs ? "warn" : "info";
+  const data = holdData(event);
+  data.acknowledgements = event.acknowledgements;
+  const entry = emitDiagnostic(
+    {
+      code: "LONG_HOLD",
+      kind: "responsiveness",
+      severity,
+      message,
+      nodeName: nodeName(subject),
+      data
+    },
+    subject
+  );
+  if (severity === "warn") reportDiagnostic(entry);
+}
+const navStates = new WeakMap();
+/** Opened, not yet settled. */
+const openNavs = new Set();
+let navigationLog = [];
+/** Drains completed since enable() — the clock `writeDrain` reads. */
+let drainSeq = 0;
+/**
+ * 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
+ * redirect re-describes it, and when the record settles, so a description
+ * refined during the hold is what every consumer ends up reading.
+ */
+function syncNavigation(state) {
+  const { event, ref } = state;
+  const frame = event.origin;
+  if (ref.name === undefined) {
+    delete frame.name;
+    delete event.name;
+  } else frame.name = event.name = ref.name;
+  if (ref.to === undefined) {
+    delete frame.to;
+    delete event.to;
+  } else frame.to = event.to = ref.to;
+  if (ref.params === undefined) {
+    delete frame.params;
+    delete event.params;
+  } else frame.params = event.params = ref.params;
+}
+function openNavigation(frame, ref) {
+  const event = { at: frame.at, writes: 0, origin: frame };
+  if (frame.from !== undefined) event.from = frame.from;
+  if (frame.interaction !== undefined) event.interaction = frame.interaction;
+  const state = {
+    event,
+    ref,
+    open: 1,
+    held: false,
+    writeDrain: drainSeq
+  };
+  syncNavigation(state);
+  navStates.set(frame, state);
+  openNavs.add(state);
+  navigationLog.push(event);
+  if (navigationLog.length > options.historyLimit) navigationLog.shift();
+  noteInteractionNavigation(event);
+}
+/** The navigation a redirect hop folds onto: the most recently opened one still pending. */
+function lastOpenNavigation() {
+  let last;
+  for (const state of openNavs) last = state;
+  return last;
+}
+/** A redirect re-describes `state`: the current destination becomes a hop it abandoned. */
+function redirectNavigation(state, ref) {
+  const event = state.event;
+  // As the router last described the destination being left behind.
+  syncNavigation(state);
+  const hop = { at: ref.at ?? now() };
+  if (event.name !== undefined) hop.name = event.name;
+  if (event.to !== undefined) hop.to = event.to;
+  if (event.params !== undefined) hop.params = event.params;
+  (event.redirects ??= []).push(hop);
+  state.ref = ref;
+  state.open++;
+  syncNavigation(state);
+}
+function closeNavigation(frame) {
+  const state = navStates.get(frame);
+  if (state === undefined || --state.open > 0) return;
+  syncNavigation(state);
+  // Nothing to wait for: no write survived the equality gate (navigating to
+  // where we already are), or a drain inside the frame already committed
+  // them (`flush(() => setLocation(…))`) with no hold.
+  if (state.event.writes === 0 || (!state.held && drainSeq > state.writeDrain))
+    settleNavigation(state, "committed");
+}
+/** stampWrite: the record replacing `prior` on a node was just stamped. */
+function noteNavigationWrite(prior, record) {
+  const origin = record.origin;
+  if (origin.kind === "navigation") {
+    const state = navStates.get(origin);
+    if (state !== undefined) {
+      state.event.writes++;
+      state.writeDrain = drainSeq;
+    }
+  }
+  // The node now carries a different frame's record: whatever `prior`'s
+  // navigation was waiting to show on it will never land as that navigation.
+  const before = prior?.origin;
+  if (before !== undefined && before !== origin && before.kind === "navigation") {
+    const state = navStates.get(before);
+    if (state !== undefined && openNavs.has(state)) settleNavigation(state, "superseded");
+  }
+}
+/** 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) {
+    const origin = node._devChange?.origin;
+    if (origin?.kind !== "navigation") continue;
+    const state = navStates.get(origin);
+    if (state !== undefined) state.held = true;
+  }
+}
+/** 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) {
+    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);
+  }
+}
+/** flushEnd: every open, closed, unheld navigation's (and interaction's) writes just committed. */
+function trackFlushEnd() {
+  drainSeq++;
+  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) {
+  if (!openNavs.has(state)) return;
+  openNavs.delete(state);
+  syncNavigation(state);
+  const event = state.event;
+  event.settledMs = now() - event.at;
+  event.outcome = outcome;
+  if (hold !== undefined) event.hold = hold;
+  for (const f of folds) f.navigation?.(event);
+  emitRecord("navigation", event);
+  // 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();
+/** Opened, not yet settled. */
+const openInteractions = new Set();
+let interactionLog = [];
+function openInteraction(frame) {
+  const event = {
+    name: frame.name,
+    at: frame.at,
+    handlerMs: 0,
+    writes: 0,
+    runs: 0,
+    created: 0,
+    runMs: 0,
+    holds: [],
+    navigations: [],
+    origin: frame
+  };
+  if (frame.target !== undefined) event.target = frame.target;
+  const state = {
+    event,
+    open: true,
+    writeDrain: drainSeq,
+    heldIn: new Set(),
+    held: false,
+    excludedWrites: 0
+  };
+  interactionStates.set(frame, state);
+  openInteractions.add(state);
+  interactionLog.push(event);
+  if (interactionLog.length > options.historyLimit) interactionLog.shift();
+}
+/** interactionEnd: the handler returned. */
+function closeInteraction(frame) {
+  const state = interactionStates.get(frame);
+  if (state === undefined) return;
+  state.open = false;
+  const end = now();
+  state.event.handlerMs = end - state.event.at;
+  maybeSettleInteraction(state, end);
+}
+/** The open record a frame runs under, if any. */
+function openInteractionOf(origin) {
+  const interaction = interactionOf(origin);
+  if (interaction === undefined) return undefined;
+  const state = interactionStates.get(interaction);
+  return state !== undefined && openInteractions.has(state) ? state : undefined;
+}
+/** stampWrite: a root write stamped `origin`. */
+function noteInteractionWrite(origin, excluded) {
+  const state = openInteractionOf(origin);
+  if (state === undefined) return;
+  if (excluded) {
+    state.excludedWrites++;
+    return;
+  }
+  state.event.writes++;
+  state.writeDrain = drainSeq;
+}
+/** recordRerun / a create run: work attributed to the interaction. */
+function noteInteractionRun(interaction, selfMs, created) {
+  const state = openInteractionOf(interaction);
+  if (state === undefined) return;
+  state.event[created ? "created" : "runs"]++;
+  state.event.runMs += selfMs;
+}
+/** openNavigation: a navigation frame opened under the interaction. */
+function noteInteractionNavigation(event) {
+  const state = openInteractionOf(event.interaction);
+  if (state !== undefined) state.event.navigations.push(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) {
+    const state = openInteractionOf(node._devChange?.origin);
+    if (state !== undefined) {
+      state.heldIn.add(t);
+      state.held = true;
+    }
+  }
+}
+/** transitionMerged: whoever waited for `outgoing` now waits for `target`. */
+function mergeInteractionsHeld(target, outgoing) {
+  for (const state of openInteractions) if (state.heldIn.delete(outgoing)) state.heldIn.add(target);
+}
+/** transitionSettled: `t` committed — its holders' writes are through. */
+function settleInteractionsHeld(t, hold) {
+  if (openInteractions.size === 0) return;
+  for (const state of openInteractions) {
+    if (!state.heldIn.delete(t)) continue;
+    if (hold !== undefined) state.event.holds.push(hold);
+    maybeSettleInteraction(state);
+  }
+}
+function maybeSettleInteraction(state, end = now()) {
+  const event = state.event;
+  if (state.open || 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;
+  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
+  // fact about the app — forget it rather than report a dead interaction.
+  if (event.writes === 0 && state.excludedWrites > 0 && event.runs === 0 && event.created === 0) {
+    const i = interactionLog.indexOf(event);
+    if (i !== -1) interactionLog.splice(i, 1);
+    return;
+  }
+  event.settledMs = end - event.at;
+  event.outcome = event.writes === 0 ? "idle" : state.held ? "held" : "committed";
+  emitRecord("interaction", event);
+}
+/** The serializable face of a navigation origin for diagnostic `data`. */
+function navigationData(origin) {
+  const data = {};
+  if (origin.name !== undefined) data.name = origin.name;
+  if (origin.to !== undefined) data.to = origin.to;
+  if (origin.from !== undefined) data.from = origin.from;
+  if (origin.params !== undefined) data.params = origin.params;
+  return data;
+}
+/** @internal No affordance answered and nothing painted while held. */
+function isSilentHold(event) {
+  return event.paintedDuringHold === 0 && event.acknowledgements.length === 0;
+}
+// The engine's implementation of the core's dev hook points. Installed by
+// enable(), uninstalled by disable() — while uninstalled the core pays one
+// null check per site and nothing else.
+let asyncStartSeq = 0;
+let asyncStartTime = 0;
+let asyncStartValue;
+const engineHooks = {
+  interactionStart,
+  interactionEnd,
+  originStart,
+  originEnd,
+  flushEnd() {
+    trackFlushEnd();
+  },
+  recomputeStart(el, create) {
+    const causes = create ? null : collectCauses(el);
+    frames.push({
+      start: now(),
+      childMs: 0,
+      causes,
+      prevDeps: create ? null : captureDeps(el),
+      // Mirror recompute's own prev-value resolution: an earlier run in the
+      // same flush may still be holding in _pendingValue.
+      prevValue: el._pendingValue !== NOT_PENDING ? el._pendingValue : el._value,
+      // 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.
+      interaction:
+        causes !== null
+          ? interactionIn(causes)
+          : frames.length > 0
+            ? frames[frames.length - 1].interaction
+            : enclosingInteraction()
+    });
+  },
+  derivedChanged(el) {
+    const frame = frames[frames.length - 1];
+    stampDerived(el, frame !== undefined && frame.causes !== null ? frame.causes : []);
+  },
+  recomputeEnd(el, _create, changed, optimistic, transition, held) {
+    const frame = frames.pop();
+    // enable() can land mid-recompute: no opening frame, nothing to report.
+    if (frame === undefined) return;
+    const totalMs = now() - frame.start;
+    if (frames.length > 0) frames[frames.length - 1].childMs += totalMs;
+    const selfMs = Math.max(0, totalMs - frame.childMs);
+    // Effect-output honesty: effects run with `_equals: false`, so core
+    // reports EVERY effect recompute as changed — which made effect waste
+    // invisible to costs() (and compiled JSX bindings are effects: the
+    // fan-out waste a naive selected-row produces is all effects). The
+    // engine re-derives the fact from its own snapshot: an identical
+    // 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 (changed && frame.causes !== null && el._type) {
+      const committed = el._pendingValue !== NOT_PENDING ? el._pendingValue : el._value;
+      if (committed !== undefined && committed === frame.prevValue) changed = false;
+    }
+    // Unstable-output check: memos only, non-create, plain runs with a
+    // committed change. The fresh value sits in `_pendingValue` for held
+    // 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 (frame.causes !== null && changed && !optimistic && !transition && !el._type)
+      checkUnstableOutput(
+        el,
+        frame.prevValue,
+        el._pendingValue !== NOT_PENDING ? el._pendingValue : el._value
+      );
+    if (frame.causes !== null)
+      recordRerun(
+        el,
+        frame,
+        { selfMs, totalMs },
+        changed,
+        optimistic ? "optimistic" : transition ? "held" : "plain",
+        held
+      );
+    else if (!excludedNode(el)) {
+      // Creation runs still get the wide-scope check: a memo can be born with
+      // its coarse-read problem already in place — and their time is charged
+      // to the interaction building them (the interaction record's `created`).
+      checkDepWidth(el);
+      noteInteractionRun(frame.interaction, selfMs, true);
+    }
+    markSeen(el);
+  },
+  write(el, prev, value) {
+    stampWrite(el, "write", prev, value);
+  },
+  refreshed(el) {
+    stampWrite(el, "refresh");
+  },
+  flightStart(el, flight) {
+    trackFlightStart(el, flight);
+  },
+  asyncStart(el) {
+    asyncStartSeq = el._devChange?.seq ?? 0;
+    asyncStartTime = el._time;
+    asyncStartValue = el._value;
+  },
+  asyncEnd(el, prev, value, direct) {
+    if (direct) {
+      // Core calls this unconditionally (hook calls cannot live inside its
+      // try blocks — see attribution-hooks.ts), so committed-ness is detected
+      // here against the asyncStart snapshot: a direct commit moves `_value`
+      // (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 committed =
+        el._value !== asyncStartValue || el._time !== asyncStartTime || el._pendingValue === value;
+      if (committed) stampWrite(el, "async", prev === undefined ? NO_VALUES : prev, value);
+      // Flight over either way — an equality-swallowed landing still spent
+      // the wall time (finalizeFlight only chains through a fresh stamp).
+      finalizeFlight(el);
+      return;
+    }
+    // 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 change = el._devChange;
+    if (change !== undefined && change.seq > asyncStartSeq && change.kind === "write")
+      stampWrite(el, "async", NO_VALUES, value);
+    finalizeFlight(el);
+  },
+  effectRunStart(el) {
+    pushFrame("effect", nodeName(el), el._devRunInteraction, el);
+  },
+  effectRunEnd() {
+    popFrame("effect");
+    if (activeHold !== null) activeHold.painted++;
+  },
+  actionStepStart(it, name) {
+    // Steps after a yield resume from a promise callback with no ambient
+    // interaction; the one that started the action (its first step) is the
+    // action's interaction for every step.
+    let interaction = actionInteractions.get(it);
+    if (interaction === undefined && !actionInteractions.has(it)) {
+      interaction = currentInteraction ?? undefined;
+      actionInteractions.set(it, interaction);
+    }
+    pushFrame("action", name, interaction);
+  },
+  actionStepEnd() {
+    popFrame("action");
+  },
+  holdStart(t) {
+    trackHoldStart(t);
+  },
+  holdEnd() {
+    activeHold = null;
+  },
+  transitionSettled(t) {
+    trackHoldSettled(t);
+  },
+  transitionMerged(target, outgoing) {
+    trackHoldMerge(target, outgoing);
+  },
+  storeReplaced(path, isArray, total, unchanged, prevTotal, owner) {
+    checkImmutableUpdate(path, isArray, total, unchanged, prevTotal, owner);
+  },
+  listChurn(el, removed, created, newLen, keyed) {
+    checkListIdentity(el, removed, created, newLen, keyed);
+  },
+  boundaryFallback(boundary, tree, shown) {
+    for (const f of folds) f.fallback?.(boundary, tree, shown);
+  },
+  currentOrigin() {
+    return ambientOrigin();
+  }
+};
+const attribution = {
+  enable(opts) {
+    options = { ...defaultOptions, ...opts };
+    frames.length = 0;
+    waterfallLog = [];
+    holdLog = [];
+    activeHold = null;
+    navigationLog = [];
+    openNavs.clear();
+    interactionLog = [];
+    openInteractions.clear();
+    drainSeq = 0;
+    reportedCycles.clear();
+    relays.clear();
+    immutableReported.clear();
+    originFrames.length = 0;
+    interactionStack.length = 0;
+    currentInteraction = null;
+    hotCauses.clear();
+    for (const f of folds) f.reset?.();
+    setAttributionHooks(engineHooks);
+  },
+  disable() {
+    clearListeners();
+    history = [];
+    frames.length = 0;
+    waterfallLog = [];
+    holdLog = [];
+    activeHold = null;
+    navigationLog = [];
+    openNavs.clear();
+    interactionLog = [];
+    openInteractions.clear();
+    drainSeq = 0;
+    reportedCycles.clear();
+    relays.clear();
+    immutableReported.clear();
+    originFrames.length = 0;
+    interactionStack.length = 0;
+    currentInteraction = null;
+    hotCauses.clear();
+    for (const f of folds) f.reset?.();
+    setAttributionHooks(null);
+  },
+  subscribe(typeOrListener, listener) {
+    const type = typeof typeOrListener === "string" ? typeOrListener : "rerun";
+    const fn = typeof typeOrListener === "string" ? listener : typeOrListener;
+    const set = recordListeners[type];
+    set.add(fn);
+    return () => set.delete(fn);
+  },
+  history() {
+    return history;
+  },
+  waterfalls() {
+    return waterfallLog;
+  },
+  holds() {
+    return holdLog;
+  },
+  navigations() {
+    return navigationLog;
+  },
+  interactions() {
+    return interactionLog;
+  },
+  markFlight(flight, startedAt = now()) {
+    // Earliest wins: re-marking (a cache re-serving the same promise) must
+    // not move the origin later.
+    const existing = flightOrigins.get(flight);
+    if (existing === undefined || startedAt < existing) flightOrigins.set(flight, startedAt);
+  }
+};
+
+/**
+ * `costs()` — the cost tables: scopes ranked by the self-time they burn,
+ * root writes ranked by the downstream re-run time they cause. Folded from
+ * every `RerunEvent` as the engine records it.
+ *
+ * Its own module on purpose: the tables register with the engine's fold seam
+ * when this module is evaluated, so an observe-tier consumer that only
+ * subscribes to records (an APM adapter) never ships the accumulation or the
+ * tables; a consumer that imports `costs` gets both. Reset with the engine on
+ * `enable()`/`disable()`.
+ */
+const scopeCosts = new Map();
+const writeCosts = new Map();
+function recordCosts(el, event) {
+  let scope = scopeCosts.get(el);
+  if (scope === undefined) {
+    scope = {
+      name: event.nodeName,
+      kind: event.nodeKind,
+      runs: 0,
+      selfMs: 0,
+      wastedMs: 0,
+      overlayMs: 0
+    };
+    scopeCosts.set(el, scope);
+  }
+  scope.runs++;
+  scope.selfMs += event.selfMs;
+  if (event.phase !== "plain") scope.overlayMs += event.selfMs;
+  else if (!event.changed && !event.held) scope.wastedMs += event.selfMs;
+  const roots = new Set();
+  rootsOf(event.causes, roots);
+  for (const name of roots) {
+    let write = writeCosts.get(name);
+    if (write === undefined) writeCosts.set(name, (write = { name, runs: 0, downstreamMs: 0 }));
+    write.runs++;
+    write.downstreamMs += event.selfMs;
+  }
+}
+registerFold({
+  rerun: recordCosts,
+  reset() {
+    scopeCosts.clear();
+    writeCosts.clear();
+  }
+});
+/**
+ * Aggregated cost tables since `enable()`: `scopes` ranked by self-time
+ * (with `wastedMs` = time spent on unchanged-value runs), `writes` ranked by
+ * total downstream re-run time each root write caused.
+ */
+function costs() {
+  return {
+    scopes: [...scopeCosts.values()].sort((a, b) => b.selfMs - a.selfMs),
+    writes: [...writeCosts.values()].sort((a, b) => b.downstreamMs - a.downstreamMs)
+  };
+}
+
+/**
+ * `feedback()` — what the user waited on, as ranked tables. Folded from the
+ * records the engine already keeps (holds, the interaction on each re-run,
+ * navigations) and two censuses the engine reports as they happen (flights
+ * started/landed/abandoned per async source; fallback shows per boundary).
+ *
+ * Its own module on purpose: the tables register with the engine's fold seam
+ * when this module is evaluated, so an observe-tier consumer that only
+ * subscribes to records never ships them. Reset with the engine on
+ * `enable()`/`disable()`.
+ */
+const feedbackSources = new Map();
+const feedbackInteractions = new Map();
+const feedbackNavigations = new Map();
+const flightStats = new Map();
+const fallbackStats = new Map();
+const FALLBACK_FLASH_MS = 150;
+function flightBucket(el) {
+  let row = flightStats.get(el);
+  if (row === undefined) {
+    row = { source: nodeName(el), flights: 0, landed: 0, abandoned: 0, landedMs: 0, worstMs: 0 };
+    flightStats.set(el, row);
+  }
+  return row;
+}
+function trackFallback(boundary, tree, shown) {
+  let bucket = fallbackStats.get(boundary);
+  if (bucket === undefined) {
+    bucket = {
+      row: { boundary: "boundary", shows: 0, shownMs: 0, worstMs: 0, flashes: 0 },
+      shownAt: null
+    };
+    fallbackStats.set(boundary, bucket);
+  }
+  // The first show can fire before the subtree exists; name on first sight.
+  if (bucket.row.boundary === "boundary" && tree !== undefined) {
+    const path = ownerPath(tree);
+    if (path !== undefined) bucket.row.boundary = path.join(" › ");
+  }
+  if (shown) {
+    if (bucket.shownAt === null) {
+      bucket.shownAt = now();
+      bucket.row.shows++;
+    }
+    return;
+  }
+  if (bucket.shownAt === null) return;
+  const ms = now() - bucket.shownAt;
+  bucket.shownAt = null;
+  bucket.row.shownMs += ms;
+  if (ms > bucket.row.worstMs) bucket.row.worstMs = ms;
+  if (ms < FALLBACK_FLASH_MS) bucket.row.flashes++;
+}
+function interactionBucket(interaction) {
+  const key = formatOrigin(interaction);
+  let bucket = feedbackInteractions.get(key);
+  if (bucket === undefined) {
+    bucket = {
+      row: {
+        interaction: key,
+        dispatches: 0,
+        runs: 0,
+        selfMs: 0,
+        worstDispatchMs: 0,
+        holds: 0,
+        heldMs: 0,
+        silentMs: 0,
+        worstHoldMs: 0
+      },
+      dispatches: new Map()
+    };
+    feedbackInteractions.set(key, bucket);
+  }
+  const at = interaction.at ?? 0;
+  if (!bucket.dispatches.has(at)) {
+    bucket.dispatches.set(at, 0);
+    bucket.row.dispatches++;
+  }
+  return bucket;
+}
+function recordFeedbackRun(event) {
+  if (event.interaction === undefined) return;
+  const bucket = interactionBucket(event.interaction);
+  bucket.row.runs++;
+  bucket.row.selfMs += event.selfMs;
+  const at = event.interaction.at ?? 0;
+  const dispatchMs = bucket.dispatches.get(at) + event.selfMs;
+  bucket.dispatches.set(at, dispatchMs);
+  if (dispatchMs > bucket.row.worstDispatchMs) bucket.row.worstDispatchMs = dispatchMs;
+}
+function recordFeedbackHold(event) {
+  const sources = [...event.blockers].sort();
+  const key = sources.join("\u0000");
+  let bucket = feedbackSources.get(key);
+  if (bucket === undefined) {
+    bucket = {
+      row: {
+        sources,
+        holds: 0,
+        heldMs: 0,
+        worstMs: 0,
+        silent: 0,
+        silentMs: 0,
+        latestOnly: 0,
+        long: 0,
+        longMs: 0,
+        acknowledgedBy: [],
+        interactions: [],
+        writes: [],
+        actions: 0
+      },
+      acks: new Map(),
+      interactions: new Map(),
+      writes: new Set()
+    };
+    feedbackSources.set(key, bucket);
+  }
+  const row = bucket.row;
+  const silent = isSilentHold(event);
+  row.holds++;
+  row.heldMs += event.holdMs;
+  if (event.holdMs > row.worstMs) row.worstMs = event.holdMs;
+  if (silent) {
+    row.silent++;
+    row.silentMs += event.holdMs;
+  } else if (
+    event.acknowledgements.length > 0 &&
+    event.acknowledgements.every(a => a.kind === "latest")
+  )
+    row.latestOnly++;
+  if (isLongHold(event)) {
+    row.long++;
+    row.longMs += event.tailMs;
+  }
+  if (event.action) row.actions++;
+  for (const a of event.acknowledgements) {
+    const by = `${a.kind}:${a.source}`;
+    bucket.acks.set(by, (bucket.acks.get(by) ?? 0) + 1);
+  }
+  for (const w of event.heldWrites) bucket.writes.add(w.name);
+  if (event.interaction !== undefined) {
+    const key = formatOrigin(event.interaction);
+    bucket.interactions.set(key, (bucket.interactions.get(key) ?? 0) + 1);
+    const ib = interactionBucket(event.interaction);
+    ib.row.holds++;
+    ib.row.heldMs += event.holdMs;
+    if (silent) ib.row.silentMs += event.holdMs;
+    if (event.holdMs > ib.row.worstHoldMs) ib.row.worstHoldMs = event.holdMs;
+  }
+}
+function recordFeedbackNavigation(event) {
+  const name = event.name ?? event.to;
+  if (name === undefined) return;
+  let row = feedbackNavigations.get(name);
+  if (row === undefined) {
+    row = {
+      name,
+      navigations: 0,
+      settledMs: 0,
+      worstMs: 0,
+      held: 0,
+      heldMs: 0,
+      silent: 0,
+      superseded: 0,
+      redirected: 0
+    };
+    feedbackNavigations.set(name, row);
+  }
+  row.navigations++;
+  if (event.redirects !== undefined) row.redirected++;
+  if (event.outcome === "superseded") {
+    row.superseded++;
+    return;
+  }
+  const ms = event.settledMs;
+  row.settledMs += ms;
+  if (ms > row.worstMs) row.worstMs = ms;
+  if (event.outcome === "held") {
+    row.held++;
+    row.heldMs += event.hold?.holdMs ?? ms;
+    if (event.hold !== undefined && isSilentHold(event.hold)) row.silent++;
+  }
+}
+function rankedCounts(counts, key) {
+  return [...counts].sort((a, b) => b[1] - a[1]).map(([name, holds]) => ({ [key]: name, holds }));
+}
+registerFold({
+  rerun: (_el, event) => recordFeedbackRun(event),
+  hold: recordFeedbackHold,
+  navigation: recordFeedbackNavigation,
+  flightStart(el, abandoned) {
+    const stats = flightBucket(el);
+    stats.flights++;
+    if (abandoned) stats.abandoned++;
+  },
+  flightLanded(el, ms) {
+    const stats = flightBucket(el);
+    stats.landed++;
+    stats.landedMs += ms;
+    if (ms > stats.worstMs) stats.worstMs = ms;
+  },
+  fallback: trackFallback,
+  reset() {
+    feedbackSources.clear();
+    feedbackInteractions.clear();
+    feedbackNavigations.clear();
+    flightStats.clear();
+    fallbackStats.clear();
+  }
+});
+/**
+ * What the user waited on, folded from holds and the interaction on each
+ * re-run: `sources` ranks async sources by the silent time writes spent held
+ * behind them (with which affordances answered, how often, and which
+ * interactions were held); `interactions` ranks user events by the total time
+ * they cost — re-run work caused (long-flush hazard) beside time held
+ * (silent-hold hazard). Facts at every duration; SILENT_HOLD is the
+ * thresholded verdict. Three more tables round out the picture: `navigations`
+ * ranks routes by the time spent held navigating to them (folded from settled
+ * navigations), `flights` counts each async source's flights and how many
+ * were abandoned before landing (the re-ask storm), and `fallbacks` measures
+ * how long each loading boundary showed its fallback and how often that was a
+ * flash.
+ */
+function feedback() {
+  const navigations = [...feedbackNavigations.values()]
+    .map(row => ({ ...row }))
+    .sort((a, b) => b.heldMs - a.heldMs || b.settledMs - a.settledMs);
+  const flights = [...flightStats.values()]
+    .map(row => ({ ...row }))
+    .sort((a, b) => b.abandoned - a.abandoned || b.flights - a.flights);
+  const fallbacks = [...fallbackStats.values()]
+    .map(bucket => ({ ...bucket.row }))
+    .sort((a, b) => b.flashes - a.flashes || b.shownMs - a.shownMs);
+  const sources = [...feedbackSources.values()]
+    .map(bucket => ({
+      ...bucket.row,
+      acknowledgedBy: rankedCounts(bucket.acks, "by"),
+      interactions: rankedCounts(bucket.interactions, "interaction"),
+      writes: [...bucket.writes]
+    }))
+    .sort((a, b) => b.silentMs - a.silentMs || b.heldMs - a.heldMs);
+  // Ranked by the total time the user spent on it: held plus synchronous work.
+  const interactions = [...feedbackInteractions.values()]
+    .map(bucket => ({ ...bucket.row }))
+    .sort((a, b) => b.heldMs + b.selfMs - (a.heldMs + a.selfMs));
+  return { sources, interactions, navigations, flights, fallbacks };
+}
+
+/**
+ * Point queries over the engine's live state — the devtools/console view of
+ * one scope. Their own module so a records-only consumer never ships them;
+ * they read the engine's ring buffer and the graph, and register nothing.
+ */
+/** The node behind a memo/effect accessor, or the raw node passed through. */
+function nodeOf(target) {
+  return target?.[$REFRESH] ?? target;
+}
+/** Re-run history for one node — pass a memo/effect accessor or raw node. */
+function why(target) {
+  const node = nodeOf(target);
+  return attribution.history().filter(event => subjectOf(event) === node);
+}
+/** Current dependency names of one scope — the devtools subscription view. */
+function subscriptions(target) {
+  const node = nodeOf(target);
+  const names = [];
+  for (let l = node?._deps ?? null; l !== null; l = l._nextDep) names.push(nodeName(l._dep));
+  return names;
+}
+
+export { attribution, costs, feedback, formatOrigin, formatRerun, subscriptions, why };