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

package/dist/dev.attribution.js

@@ -0,0 +1,3307 @@
+import {
+  bL as OBSERVE,
+  bV as setAttributionHooks,
+  bW as liveRootOwners,
+  b as NOT_PENDING,
+  ay as emitDiagnostic,
+  bX as ownerPath,
+  ax as reportDiagnostic,
+  bY as isSuppressed,
+  bZ as CONFIG_PLUMBING,
+  b_ as anyExcluded,
+  b$ as isExcluded,
+  q as CONFIG_DERIVED_OVERRIDE,
+  c0 as GRAPH_SIZE_WARN_AT,
+  c1 as noteFanOut,
+  aV as $REFRESH
+} from "./dev-shared.js";
+
+/** A fallback shown for less than this is a flash: feedback for a wait too short to need it. */
+const FALLBACK_FLASH_MS = 150;
+/**
+ * Under an owner the observer marked as its own (`OBSERVE.exclude`), or
+ * framework plumbing itself (`CONFIG_PLUMBING` — the HMR memo between a
+ * component's root and its body, which is nobody's node): the engine records
+ * nothing about the node. Plumbing is a bit read and excludes the node alone,
+ * not what it owns; the observer exclusion is cached per node once any
+ * exists, before that a flag read.
+ */
+function excludedNode(el) {
+  if ((el._config & CONFIG_PLUMBING) !== 0) return true;
+  if (!anyExcluded()) return false;
+  const node = el;
+  if (node._devExcluded === undefined) node._devExcluded = isExcluded(el);
+  return node._devExcluded;
+}
+let attributionActive = false;
+let changeSeq = 0;
+let runSeq = 0;
+const defaultOptions = {
+  log: true,
+  // Tier-dependent (see `AttributionOptions.values`): dev output is for the
+  // developer at the console and shows everything; an observe build is a
+  // production artifact and carries no user data unless a holder asks. The
+  // literal folds per build — the observe engine ships `"none"` only.
+  values: "full",
+  checks: true,
+  stacks: false,
+  historyLimit: 200,
+  hotRuns: { count: 120, windowMs: 1000 },
+  wideDeps: 30,
+  hotTime: { budgetMs: 8, windowMs: 1000 },
+  unstableMemos: 4,
+  wastedRecompute: { minRuns: 5, ratio: 0.8, budgetMs: 2, windowMs: 1000 },
+  fanOut: 250,
+  waterfalls: { minFlightMs: 50 },
+  holds: { infoMs: 100, warnMs: 200 },
+  longHolds: { infoMs: 500, warnMs: 1000 },
+  graphGrowth: { visits: 3, ratio: 1.25 },
+  abandonedFlights: { count: 3, windowMs: 1000 },
+  fallbackFlashes: true,
+  optimisticReverts: true,
+  stackedHolds: { count: 3 }
+};
+let options = { ...defaultOptions };
+let history = [];
+/**
+ * The engine's records go out on the core's channel, `OBSERVE.records` —
+ * the one every runtime emits on — under the types `RecordTypes` declares
+ * for it (`rerun`, `create`, `effect`, `flush`, `flight`, `fallback`,
+ * `interaction`, `hold`, `navigation`, `graph`), each with the live node as
+ * `live` where the record has one. `records.observed(type)` is the
+ * pre-check the listener-gated records cost nothing without; the channel
+ * is process-wide and the subscriptions on it are the consumer's, so the
+ * engine neither holds nor clears listeners of its own.
+ */
+const records = OBSERVE.records;
+/** @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";
+}
+/** The record vocabulary for a computation's kind: effects carry a `_type`, memos do not. */
+function nodeKind(el) {
+  return el._type ? "effect" : "memo";
+}
+/**
+ * Whether a re-run record has an audience — a listener on the channel, an
+ * imported fold (`costs`/`feedback`), or the console log. Read at recompute
+ * START (the subscription diff needs the deps as they were), so a listener
+ * arriving mid-run hears the next one. Without an audience the engine still
+ * runs every check and keeps every per-node fact; only the record — its
+ * cause list copy, dep diff, previews — is not built, and `history("rerun")`
+ * stays empty.
+ */
+function wantsRerun() {
+  return options.log || folds.length > 0 || records.observed("rerun");
+}
+/**
+ * A short preview of a written value for a record — only ever called under
+ * `values: "full"` (`stampWrite`, OPTIMISTIC_REVERTED): the other levels
+ * carry no previews, and the check is made at the call site so the value is
+ * not even looked at.
+ */
+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 = [];
+/**
+ * The element label an interaction record carries, from the one the runtime
+ * described (`tag`, then `#id` or `[name=…]`, then the element's text in
+ * quotes — `button#next "Next →"`), cut to what `options.values` allows: the
+ * text is the part after the first ` "`; under `"labels"` it stays on a
+ * `button` or an `a`, under `"none"` never. The ref's own string is never
+ * mutated — the runtime's object is the runtime's.
+ */
+function targetLabel(target) {
+  const level = options.values;
+  if (level === "full") return target;
+  const text = target.indexOf(' "');
+  if (text === -1) return target;
+  if (level === "labels") {
+    const head = target.slice(0, text);
+    const mark = head.search(/[#[]/);
+    const tag = mark === -1 ? head : head.slice(0, mark);
+    if (tag === "button" || tag === "a") return target;
+  }
+  return target.slice(0, text);
+}
+function interactionStart(ref) {
+  interactionStack.push(currentInteraction);
+  // One clock read: the frame opens now; the interaction began at `ref.at`
+  // when the runtime dated it (the event's own timestamp), else now too.
+  const opened = now();
+  const origin = { kind: "interaction", name: ref.type, at: ref.at ?? opened };
+  if (ref.target) origin.target = targetLabel(ref.target);
+  currentInteraction = origin;
+  openInteraction(origin, opened);
+}
+function interactionEnd(returned) {
+  const closing = currentInteraction;
+  currentInteraction = interactionStack.length ? interactionStack.pop() : null;
+  if (closing !== null) closeInteraction(closing, returned);
+}
+/** 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 nodes of the open effect frames, innermost last — parallel to the
+ * `effect` entries of `originFrames`, so the frame on top resolves to its
+ * node without a map. A stack, not a single slot: a render effect created
+ * inside a callback runs its own callback synchronously.
+ */
+const effectStack = [];
+/**
+ * A write just stamped `origin`. If it is the innermost effect frame (a
+ * root write's origin is always the innermost open frame, see `stampWrite`)
+ * and no earlier write registered it, register it now with the node on top
+ * of the effect stack. An origin that is an effect frame but not the top is
+ * inherited — reached through an earlier write's record — and that write
+ * registered it.
+ */
+function noteEffectOrigin(origin) {
+  if (origin.kind !== "effect" || effectFrames.has(origin)) return;
+  if (originFrames[originFrames.length - 1] !== origin) return;
+  const node = effectStack[effectStack.length - 1];
+  if (node !== undefined) effectFrames.set(origin, { node, causes: node._devRunCauses });
+}
+/** 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;
+    // The frame → node map is filled by the first write inside the callback
+    // (noteEffectOrigin), not here: most callbacks never write.
+    effectStack.push(effect);
+  }
+  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();
+    if (kind === "effect") effectStack.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;
+}
+/**
+ * HUGE_FAN_OUT from the engine's lower `fanOut` threshold (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). Stops at
+ * GRAPH_SIZE_WARN_AT, where the always-on core check takes over, so the two
+ * never fire for the same write; the once-per-node dedupe is the core's.
+ */
+function checkFanOut(node, kind) {
+  const limit = options.fanOut;
+  if (typeof limit !== "number") return;
+  const subs = countSubscribers(node);
+  if (subs < limit || subs >= GRAPH_SIZE_WARN_AT) return;
+  noteFanOut(node, subs, kind);
+}
+function stampWrite(node, kind, prev = NO_VALUES, value = NO_VALUES) {
+  const record = {
+    seq: ++changeSeq,
+    kind,
+    name: nodeName(node),
+    nodeId: devId(node)
+  };
+  // The previews are the record's one look at the written values: under
+  // any level but `"full"` they are not taken, so the record never carries
+  // them (nor does the `HeldWrite` copied from it, nor a sentence built on it).
+  if (value !== NO_VALUES && options.values === "full") {
+    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
+  // engine's fan-out check needs to live.
+  checkFanOut(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),
+    nodeId: devId(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 message =
+    `[WIDE_SCOPE_DEPS] ${nodeKind(el)} "${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, causes) {
+  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(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 = causes.map(c => `"${c.name}" (${c.kind})`).join(", ");
+    const message =
+      `[HOT_SCOPE_RERUNS] ${nodeKind(el)} "${nodeName(el)}" 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: nodeName(el),
+          data: {
+            runs: node._devWinCount,
+            windowMs: cfg.windowMs,
+            causes: 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, selfMs, causes) {
+  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) + selfMs;
+  if (node._devTimeWarned || node._devTimeWinMs < cfg.budgetMs) return;
+  node._devTimeWarned = true;
+  const rootCause = causes.map(c => `"${c.name}" (${c.kind})`).join(", ");
+  const message =
+    `[HOT_SCOPE_TIME] ${nodeKind(el)} "${nodeName(el)}" 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: nodeName(el),
+        data: {
+          spentMs: node._devTimeWinMs,
+          budgetMs: cfg.budgetMs,
+          windowMs: cfg.windowMs,
+          causes: causes.map(c => c.name)
+        }
+      },
+      el
+    )
+  );
+}
+/**
+ * A scope whose equality gate closes almost every time: it re-ran because
+ * an input changed, computed, compared equal to its last value and told
+ * nobody — the run was pure cost. `costs().wastedMs` sums this; the finding
+ * names it while it happens, with the input that keeps triggering it. The
+ * fix is upstream: an equality boundary on the part of the input the scope
+ * depends on, or a narrower read. Plain runs only — a held or overlay run
+ * may be replayed and is never blamed as waste.
+ */
+function checkWastedRecompute(el, at, phase, changed, selfMs, causes) {
+  const cfg = options.wastedRecompute;
+  if (cfg === false || phase !== "plain") return;
+  // This runs on every re-run: fields on the node (one property read each,
+  // like hotRuns) and the run's own `at` — no clock read, no map lookup.
+  const node = el;
+  if (node._devWasteWinStart === undefined || at - node._devWasteWinStart > cfg.windowMs) {
+    node._devWasteWinStart = at;
+    node._devWasteRuns = 0;
+    node._devWasted = 0;
+    node._devWastedMs = 0;
+    node._devWasteWarned = false;
+  }
+  node._devWasteRuns = node._devWasteRuns + 1;
+  if (!changed) {
+    node._devWasted = node._devWasted + 1;
+    node._devWastedMs = node._devWastedMs + selfMs;
+  }
+  if (
+    node._devWasteWarned ||
+    node._devWasteRuns < cfg.minRuns ||
+    node._devWasted / node._devWasteRuns < cfg.ratio ||
+    node._devWastedMs < cfg.budgetMs
+  )
+    return;
+  node._devWasteWarned = true;
+  const win = { runs: node._devWasteRuns, wasted: node._devWasted, wastedMs: node._devWastedMs };
+  const rootCause = causes.map(c => `"${c.name}" (${c.kind})`).join(", ");
+  const message =
+    `[WASTED_RECOMPUTE] ${nodeKind(el)} "${nodeName(el)}" re-ran ${win.runs} times in ` +
+    `${cfg.windowMs}ms and ${win.wasted} of those produced the same value — ` +
+    `${win.wastedMs.toFixed(1)}ms of compute the equality gate then discarded. Its inputs ` +
+    `change without changing its result: put an equality boundary upstream (a memo over the ` +
+    `part of the input it reads, or an \`equals\` on the source), or read a narrower slice ` +
+    `(the property, not the object). Latest cause: ${rootCause || "(untracked pull)"}`;
+  reportDiagnostic(
+    emitDiagnostic(
+      {
+        code: "WASTED_RECOMPUTE",
+        kind: "perf",
+        severity: "warn",
+        message,
+        nodeName: nodeName(el),
+        data: {
+          runs: win.runs,
+          wasted: win.wasted,
+          wastedMs: win.wastedMs,
+          windowMs: cfg.windowMs,
+          causes: causes.map(c => c.name)
+        }
+      },
+      el
+    )
+  );
+}
+function recordRerun(el, frame, timing, changed, phase, held) {
+  const causes = frame.causes;
+  const node = el;
+  const prevCauses = node._devRunCauses;
+  const interaction = frame.interaction;
+  if (excludedNode(el)) {
+    // The observer's own computation: keep the per-node bookkeeping its
+    // effect phase reads (see effectRunStart) and record nothing.
+    node._devRunInteraction = interaction;
+    node._devRunSeq = undefined;
+    node._devRunCauses = causes;
+    return;
+  }
+  // The facts every run leaves on the node, record or not: the run sequence
+  // (`ChangeOrigin.run` joins an effect-phase write to it), the run count,
+  // and what the effect phase inherits — it runs later in the flush with no
+  // cause list of its own, so it takes this run's interaction and causes
+  // (see effectRunStart / pushFrame).
+  const run = ++runSeq;
+  const nodeRuns = (node._devRunCount = (node._devRunCount ?? 0) + 1);
+  node._devRunInteraction = interaction;
+  node._devRunSeq = run;
+  node._devRunCauses = causes;
+  noteInteractionRun(interaction, timing.selfMs, false);
+  if (openFlush !== null) noteFlushRun(openFlush, false, interaction);
+  // The checks read the facts, not the record, so they run with or without
+  // an audience for it.
+  const kind = nodeKind(el);
+  if (kind === "effect") checkEffectCycle(el, causes);
+  checkRelayTear(el, causes, prevCauses);
+  checkHotRuns(el, causes);
+  checkHotTime(el, timing.selfMs, causes);
+  checkWastedRecompute(el, frame.start, phase, changed, timing.selfMs, causes);
+  checkDepWidth(el);
+  // The record: built only when something wanted it at run start (see
+  // `wantsRerun`) — a listener, a fold, the log.
+  const prevDeps = frame.prevDeps;
+  if (prevDeps === null) 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,
+    at: frame.start,
+    nodeRuns,
+    nodeKind: kind,
+    nodeName: nodeName(el),
+    nodeId: devId(el),
+    causes,
+    depCount: newDeps.length,
+    depsAdded,
+    depsRemoved,
+    selfMs: timing.selfMs,
+    totalMs: timing.totalMs,
+    changed,
+    phase,
+    held
+  };
+  if (interaction !== undefined) event.interaction = interaction;
+  history.push(event);
+  if (history.length > options.historyLimit) history.shift();
+  for (const f of folds) f.rerun?.(el, event);
+  records.emit("rerun", event, el);
+  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;
+}
+/** @internal The id the engine's records name `node` by, if it has one yet — read without assigning. */
+function nodeIdOf(node) {
+  return devIds.get(node);
+}
+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;
+  if (origin !== undefined) noteEffectOrigin(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;
+}
+/**
+ * The 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.
+ */
+function enclosingCauses() {
+  for (let i = frames.length - 1; i >= 0; i--) {
+    const causes = frames[i].causes;
+    if (causes !== null) return causes;
+  }
+  return null;
+}
+/** The flight's face as a record, at the moment it landed or was superseded. */
+function emitFlight(el, flight, endedAt, outcome) {
+  if (excludedNode(el)) return;
+  const event = {
+    nodeId: devId(el),
+    nodeName: nodeName(el),
+    at: flight.origin,
+    durationMs: endedAt - flight.origin,
+    outcome
+  };
+  const path = ownerPath(el);
+  if (path !== undefined) event.ownerPath = path;
+  if (flight.interaction !== undefined) event.interaction = flight.interaction;
+  records.emit("flight", event, el);
+}
+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.
+  const superseded = liveFlights.get(el);
+  for (const f of folds) f.flightStart?.(el, superseded !== undefined);
+  if (superseded !== undefined) {
+    if (records.observed("flight")) emitFlight(el, superseded, at, "abandoned");
+    checkAbandonedFlights(el, superseded);
+  }
+  const causes = enclosingCauses();
+  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);
+  if (records.observed("flight")) emitFlight(el, flight, landedAt, "landed");
+  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 tailMs = lastJoinAt === -Infinity ? holdMs : Math.min(holdMs, end - lastJoinAt);
+  const acknowledgements = [...state.acknowledgements.values()];
+  // The verdicts, stamped on the record so a consumer — in-process or
+  // offline — applies the engine's own tiering rather than a threshold of
+  // its own: silent is duration-free (the finding adds the floor); long is
+  // the tail against `longHolds.infoMs` as the options stand at settle.
+  const longCfg = options.longHolds;
+  const event = {
+    at,
+    holdMs,
+    tailMs,
+    flushes: state.flushes,
+    heldWrites,
+    blockers: [...state.blockers].map(nodeName),
+    acknowledgements,
+    paintedDuringHold: state.painted,
+    action: state.action,
+    silent: state.painted === 0 && acknowledgements.length === 0,
+    long: longCfg !== false && longCfg !== undefined && tailMs >= longCfg.infoMs
+  };
+  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.
+  // `live` is the first held root write's signal: the subject the findings
+  // below name.
+  records.emit("hold", event, subject);
+  checkStackedHolds(t, event, subject);
+  settleNavigations(t, event);
+  settleInteractionsHeld(t, event);
+  for (const f of folds) f.hold?.(event);
+  if (event.silent) checkSilentHold(event, subject);
+  else checkLongHold(event, subject);
+}
+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 = event.long;
+  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);
+}
+/**
+ * The person saw the guess, then the correction. An optimistic value is a
+ * promise the UI makes about the outcome; when the outcome differs — the
+ * action failed and the override lifted back to the old value, or the
+ * source answered with something else — the screen changes twice for one
+ * intent. Expected on failure and correct by construction (the override
+ * reverts; that is the feature), so `info`: a count that grows for one
+ * source is what says the guess, or the failure rate, is wrong. Judged by
+ * the node's own equality, so a structurally equal replacement is not a
+ * revert.
+ */
+function checkOptimisticRevert(el, shown, truth, how) {
+  // The runtime's own optimistic nodes are not guesses the person saw: an
+  // `isPending()` companion goes true while pending and back to false at
+  // commit by design — the acknowledgement SILENT_HOLD asks for — and a
+  // derived override promotes rather than reverts. Same predicate the hold
+  // census uses to skip them.
+  if (!options.optimisticReverts || isCompanion(el)) return;
+  const equals = el._equals;
+  if (equals && equals(shown, truth)) return;
+  const source = nodeName(el);
+  // The two values are user data: quoted only under `values: "full"`; the
+  // other levels say what happened without saying what was shown.
+  const values = options.values === "full";
+  const change = how === "superseded" ? "settled to" : "reverted to";
+  const message =
+    `[OPTIMISTIC_REVERTED] the optimistic value of ${source} ` +
+    (values
+      ? `showed ${preview(shown)}; it ${change} ${preview(truth)}.`
+      : `${how === "superseded" ? "was superseded by the settled value" : "reverted at settle"}.`) +
+    ` The person saw the guess, then the correction. A revert on failure is the feature; one ` +
+    `that recurs says the guess is wrong for this input or the action fails often — show the ` +
+    `failure where the value renders (the action's catch, an Errored boundary) rather than ` +
+    `letting the value snap back on its own.`;
+  const data = { source, how };
+  if (values) {
+    data.shown = preview(shown);
+    data.truth = preview(truth);
+  }
+  emitDiagnostic(
+    {
+      code: "OPTIMISTIC_REVERTED",
+      kind: "responsiveness",
+      severity: "info",
+      message,
+      nodeName: source,
+      data
+    },
+    el
+  );
+}
+// --- Graph growth -----------------------------------------------------------------
+/** Per route: the graph's size at its last `visits` settles, oldest first. */
+const routeCounts = new Map();
+/**
+ * The live graph's size — a walk, not a counter: nothing is charged at node
+ * creation, disposal, write or re-run; the engine asks at a navigation's
+ * settle. Two passes. The owner tree from the registered top-level roots
+ * gives `owners` and seeds the computations. Then each computation's
+ * dependency links give `edges` and the `signals` and computations they
+ * reach, and each newly met source's subscriber list gives the computations
+ * that read it — including one created with no owner, which no chain holds
+ * and only its sources keep alive: the subscription leak a heap snapshot
+ * finds. Measured at 5–10 ns per link; a 50k-owner graph walks in under a
+ * millisecond. Dormant nodes are spliced out of their chain and are not
+ * counted unless a subscription still reaches them.
+ */
+function graphSize() {
+  const roots = liveRootOwners();
+  const size = { roots: roots.length, owners: 0, computations: 0, signals: 0, edges: 0 };
+  const seen = new Set();
+  // A worklist, not recursion: a subscriber chain can be thousands deep.
+  const work = [];
+  const stack = [];
+  const meet = node => {
+    if (seen.has(node)) return;
+    seen.add(node);
+    if (typeof node._fn === "function") size.computations++;
+    else size.signals++;
+    work.push(node);
+  };
+  for (const root of roots) {
+    size.owners++;
+    // Iterative: a deep tree must not grow the call stack.
+    let child = root._firstChild;
+    for (;;) {
+      while (child !== null) {
+        size.owners++;
+        if (typeof child._fn === "function") meet(child);
+        if (child._firstChild !== null) stack.push(child);
+        child = child._nextSibling;
+      }
+      const next = stack.pop();
+      if (next === undefined) break;
+      child = next._firstChild;
+    }
+  }
+  for (let i = 0; i < work.length; i++) {
+    const node = work[i];
+    // Whoever reads this node: owned computations are already known; an
+    // ownerless one is met only here.
+    for (let s = node._subs; s !== null; s = s._nextSub) meet(s._sub);
+    if (typeof node._fn === "function")
+      for (let link = node._deps; link !== null; link = link._nextDep) {
+        size.edges++;
+        meet(link._dep);
+      }
+  }
+  return size;
+}
+/**
+ * settleNavigation: the app has finished moving to a route — count the live
+ * graph. One record per settle for a listener; the growth check compares
+ * this settle of the route with its previous ones. A count that climbs on
+ * consecutive visits is something the previous visit left behind: a
+ * `createRoot` in an effect with no dispose, a subscription a component
+ * registered outside its owner. Nothing here runs per node; the walk is
+ * the cost, at navigation cadence.
+ */
+const GRAPH_SERIES = ["owners", "computations", "signals", "edges"];
+function trackGraph(navigation) {
+  const cfg = options.graphGrowth;
+  if (cfg === false && !records.observed("graph")) return;
+  const size = graphSize();
+  const route = navigation.name ?? navigation.to;
+  const event = { at: now(), ...size, navigation };
+  if (route !== undefined) event.route = route;
+  records.emit("graph", event, undefined);
+  if (cfg === false || route === undefined) return;
+  let history = routeCounts.get(route);
+  if (history === undefined) routeCounts.set(route, (history = []));
+  history.push(size);
+  if (history.length > cfg.visits) history.shift();
+  if (history.length < cfg.visits) return;
+  // Any series climbing on every visit to the ratio is growth; which ones
+  // did says what leaked — computations with owners flat is an ownerless
+  // effect per visit, edges alone is a subscription per visit to something
+  // long-lived, owners is an undisposed root.
+  const grew = GRAPH_SERIES.filter(key => {
+    for (let i = 1; i < history.length; i++)
+      if (history[i][key] <= history[i - 1][key]) return false;
+    return history[history.length - 1][key] >= history[0][key] * cfg.ratio;
+  });
+  if (grew.length === 0) return;
+  // The count is the whole graph's, so a leak shows at every route's settle;
+  // the first route to complete its climb reports, naming the others seen.
+  const routes = [...routeCounts.keys()];
+  const series = grew.map(key => `${key} ${history.map(h => h[key]).join(" → ")}`).join("; ");
+  const shape = grew.includes("owners")
+    ? "a createRoot() in an effect or handler with no dispose, or a Portal or panel mounted per visit"
+    : grew.includes("computations")
+      ? "an effect or memo created with no owner (a module-level or callback createEffect) that only its sources keep alive"
+      : "a subscription per visit to something long-lived — a global store or signal read by a computation that outlives the visit";
+  const message =
+    `[GRAPH_GROWTH] the live graph grew on ${cfg.visits} consecutive visits to ${route}: ${series} ` +
+    `(${size.roots} roots)${routes.length > 1 ? `, across visits to ${routes.join(", ")}` : ""}. Each ` +
+    `visit left something behind that the next did not reclaim — the shape says ${shape}. Dispose ` +
+    `what a visit creates (onCleanup, or return the disposer from onSettled) and own it under the ` +
+    `route's component so leaving the route tears it down.`;
+  const data = {
+    route,
+    grew,
+    history: history.map(h => ({ ...h })),
+    roots: size.roots,
+    routes
+  };
+  if (navigation.interaction !== undefined)
+    data.interaction = { type: navigation.interaction.name, target: navigation.interaction.target };
+  reportDiagnostic(
+    emitDiagnostic({ code: "GRAPH_GROWTH", kind: "perf", severity: "warn", message, data }, null)
+  );
+  // Judged once for the graph, not once per route: the next verdict needs
+  // another `visits` climbing settles.
+  routeCounts.clear();
+}
+// --- Feedback-table findings -----------------------------------------------------
+/** Per async source: abandoned flights inside the current window. Engine-side; the node carries nothing. */
+const abandonWindows = new WeakMap();
+/**
+ * One source abandoning flight after flight inside a window: every input
+ * asked again and the earlier answers were thrown away — the
+ * request-per-keystroke signature `feedback().flights[].abandoned` counts,
+ * as a finding while it happens. Warned once per window per source.
+ */
+function checkAbandonedFlights(el, abandoned) {
+  const cfg = options.abandonedFlights;
+  if (cfg === false || excludedNode(el)) return;
+  const at = Date.now();
+  let win = abandonWindows.get(el);
+  if (win === undefined || at - win.start > cfg.windowMs) {
+    win = { start: at, count: 0, warned: false };
+    abandonWindows.set(el, win);
+  }
+  win.count++;
+  if (win.warned || win.count < cfg.count) return;
+  win.warned = true;
+  const source = nodeName(el);
+  const who =
+    abandoned.interaction !== undefined
+      ? ` (${formatOrigin(abandoned.interaction)} started the first)`
+      : "";
+  const message =
+    `[ABANDONED_FLIGHTS] "${source}" abandoned ${win.count} flights in ${cfg.windowMs}ms` +
+    `${who}: each was superseded by the next before it landed, so every input asked again and the ` +
+    `answers were discarded. Put a debounced or equality-gated derivation between the input and ` +
+    `the fetch, or key the fetch on what changes rather than on every keystroke; a preload the ` +
+    `flights share (markFlight) reads as one flight, not many.`;
+  const data = {
+    source,
+    abandoned: win.count,
+    windowMs: cfg.windowMs
+  };
+  if (abandoned.interaction !== undefined)
+    data.interaction = { type: abandoned.interaction.name, target: abandoned.interaction.target };
+  const entry = emitDiagnostic(
+    {
+      code: "ABANDONED_FLIGHTS",
+      kind: "responsiveness",
+      severity: "warn",
+      message,
+      nodeName: source,
+      data
+    },
+    el
+  );
+  reportDiagnostic(entry);
+}
+/**
+ * A fallback that appeared and vanished: the other end of the SILENT_HOLD
+ * spectrum — feedback for a wait too short to need it, which reads as a
+ * flicker. `info`, once per flash; `feedback().fallbacks[].flashes` is the
+ * count. The repair is a preload, a cache, or lifting the fetch above the
+ * boundary so the data is there before the boundary asks.
+ */
+function checkFallbackFlash(subtree, shownMs, interaction) {
+  if (subtree !== undefined && excludedNode(subtree)) return;
+  const where = subtree !== undefined ? ownerPath(subtree)?.join(" › ") : undefined;
+  const who = interaction !== undefined ? `${formatOrigin(interaction)}: ` : "";
+  const message =
+    `[FALLBACK_FLASH] ${who}the Loading fallback${where ? ` at ${where}` : ""} showed for ` +
+    `${shownMs.toFixed(0)}ms — a spinner that appeared and vanished, feedback for a wait too short ` +
+    `to need it. Preload or cache the data so it is there before the boundary asks, or lift the ` +
+    `read above the boundary; a fallback under ${FALLBACK_FLASH_MS}ms reads as a flicker.`;
+  const data = { shownMs };
+  if (interaction !== undefined)
+    data.interaction = { type: interaction.name, target: interaction.target };
+  emitDiagnostic(
+    { code: "FALLBACK_FLASH", kind: "responsiveness", severity: "info", message, data },
+    subtree ?? null
+  );
+}
+/**
+ * Several interactions waiting in one hold when it commits: the person kept
+ * clicking or typing while the first answer was in the air, and all of them
+ * waited on the same source. The pile is the symptom; the hold's own verdict
+ * (SILENT_HOLD / LONG_HOLD) is the cause, so the repair is the same
+ * acknowledgement, plus a control that does not accept the repeat.
+ */
+function checkStackedHolds(t, hold, subject) {
+  const cfg = options.stackedHolds;
+  if (cfg === false) return;
+  let stacked = 0;
+  for (const state of openInteractions) if (state.heldIn.has(t)) stacked++;
+  if (stacked < cfg.count) return;
+  const waitedOn = describeBlockers(hold, "waiting on");
+  const message =
+    `[STACKED_HOLDS] ${stacked} interactions queued behind one hold${waitedOn} for ` +
+    `${hold.holdMs.toFixed(0)}ms: the person kept ${hold.interaction?.name === "input" ? "typing" : "clicking"} ` +
+    `while the first answer was in the air, and every repeat waited on the same source. ` +
+    `Acknowledge the wait where the control is (isPending() to disable or dim it) so the repeats ` +
+    `stop, or debounce the input; the hold itself is judged by SILENT_HOLD/LONG_HOLD.`;
+  const data = holdData(hold);
+  data.interactions = stacked;
+  const entry = emitDiagnostic(
+    {
+      code: "STACKED_HOLDS",
+      kind: "responsiveness",
+      severity: "warn",
+      message,
+      nodeName: nodeName(subject),
+      data
+    },
+    subject
+  );
+  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);
+  }
+}
+let openFlush = null;
+function noteFlushRun(flush, create, interaction) {
+  if (create) flush.created++;
+  else flush.runs++;
+  if (interaction === undefined || flush.interaction === null) return;
+  if (flush.interaction === undefined) flush.interaction = interaction;
+  else if (flush.interaction !== interaction) flush.interaction = null;
+}
+function trackFlushStart() {
+  if (!records.observed("flush")) return;
+  openFlush = { at: now(), runs: 0, created: 0, held: false, interaction: undefined };
+}
+/** The key for swaps no transaction carries — an object, so the map below can be weak. */
+const DRAIN = { drain: true };
+const openFallbacks = new WeakMap();
+// Weak on the transaction: one that is dropped without settling or merging
+// (its boundary disposed, its queues discarded) takes its staged opens with it.
+const stagedFallbacks = new WeakMap();
+/** Bumped by `resetTracking` — the engine's install generation. */
+let trackingGen = 0;
+function trackFallback$1(boundary, tree, shown, transition) {
+  if (shown) {
+    // Folds count showings too, and the flash finding needs the show's
+    // clock: an open is kept for any of the three audiences.
+    const record = records.observed("fallback");
+    if (!record && folds.length === 0 && options.fallbackFlashes === false) return;
+    // The wait is the enclosing recompute's cause's interaction — the read
+    // that registered the pending source runs inside one — else the ambient.
+    const causes = enclosingCauses();
+    const staged = transition ?? DRAIN;
+    const open = {
+      at: now(),
+      gen: trackingGen,
+      record,
+      boundary,
+      tree,
+      interaction: causes !== null ? interactionIn(causes) : (currentInteraction ?? undefined),
+      staged
+    };
+    openFallbacks.set(boundary, open);
+    const list = stagedFallbacks.get(staged);
+    if (list === undefined) stagedFallbacks.set(staged, [open]);
+    else list.push(open);
+    return;
+  }
+  const open = openFallbacks.get(boundary);
+  if (open === undefined) return;
+  openFallbacks.delete(boundary);
+  if (open.staged !== null) {
+    // Cleared before its commit: never on screen.
+    const list = stagedFallbacks.get(open.staged);
+    list.splice(list.indexOf(open), 1);
+    if (list.length === 0) stagedFallbacks.delete(open.staged);
+    return;
+  }
+  if (open.gen !== trackingGen) return;
+  // The hide has the subtree the first show may have lacked.
+  const subtree = tree ?? open.tree;
+  for (const f of folds) f.fallback?.(boundary, subtree, false);
+  const shownMs = now() - open.at;
+  if (options.fallbackFlashes !== false && shownMs < FALLBACK_FLASH_MS)
+    checkFallbackFlash(subtree, shownMs, open.interaction);
+  if (!open.record) return;
+  const event = { at: open.at, shownMs };
+  const path = subtree !== undefined ? ownerPath(subtree) : undefined;
+  if (path !== undefined) event.ownerPath = path;
+  if (open.interaction !== undefined) event.interaction = open.interaction;
+  records.emit("fallback", event, subtree);
+}
+/** flushEnd: the drain's committed swaps have rendered — those fallbacks are on screen from here. */
+function displayFallbacks() {
+  const list = stagedFallbacks.get(DRAIN);
+  if (list === undefined) return;
+  stagedFallbacks.delete(DRAIN);
+  const at = now();
+  for (const open of list) {
+    open.staged = null;
+    open.at = at;
+    if (open.gen === trackingGen)
+      for (const f of folds) f.fallback?.(open.boundary, open.tree, true);
+  }
+}
+/** transitionSettled (`from` a transaction, into this drain) and
+ * transitionMerged (`from` the outgoing, into the surviving transaction):
+ * the swaps staged under `from` now land with `into`. */
+function rebaseFallbacks(from, into) {
+  const list = stagedFallbacks.get(from);
+  if (list === undefined) return;
+  stagedFallbacks.delete(from);
+  for (const open of list) open.staged = into;
+  const target = stagedFallbacks.get(into);
+  if (target === undefined) stagedFallbacks.set(into, list);
+  else target.push(...list);
+}
+/** flushEnd: every open, closed, unheld navigation's (and interaction's) writes just committed. */
+function trackFlushEnd() {
+  // The drain's own record first: the interactions it settles below waited on it.
+  const flush = openFlush;
+  if (flush !== null) {
+    openFlush = null;
+    const event = {
+      at: flush.at,
+      durationMs: now() - flush.at,
+      runs: flush.runs,
+      created: flush.created,
+      held: flush.held
+    };
+    if (flush.interaction != null) event.interaction = flush.interaction;
+    records.emit("flush", event, undefined);
+  }
+  drainSeq++;
+  // The swaps this drain committed have rendered.
+  displayFallbacks();
+  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);
+  records.emit("navigation", event, undefined);
+  trackGraph(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, opened) {
+  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;
+  // The runtime may date the frame from the event's own timestamp (before
+  // any queued task ran); the gap to here is the input delay the browser's
+  // INP counts first.
+  if (opened > event.at) event.inputDelayMs = opened - event.at;
+  const state = {
+    event,
+    open: true,
+    opened,
+    writeDrain: drainSeq,
+    heldIn: new Set(),
+    held: false,
+    excludedWrites: 0,
+    awaiting: false,
+    actioned: false
+  };
+  interactionStates.set(frame, state);
+  openInteractions.add(state);
+  interactionLog.push(event);
+  if (interactionLog.length > options.historyLimit) interactionLog.shift();
+}
+/**
+ * How long the record waits on a handler's returned promise before settling
+ * without it: a promise that never settles (a hung request, a listener
+ * awaiting an event that never comes) must not keep the record open forever.
+ */
+const ASYNC_HANDLER_CAP_MS = 10_000;
+/** interactionEnd: the handler returned. */
+function closeInteraction(frame, returned) {
+  const state = interactionStates.get(frame);
+  if (state === undefined) return;
+  state.open = false;
+  const end = now();
+  state.event.handlerMs = end - state.opened;
+  // `async () => { await save(); set(…) }` returns a promise and continues
+  // past the frame; the person's wait is that continuation. The record stays
+  // open until it settles (or the cap), then judges whether anything on
+  // screen could have shown the wait.
+  const thenable =
+    returned !== null &&
+    (typeof returned === "object" || typeof returned === "function") &&
+    typeof returned.then === "function"
+      ? returned
+      : null;
+  if (thenable !== null) {
+    state.awaiting = true;
+    let done = false;
+    let timer;
+    const settle = () => {
+      if (done) return;
+      done = true;
+      if (timer !== undefined) clearTimeout(timer);
+      if (!openInteractions.has(state)) return;
+      state.awaiting = false;
+      const at = now();
+      state.event.continuationMs = at - end;
+      checkUntrackedAsyncHandler(state);
+      maybeSettleInteraction(state, at);
+    };
+    timer = setTimeout(settle, ASYNC_HANDLER_CAP_MS);
+    // A pending cap must not hold a Node process (tests, SSR harnesses) open.
+    timer.unref?.();
+    // Both branches: a rejected handler promise still ended the wait.
+    thenable.then(settle, settle);
+    return;
+  }
+  maybeSettleInteraction(state, end);
+}
+/**
+ * The handler awaited past its frame with nothing in the graph carrying the
+ * wait: no root write before the `await` (a pending flag, an optimistic
+ * value) and no action step (an action's steps stay attributed across
+ * yields, and its holds are judged by SILENT_HOLD). From the person's side
+ * the click did nothing for `continuationMs`; from the engine's side the
+ * wait is invisible — no hold opened, so no hold could be acknowledged.
+ * Thresholds are the hold thresholds: it is the same wait.
+ */
+function checkUntrackedAsyncHandler(state) {
+  const cfg = options.holds;
+  if (cfg === false) return;
+  const event = state.event;
+  const ms = event.continuationMs;
+  if (state.actioned || event.writes > 0 || ms < cfg.infoMs) return;
+  const actor = formatOrigin(event.origin);
+  const message =
+    `[UNTRACKED_ASYNC_HANDLER] ${actor}'s handler awaited ${ms.toFixed(0)}ms past its frame with no ` +
+    `write before the await: no hold opened, so nothing on screen could show the wait — the ` +
+    `interaction was dead for ${ms.toFixed(0)}ms. Make the async work an action() (its steps stay ` +
+    `attributed across yields and its hold is judged), or write the pending state first: a ` +
+    `createOptimistic(false) "saving" flag the UI reads.`;
+  const severity = ms >= cfg.warnMs ? "warn" : "info";
+  const data = {
+    interaction: { type: event.name, target: event.target },
+    continuationMs: ms,
+    capped: ms >= ASYNC_HANDLER_CAP_MS
+  };
+  const entry = emitDiagnostic(
+    { code: "UNTRACKED_ASYNC_HANDLER", kind: "responsiveness", severity, message, data },
+    null
+  );
+  if (severity === "warn") reportDiagnostic(entry);
+}
+/** 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.awaiting || 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";
+  records.emit("interaction", event, undefined);
+}
+/** 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;
+}
+// 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,
+  flushStart() {
+    trackFlushStart();
+  },
+  flushEnd() {
+    trackFlushEnd();
+  },
+  recomputeStart(el, create) {
+    const causes = create ? null : collectCauses(el);
+    frames.push({
+      start: now(),
+      childMs: 0,
+      causes,
+      // The record's dep diff needs the deps as they were: captured here,
+      // and only when the record will have an audience (see wantsRerun).
+      prevDeps: create || !wantsRerun() ? 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);
+      // The first effect callback runs with no re-run record to inherit from;
+      // hand it the interaction that built the node (see effectRunStart).
+      el._devRunInteraction = frame.interaction;
+      if (openFlush !== null) noteFlushRun(openFlush, true, frame.interaction);
+      if (records.observed("create")) {
+        const event = {
+          at: frame.start,
+          nodeKind: nodeKind(el),
+          nodeName: nodeName(el),
+          nodeId: devId(el),
+          depCount: captureDeps(el).length,
+          selfMs,
+          totalMs,
+          phase: optimistic ? "optimistic" : transition ? "held" : "plain",
+          held
+        };
+        if (frame.interaction !== undefined) event.interaction = frame.interaction;
+        records.emit("create", event, el);
+      }
+    }
+    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);
+    // The frame's own `at` doubles as the record's start: set only while
+    // listened, so a listener arriving mid-callback finds no start and the
+    // end emits nothing for it — and an unlistened callback pays no clock read.
+    if (records.observed("effect")) originFrames[originFrames.length - 1].at = now();
+  },
+  effectRunEnd(el) {
+    const frame = originFrames[originFrames.length - 1];
+    if (frame !== undefined && frame.kind === "effect" && frame.at !== undefined) {
+      if (!excludedNode(el)) {
+        const event = {
+          at: frame.at,
+          durationMs: now() - frame.at,
+          nodeId: devId(el),
+          nodeName: nodeName(el)
+        };
+        if (frame.run !== undefined) event.run = frame.run;
+        if (frame.interaction !== undefined) event.interaction = frame.interaction;
+        records.emit("effect", event, el);
+      }
+    }
+    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);
+      // The handler's async work is an action's: tracked across yields.
+      const state = interaction !== undefined ? interactionStates.get(interaction) : undefined;
+      if (state !== undefined) state.actioned = true;
+    }
+    pushFrame("action", name, interaction);
+  },
+  actionStepEnd() {
+    popFrame("action");
+  },
+  holdStart(t) {
+    if (openFlush !== null) openFlush.held = true;
+    trackHoldStart(t);
+  },
+  holdEnd() {
+    activeHold = null;
+  },
+  transitionSettled(t) {
+    trackHoldSettled(t);
+    rebaseFallbacks(t, DRAIN);
+  },
+  transitionMerged(target, outgoing) {
+    trackHoldMerge(target, outgoing);
+    rebaseFallbacks(outgoing, target);
+  },
+  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, transition) {
+    // The folds hear the show at its display (see trackFallback), not here.
+    trackFallback$1(boundary, tree, shown, transition ?? null);
+  },
+  optimisticReverted(el, shown, truth, how) {
+    checkOptimisticRevert(el, shown, truth, how);
+  },
+  currentOrigin() {
+    return ambientOrigin();
+  }
+};
+const holds = [];
+/**
+ * The windows: what a consumer reads back — the ring buffers, the once-only
+ * warning memories (so a new window can warn again), the hot-cause windows,
+ * the folds' tables. Reset by every `enable()` (each opens a fresh window)
+ * and by the last `disable()`. Never touches the live tracking state —
+ * open frames, open interactions and navigations, the active hold,
+ * `drainSeq` — which belongs to whoever is mid-flight when a second
+ * consumer arrives.
+ */
+function resetWindows() {
+  history = [];
+  waterfallLog = [];
+  holdLog = [];
+  navigationLog = [];
+  interactionLog = [];
+  reportedCycles.clear();
+  relays.clear();
+  immutableReported.clear();
+  hotCauses.clear();
+  for (const f of folds) f.reset?.();
+}
+/** The live tracking state — reset only when the engine is (un)installed. */
+function resetTracking() {
+  frames.length = 0;
+  activeHold = null;
+  openFlush = null;
+  stagedFallbacks.delete(DRAIN);
+  trackingGen++;
+  openNavs.clear();
+  openInteractions.clear();
+  routeCounts.clear();
+  drainSeq = 0;
+  originFrames.length = 0;
+  effectStack.length = 0;
+  interactionStack.length = 0;
+  currentInteraction = null;
+}
+/**
+ * One hold's request in full: the defaults for what it left unsaid (an
+ * explicit `undefined` is unsaid), and `checks: false` folding its five cost
+ * checks off before anyone else's request is considered.
+ */
+function resolveHold(opts) {
+  const out = { ...defaultOptions };
+  if (opts !== undefined) {
+    for (const key of Object.keys(opts)) {
+      const value = opts[key];
+      if (value !== undefined) out[key] = value;
+    }
+  }
+  if (!out.checks) {
+    out.hotRuns = false;
+    out.hotTime = false;
+    out.wideDeps = false;
+    out.unstableMemos = false;
+    out.fanOut = false;
+    out.wastedRecompute = false;
+  }
+  return out;
+}
+/** `values` levels by how much they carry: the merge takes the lowest. */
+const VALUES_RANK = { none: 0, labels: 1, full: 2 };
+/**
+ * The more demanding of two settings for one key: `true` over `false`, the
+ * larger `historyLimit`, a threshold config over `false`, and between two
+ * configs the field values that fire sooner — the lower count, budget or
+ * millisecond bound, the longer `windowMs`. For `values` "more demanding"
+ * is LESS data: the level that carries the least wins, so a holder that
+ * must not see user data is never overruled by one that wants it.
+ */
+function demanding(key, a, b) {
+  if (key === "values") return VALUES_RANK[a] <= VALUES_RANK[b] ? a : b;
+  if (typeof a === "boolean") return a || b;
+  if (key === "historyLimit") return Math.max(a, b);
+  if (a === false) return b;
+  if (b === false) return a;
+  if (typeof a === "number") return Math.min(a, b);
+  const out = {};
+  for (const field in a) {
+    const x = a[field];
+    const y = b[field];
+    out[field] = field === "windowMs" ? Math.max(x, y) : Math.min(x, y);
+  }
+  return out;
+}
+/**
+ * Recompute the options in effect: each live hold's request resolved, then
+ * combined per key by the most demanding value — the one that has the
+ * engine observe more, report more or keep more. A hold says what it wants
+ * and can only add to what another hold asked for, never take it away, so
+ * the result does not depend on the order the holds were taken: the console
+ * log prints while any holder wants it, a check runs while any holder wants
+ * it and at the most sensitive threshold anyone asked for, the ring buffer
+ * is the largest requested, and records carry the least user data any
+ * holder allows (`values`). With no hold outstanding the defaults stand.
+ */
+function applyOptions() {
+  if (holds.length === 0) {
+    options = { ...defaultOptions };
+    return;
+  }
+  const out = resolveHold(holds[0].opts);
+  for (let i = 1; i < holds.length; i++) {
+    const next = resolveHold(holds[i].opts);
+    for (const key in out) out[key] = demanding(key, out[key], next[key]);
+  }
+  options = out;
+}
+/** The last hold is gone (or `disable()` was called): uninstall and clear everything. */
+function uninstall() {
+  holds.length = 0;
+  applyOptions();
+  attributionActive = false;
+  resetWindows();
+  resetTracking();
+  setAttributionHooks(null);
+}
+const attribution = {
+  enable(opts) {
+    const hold = { opts };
+    holds.push(hold);
+    applyOptions();
+    resetWindows();
+    if (!attributionActive) {
+      attributionActive = true;
+      resetTracking();
+      setAttributionHooks(engineHooks);
+    }
+    return () => {
+      const i = holds.indexOf(hold);
+      if (i === -1) return;
+      holds.splice(i, 1);
+      if (holds.length === 0) uninstall();
+      else applyOptions();
+    };
+  },
+  disable() {
+    uninstall();
+  },
+  history(type) {
+    let buffer;
+    switch (type) {
+      case "rerun":
+        buffer = history;
+        break;
+      case "waterfall":
+        buffer = waterfallLog;
+        break;
+      case "hold":
+        buffer = holdLog;
+        break;
+      case "navigation":
+        buffer = navigationLog;
+        break;
+      case "interaction":
+        buffer = interactionLog;
+        break;
+      default:
+        throw new Error(`attribution.history: unknown record type "${String(type)}"`);
+    }
+    // The buffers are typed by their variable; the switch is the proof.
+    return buffer;
+  },
+  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();
+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 = event.silent;
+  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 (event.long) {
+    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 && event.hold.silent) 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 scope — pass a memo/effect accessor or raw node,
+ * or a scope's name as a string (an out-of-process consumer such as the
+ * diagnostics bridge holds no node, only the `nodeName` the records
+ * carry). Records name their scope by `nodeId`; a node that has never run
+ * under the engine has none, and no history. By name, every scope of that
+ * name answers. A view of `history("rerun")`, so it shares that buffer's
+ * gate: runs nothing wanted a record of (no `rerun` listener, fold or log
+ * at the time) left no record and are not here — a console session that
+ * wants them subscribes or imports a fold first.
+ */
+function why(target) {
+  const history = attribution.history("rerun");
+  if (typeof target === "string") return history.filter(event => event.nodeName === target);
+  const id = nodeIdOf(nodeOf(target));
+  if (id === undefined) return [];
+  return history.filter(event => event.nodeId === id);
+}
+/**
+ * Current dependency names of one scope — the devtools subscription view.
+ * Read from the graph, not a record, so it answers with or without an
+ * audience for re-run records (and with the engine disabled).
+ */
+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, graphSize, subscriptions, why };