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

package/dist/dev.attribution.js

@@ -1,14 +1,17 @@
 import {
-  aF as $REFRESH,
-  bp as setAttributionHooks,
+  bK as setAttributionHooks,
   b as NOT_PENDING,
-  bq as ownerPath,
-  al as reportDiagnostic,
-  am as emitDiagnostic,
-  br as isSuppressed,
-  bs as anyExcluded,
-  bt as isExcluded,
-  bu as GRAPH_SIZE_WARN_AT
+  ax as reportDiagnostic,
+  ay as emitDiagnostic,
+  bL as isSuppressed,
+  bM as recordSubject,
+  bN as anyExcluded,
+  bO as isExcluded,
+  q as CONFIG_DERIVED_OVERRIDE,
+  bP as GRAPH_SIZE_WARN_AT,
+  bF as ownerPath,
+  bQ as subjectOf,
+  aT as $REFRESH
 } from "./dev-shared.js";
 
 /**
@@ -51,42 +54,21 @@ function emitRecord(type, record) {
 function clearListeners() {
   for (const type in recordListeners) recordListeners[type].clear();
 }
+/** @internal The engine's clock: `performance.now()` where it exists. */
 const now = typeof performance !== "undefined" ? () => performance.now() : () => Date.now();
 const frames = [];
-const scopeCosts = new Map();
-const writeCosts = new Map();
+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 recordCosts(event) {
-  let scope = scopeCosts.get(event.node);
-  if (scope === undefined) {
-    scope = {
-      name: event.nodeName,
-      kind: event.nodeKind,
-      runs: 0,
-      selfMs: 0,
-      wastedMs: 0,
-      overlayMs: 0
-    };
-    scopeCosts.set(event.node, 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;
-  }
-}
 function nodeName(node) {
   return node._name ?? "anonymous";
 }
@@ -179,6 +161,41 @@ function currentOrigin() {
   if (frame !== undefined) return frame;
   return currentInteraction ?? EXTERNAL_ORIGIN;
 }
+/** The root origin a cause list traces back to — the stamp of the nearest root write, derived links walked. */
+function originIn(causes) {
+  for (const c of causes) {
+    const found =
+      c.kind === "derived" ? (c.causes !== undefined ? originIn(c.causes) : undefined) : c.origin;
+    if (found !== undefined && found.kind !== "external") return found;
+  }
+  return undefined;
+}
+/**
+ * The `currentOrigin` hook: what a runtime recording its own fact right now
+ * (a server-function call) should stamp it with. Inside a recompute the
+ * fact belongs to the change that caused the run — a `createAsync` calling
+ * the server on a navigation's write is the navigation's, and through it the
+ * click's — walked down past create runs the way `trackFlightStart` does,
+ * since a node born inside a parent's run inherits the parent's causality.
+ * Outside one — or when the causes were themselves external (a memo a
+ * handler pulls, stale from a timer's write) — it is the write's answer
+ * (`currentOrigin`), minus the external sentinel: "none known" is
+ * `undefined` on a record, as `HoldEvent.origin` has it. The objects
+ * returned are the engine's own frames, so the caller's record joins
+ * `InteractionEvent.origin` / `NavigationEvent.origin` by identity.
+ */
+function ambientOrigin() {
+  for (let i = frames.length - 1; i >= 0; i--) {
+    const causes = frames[i].causes;
+    if (causes !== null) {
+      const cause = originIn(causes);
+      if (cause !== undefined) return cause;
+      break;
+    }
+  }
+  const origin = currentOrigin();
+  return origin === EXTERNAL_ORIGIN ? undefined : origin;
+}
 const effectFrames = new WeakMap();
 /** The interaction the innermost open frame runs under, else the ambient one. */
 function enclosingInteraction() {
@@ -324,7 +341,7 @@ function stampWrite(node, kind, prev = NO_VALUES, value = NO_VALUES) {
   const prior = node._devChange;
   node._devChange = record;
   noteNavigationWrite(prior, record);
-  noteInteractionWrite(record.origin);
+  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
@@ -361,10 +378,20 @@ function collectCauses(el) {
 function markSeen(el) {
   el._devSeenSeq = changeSeq;
 }
-/** Snapshot the node's current dep identities (call before a run replaces them). */
+/**
+ * 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);
+  for (let l = el._deps; l !== null; l = l._nextDep) {
+    deps.push(l._dep);
+    if (l === el._depsTail) break;
+  }
   return deps;
 }
 /**
@@ -381,6 +408,7 @@ function checkDepWidth(el) {
   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;
@@ -558,7 +586,7 @@ function recordRerun(el, frame, timing, changed, phase, held) {
     nodeRuns: (node._devRunCount = (node._devRunCount ?? 0) + 1),
     nodeKind: el._type ? "effect" : "memo",
     nodeName: nodeName(el),
-    node: el,
+    nodeId: devId(el),
     causes,
     depCount: newDeps.length,
     depsAdded,
@@ -577,10 +605,13 @@ function recordRerun(el, frame, timing, changed, phase, held) {
   node._devRunInteraction = interaction;
   node._devRunSeq = event.run;
   node._devRunCauses = causes;
+  // The record is serializable and never carries the node; keep the node
+  // beside it for `OBSERVE.subjectOf` and the engine's own joins (effect
+  // cycles, relay tears, `why()`), for as long as anyone holds the record.
+  recordSubject(event, el);
   history.push(event);
   if (history.length > options.historyLimit) history.shift();
-  recordCosts(event);
-  recordFeedbackRun(event);
+  for (const f of folds) f.rerun?.(el, event);
   noteInteractionRun(interaction, timing.selfMs, false);
   if (event.nodeKind === "effect") checkEffectCycle(el, causes);
   checkRelayTear(el, causes, prevCauses);
@@ -1015,7 +1046,7 @@ function checkRelayTear(victim, causes, prevCauses) {
 // 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) {
+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.
@@ -1035,16 +1066,23 @@ function checkImmutableUpdate(path, isArray, total, same, prevTotal) {
     `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}).`;
-  const entry = emitDiagnostic({
-    code: "IMMUTABLE_UPDATE_IN_STORE",
-    kind: "perf",
-    severity: "warn",
-    message,
-    nodeName: path,
-    data: { path, shape, total, unchanged: same, changed }
-  });
-  // Paths are not unique across stores: a write under an excluded owner
-  // (an adapter's own "store.list") must not spend the app's once-per-path slot.
+  // 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);
@@ -1160,9 +1198,7 @@ function trackFlightStart(el, flight) {
   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 stats = flightBucket(el);
-  stats.flights++;
-  if (liveFlights.has(el)) stats.abandoned++;
+  for (const f of folds) f.flightStart?.(el, liveFlights.has(el));
   // Nearest enclosing frame with causes: create runs carry null (a node born
   // inside a parent's recompute inherits the parent's causality — the
   // boundary-reveal case, and the lazy sibling whose first pull is gated
@@ -1200,10 +1236,7 @@ function finalizeFlight(el) {
   liveFlights.delete(el);
   const landedAt = now();
   const ms = landedAt - flight.origin;
-  const stats = flightBucket(el);
-  stats.landed++;
-  stats.landedMs += ms;
-  if (ms > stats.worstMs) stats.worstMs = ms;
+  for (const f of folds) f.flightLanded?.(el, ms);
   const record = el._devChange;
   // Only a stamp this landing produced may carry the measurement — a stale
   // async record from a previous landing must not be re-labeled.
@@ -1266,9 +1299,14 @@ function checkWaterfall(el, chain, ms) {
 const holdStates = new WeakMap();
 let activeHold = null;
 let holdLog = [];
-/** Companions are optimistic nodes too; `_parentSource` marks them. */
+/** 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;
+  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) {
@@ -1461,11 +1499,12 @@ function trackHoldSettled(t) {
   emitRecord("hold", event);
   settleNavigations(t, event);
   settleInteractionsHeld(t, event);
-  recordFeedbackHold(event);
+  for (const f of folds) f.hold?.(event);
   if (isSilentHold(event)) checkSilentHold(event, subject);
   else checkLongHold(event, subject);
 }
 /** `isLongHold` — the tail outlasted `longHolds.infoMs`. */
+/** @internal */
 function isLongHold(event) {
   const cfg = options.longHolds;
   return cfg !== false && cfg !== undefined && event.tailMs >= cfg.infoMs;
@@ -1735,7 +1774,7 @@ function settleNavigation(state, outcome, hold) {
   event.settledMs = now() - event.at;
   event.outcome = outcome;
   if (hold !== undefined) event.hold = hold;
-  recordFeedbackNavigation(event);
+  for (const f of folds) f.navigation?.(event);
   emitRecord("navigation", event);
   // The interaction that performed it may have been waiting only on this.
   const under = openInteractionOf(event.interaction);
@@ -1764,7 +1803,8 @@ function openInteraction(frame) {
     open: true,
     writeDrain: drainSeq,
     heldIn: new Set(),
-    held: false
+    held: false,
+    excludedWrites: 0
   };
   interactionStates.set(frame, state);
   openInteractions.add(state);
@@ -1788,9 +1828,13 @@ function openInteractionOf(origin) {
   return state !== undefined && openInteractions.has(state) ? state : undefined;
 }
 /** stampWrite: a root write stamped `origin`. */
-function noteInteractionWrite(origin) {
+function noteInteractionWrite(origin, excluded) {
   const state = openInteractionOf(origin);
   if (state === undefined) return;
+  if (excluded) {
+    state.excludedWrites++;
+    return;
+  }
   state.event.writes++;
   state.writeDrain = drainSeq;
 }
@@ -1839,6 +1883,14 @@ function maybeSettleInteraction(state, end = now()) {
   if (event.writes > 0 && drainSeq <= state.writeDrain) return;
   for (const nav of event.navigations) if (nav.outcome === undefined) return;
   openInteractions.delete(state);
+  // Every write went to an excluded subject and nothing of the app's ran: the
+  // click was on the observer's own UI (a devtools panel's button). Not a
+  // fact about the app — forget it rather than report a dead interaction.
+  if (event.writes === 0 && state.excludedWrites > 0 && event.runs === 0 && event.created === 0) {
+    const i = interactionLog.indexOf(event);
+    if (i !== -1) interactionLog.splice(i, 1);
+    return;
+  }
   event.settledMs = end - event.at;
   event.outcome = event.writes === 0 ? "idle" : state.held ? "held" : "committed";
   emitRecord("interaction", event);
@@ -1852,209 +1904,10 @@ function navigationData(origin) {
   if (origin.params !== undefined) data.params = origin.params;
   return data;
 }
-const feedbackSources = new Map();
-const feedbackInteractions = new Map();
-const feedbackNavigations = new Map();
-const flightStats = new Map();
-const fallbackStats = new Map();
-const FALLBACK_FLASH_MS = 150;
-function flightBucket(el) {
-  let row = flightStats.get(el);
-  if (row === undefined) {
-    row = { source: nodeName(el), flights: 0, landed: 0, abandoned: 0, landedMs: 0, worstMs: 0 };
-    flightStats.set(el, row);
-  }
-  return row;
-}
-function trackFallback(boundary, tree, shown) {
-  let bucket = fallbackStats.get(boundary);
-  if (bucket === undefined) {
-    bucket = {
-      row: { boundary: "boundary", shows: 0, shownMs: 0, worstMs: 0, flashes: 0 },
-      shownAt: null
-    };
-    fallbackStats.set(boundary, bucket);
-  }
-  // The first show can fire before the subtree exists; name on first sight.
-  if (bucket.row.boundary === "boundary" && tree !== undefined) {
-    const path = ownerPath(tree);
-    if (path !== undefined) bucket.row.boundary = path.join(" › ");
-  }
-  if (shown) {
-    if (bucket.shownAt === null) {
-      bucket.shownAt = now();
-      bucket.row.shows++;
-    }
-    return;
-  }
-  if (bucket.shownAt === null) return;
-  const ms = now() - bucket.shownAt;
-  bucket.shownAt = null;
-  bucket.row.shownMs += ms;
-  if (ms > bucket.row.worstMs) bucket.row.worstMs = ms;
-  if (ms < FALLBACK_FLASH_MS) bucket.row.flashes++;
-}
-/** No affordance answered and nothing painted while held. */
+/** @internal No affordance answered and nothing painted while held. */
 function isSilentHold(event) {
   return event.paintedDuringHold === 0 && event.acknowledgements.length === 0;
 }
-function interactionBucket(interaction) {
-  const key = formatOrigin(interaction);
-  let bucket = feedbackInteractions.get(key);
-  if (bucket === undefined) {
-    bucket = {
-      row: {
-        interaction: key,
-        dispatches: 0,
-        runs: 0,
-        selfMs: 0,
-        worstDispatchMs: 0,
-        holds: 0,
-        heldMs: 0,
-        silentMs: 0,
-        worstHoldMs: 0
-      },
-      dispatches: new Map()
-    };
-    feedbackInteractions.set(key, bucket);
-  }
-  const at = interaction.at ?? 0;
-  if (!bucket.dispatches.has(at)) {
-    bucket.dispatches.set(at, 0);
-    bucket.row.dispatches++;
-  }
-  return bucket;
-}
-function recordFeedbackRun(event) {
-  if (event.interaction === undefined) return;
-  const bucket = interactionBucket(event.interaction);
-  bucket.row.runs++;
-  bucket.row.selfMs += event.selfMs;
-  const at = event.interaction.at ?? 0;
-  const dispatchMs = bucket.dispatches.get(at) + event.selfMs;
-  bucket.dispatches.set(at, dispatchMs);
-  if (dispatchMs > bucket.row.worstDispatchMs) bucket.row.worstDispatchMs = dispatchMs;
-}
-function recordFeedbackHold(event) {
-  const sources = [...event.blockers].sort();
-  const key = sources.join("\u0000");
-  let bucket = feedbackSources.get(key);
-  if (bucket === undefined) {
-    bucket = {
-      row: {
-        sources,
-        holds: 0,
-        heldMs: 0,
-        worstMs: 0,
-        silent: 0,
-        silentMs: 0,
-        latestOnly: 0,
-        long: 0,
-        longMs: 0,
-        acknowledgedBy: [],
-        interactions: [],
-        writes: [],
-        actions: 0
-      },
-      acks: new Map(),
-      interactions: new Map(),
-      writes: new Set()
-    };
-    feedbackSources.set(key, bucket);
-  }
-  const row = bucket.row;
-  const silent = isSilentHold(event);
-  row.holds++;
-  row.heldMs += event.holdMs;
-  if (event.holdMs > row.worstMs) row.worstMs = event.holdMs;
-  if (silent) {
-    row.silent++;
-    row.silentMs += event.holdMs;
-  } else if (
-    event.acknowledgements.length > 0 &&
-    event.acknowledgements.every(a => a.kind === "latest")
-  )
-    row.latestOnly++;
-  if (isLongHold(event)) {
-    row.long++;
-    row.longMs += event.tailMs;
-  }
-  if (event.action) row.actions++;
-  for (const a of event.acknowledgements) {
-    const by = `${a.kind}:${a.source}`;
-    bucket.acks.set(by, (bucket.acks.get(by) ?? 0) + 1);
-  }
-  for (const w of event.heldWrites) bucket.writes.add(w.name);
-  if (event.interaction !== undefined) {
-    const key = formatOrigin(event.interaction);
-    bucket.interactions.set(key, (bucket.interactions.get(key) ?? 0) + 1);
-    const ib = interactionBucket(event.interaction);
-    ib.row.holds++;
-    ib.row.heldMs += event.holdMs;
-    if (silent) ib.row.silentMs += event.holdMs;
-    if (event.holdMs > ib.row.worstHoldMs) ib.row.worstHoldMs = event.holdMs;
-  }
-}
-function recordFeedbackNavigation(event) {
-  const name = event.name ?? event.to;
-  if (name === undefined) return;
-  let row = feedbackNavigations.get(name);
-  if (row === undefined) {
-    row = {
-      name,
-      navigations: 0,
-      settledMs: 0,
-      worstMs: 0,
-      held: 0,
-      heldMs: 0,
-      silent: 0,
-      superseded: 0,
-      redirected: 0
-    };
-    feedbackNavigations.set(name, row);
-  }
-  row.navigations++;
-  if (event.redirects !== undefined) row.redirected++;
-  if (event.outcome === "superseded") {
-    row.superseded++;
-    return;
-  }
-  const ms = event.settledMs;
-  row.settledMs += ms;
-  if (ms > row.worstMs) row.worstMs = ms;
-  if (event.outcome === "held") {
-    row.held++;
-    row.heldMs += event.hold?.holdMs ?? ms;
-    if (event.hold !== undefined && isSilentHold(event.hold)) row.silent++;
-  }
-}
-function rankedCounts(counts, key) {
-  return [...counts].sort((a, b) => b[1] - a[1]).map(([name, holds]) => ({ [key]: name, holds }));
-}
-function feedbackTables() {
-  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 };
-}
 // 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.
@@ -2213,28 +2066,26 @@ const engineHooks = {
   transitionMerged(target, outgoing) {
     trackHoldMerge(target, outgoing);
   },
-  storeReplaced(path, isArray, total, unchanged, prevTotal) {
-    checkImmutableUpdate(path, isArray, total, unchanged, prevTotal);
+  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) {
-    trackFallback(boundary, tree, shown);
+    for (const f of folds) f.fallback?.(boundary, tree, shown);
+  },
+  currentOrigin() {
+    return ambientOrigin();
   }
 };
 const attribution = {
   enable(opts) {
     options = { ...defaultOptions, ...opts };
     frames.length = 0;
-    scopeCosts.clear();
-    writeCosts.clear();
     waterfallLog = [];
     holdLog = [];
     activeHold = null;
-    feedbackSources.clear();
-    feedbackInteractions.clear();
-    feedbackNavigations.clear();
     navigationLog = [];
     openNavs.clear();
     interactionLog = [];
@@ -2243,26 +2094,20 @@ const attribution = {
     reportedCycles.clear();
     relays.clear();
     immutableReported.clear();
-    flightStats.clear();
-    fallbackStats.clear();
     originFrames.length = 0;
     interactionStack.length = 0;
     currentInteraction = null;
     hotCauses.clear();
+    for (const f of folds) f.reset?.();
     setAttributionHooks(engineHooks);
   },
   disable() {
     clearListeners();
     history = [];
     frames.length = 0;
-    scopeCosts.clear();
-    writeCosts.clear();
     waterfallLog = [];
     holdLog = [];
     activeHold = null;
-    feedbackSources.clear();
-    feedbackInteractions.clear();
-    feedbackNavigations.clear();
     navigationLog = [];
     openNavs.clear();
     interactionLog = [];
@@ -2271,12 +2116,11 @@ const attribution = {
     reportedCycles.clear();
     relays.clear();
     immutableReported.clear();
-    flightStats.clear();
-    fallbackStats.clear();
     originFrames.length = 0;
     interactionStack.length = 0;
     currentInteraction = null;
     hotCauses.clear();
+    for (const f of folds) f.reset?.();
     setAttributionHooks(null);
   },
   subscribe(typeOrListener, listener) {
@@ -2289,22 +2133,6 @@ const attribution = {
   history() {
     return history;
   },
-  why(target) {
-    const node = target?.[$REFRESH] ?? target;
-    return history.filter(event => event.node === node);
-  },
-  subscriptions(target) {
-    const node = target?.[$REFRESH] ?? target;
-    const names = [];
-    for (let l = node?._deps ?? null; l !== null; l = l._nextDep) names.push(nodeName(l._dep));
-    return names;
-  },
-  costs() {
-    return {
-      scopes: [...scopeCosts.values()].sort((a, b) => b.selfMs - a.selfMs),
-      writes: [...writeCosts.values()].sort((a, b) => b.downstreamMs - a.downstreamMs)
-    };
-  },
   waterfalls() {
     return waterfallLog;
   },
@@ -2317,17 +2145,341 @@ const attribution = {
   interactions() {
     return interactionLog;
   },
-  feedback() {
-    return feedbackTables();
-  },
   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);
-  },
-  format: formatRerun,
-  formatOrigin
+  }
 };
 
-export { attribution };
+/**
+ * `costs()` — the cost tables: scopes ranked by the self-time they burn,
+ * root writes ranked by the downstream re-run time they cause. Folded from
+ * every `RerunEvent` as the engine records it.
+ *
+ * Its own module on purpose: the tables register with the engine's fold seam
+ * when this module is evaluated, so an observe-tier consumer that only
+ * subscribes to records (an APM adapter) never ships the accumulation or the
+ * tables; a consumer that imports `costs` gets both. Reset with the engine on
+ * `enable()`/`disable()`.
+ */
+const scopeCosts = new Map();
+const writeCosts = new Map();
+function recordCosts(el, event) {
+  let scope = scopeCosts.get(el);
+  if (scope === undefined) {
+    scope = {
+      name: event.nodeName,
+      kind: event.nodeKind,
+      runs: 0,
+      selfMs: 0,
+      wastedMs: 0,
+      overlayMs: 0
+    };
+    scopeCosts.set(el, scope);
+  }
+  scope.runs++;
+  scope.selfMs += event.selfMs;
+  if (event.phase !== "plain") scope.overlayMs += event.selfMs;
+  else if (!event.changed && !event.held) scope.wastedMs += event.selfMs;
+  const roots = new Set();
+  rootsOf(event.causes, roots);
+  for (const name of roots) {
+    let write = writeCosts.get(name);
+    if (write === undefined) writeCosts.set(name, (write = { name, runs: 0, downstreamMs: 0 }));
+    write.runs++;
+    write.downstreamMs += event.selfMs;
+  }
+}
+registerFold({
+  rerun: recordCosts,
+  reset() {
+    scopeCosts.clear();
+    writeCosts.clear();
+  }
+});
+/**
+ * Aggregated cost tables since `enable()`: `scopes` ranked by self-time
+ * (with `wastedMs` = time spent on unchanged-value runs), `writes` ranked by
+ * total downstream re-run time each root write caused.
+ */
+function costs() {
+  return {
+    scopes: [...scopeCosts.values()].sort((a, b) => b.selfMs - a.selfMs),
+    writes: [...writeCosts.values()].sort((a, b) => b.downstreamMs - a.downstreamMs)
+  };
+}
+
+/**
+ * `feedback()` — what the user waited on, as ranked tables. Folded from the
+ * records the engine already keeps (holds, the interaction on each re-run,
+ * navigations) and two censuses the engine reports as they happen (flights
+ * started/landed/abandoned per async source; fallback shows per boundary).
+ *
+ * Its own module on purpose: the tables register with the engine's fold seam
+ * when this module is evaluated, so an observe-tier consumer that only
+ * subscribes to records never ships them. Reset with the engine on
+ * `enable()`/`disable()`.
+ */
+const feedbackSources = new Map();
+const feedbackInteractions = new Map();
+const feedbackNavigations = new Map();
+const flightStats = new Map();
+const fallbackStats = new Map();
+const FALLBACK_FLASH_MS = 150;
+function flightBucket(el) {
+  let row = flightStats.get(el);
+  if (row === undefined) {
+    row = { source: nodeName(el), flights: 0, landed: 0, abandoned: 0, landedMs: 0, worstMs: 0 };
+    flightStats.set(el, row);
+  }
+  return row;
+}
+function trackFallback(boundary, tree, shown) {
+  let bucket = fallbackStats.get(boundary);
+  if (bucket === undefined) {
+    bucket = {
+      row: { boundary: "boundary", shows: 0, shownMs: 0, worstMs: 0, flashes: 0 },
+      shownAt: null
+    };
+    fallbackStats.set(boundary, bucket);
+  }
+  // The first show can fire before the subtree exists; name on first sight.
+  if (bucket.row.boundary === "boundary" && tree !== undefined) {
+    const path = ownerPath(tree);
+    if (path !== undefined) bucket.row.boundary = path.join(" › ");
+  }
+  if (shown) {
+    if (bucket.shownAt === null) {
+      bucket.shownAt = now();
+      bucket.row.shows++;
+    }
+    return;
+  }
+  if (bucket.shownAt === null) return;
+  const ms = now() - bucket.shownAt;
+  bucket.shownAt = null;
+  bucket.row.shownMs += ms;
+  if (ms > bucket.row.worstMs) bucket.row.worstMs = ms;
+  if (ms < FALLBACK_FLASH_MS) bucket.row.flashes++;
+}
+function interactionBucket(interaction) {
+  const key = formatOrigin(interaction);
+  let bucket = feedbackInteractions.get(key);
+  if (bucket === undefined) {
+    bucket = {
+      row: {
+        interaction: key,
+        dispatches: 0,
+        runs: 0,
+        selfMs: 0,
+        worstDispatchMs: 0,
+        holds: 0,
+        heldMs: 0,
+        silentMs: 0,
+        worstHoldMs: 0
+      },
+      dispatches: new Map()
+    };
+    feedbackInteractions.set(key, bucket);
+  }
+  const at = interaction.at ?? 0;
+  if (!bucket.dispatches.has(at)) {
+    bucket.dispatches.set(at, 0);
+    bucket.row.dispatches++;
+  }
+  return bucket;
+}
+function recordFeedbackRun(event) {
+  if (event.interaction === undefined) return;
+  const bucket = interactionBucket(event.interaction);
+  bucket.row.runs++;
+  bucket.row.selfMs += event.selfMs;
+  const at = event.interaction.at ?? 0;
+  const dispatchMs = bucket.dispatches.get(at) + event.selfMs;
+  bucket.dispatches.set(at, dispatchMs);
+  if (dispatchMs > bucket.row.worstDispatchMs) bucket.row.worstDispatchMs = dispatchMs;
+}
+function recordFeedbackHold(event) {
+  const sources = [...event.blockers].sort();
+  const key = sources.join("\u0000");
+  let bucket = feedbackSources.get(key);
+  if (bucket === undefined) {
+    bucket = {
+      row: {
+        sources,
+        holds: 0,
+        heldMs: 0,
+        worstMs: 0,
+        silent: 0,
+        silentMs: 0,
+        latestOnly: 0,
+        long: 0,
+        longMs: 0,
+        acknowledgedBy: [],
+        interactions: [],
+        writes: [],
+        actions: 0
+      },
+      acks: new Map(),
+      interactions: new Map(),
+      writes: new Set()
+    };
+    feedbackSources.set(key, bucket);
+  }
+  const row = bucket.row;
+  const silent = isSilentHold(event);
+  row.holds++;
+  row.heldMs += event.holdMs;
+  if (event.holdMs > row.worstMs) row.worstMs = event.holdMs;
+  if (silent) {
+    row.silent++;
+    row.silentMs += event.holdMs;
+  } else if (
+    event.acknowledgements.length > 0 &&
+    event.acknowledgements.every(a => a.kind === "latest")
+  )
+    row.latestOnly++;
+  if (isLongHold(event)) {
+    row.long++;
+    row.longMs += event.tailMs;
+  }
+  if (event.action) row.actions++;
+  for (const a of event.acknowledgements) {
+    const by = `${a.kind}:${a.source}`;
+    bucket.acks.set(by, (bucket.acks.get(by) ?? 0) + 1);
+  }
+  for (const w of event.heldWrites) bucket.writes.add(w.name);
+  if (event.interaction !== undefined) {
+    const key = formatOrigin(event.interaction);
+    bucket.interactions.set(key, (bucket.interactions.get(key) ?? 0) + 1);
+    const ib = interactionBucket(event.interaction);
+    ib.row.holds++;
+    ib.row.heldMs += event.holdMs;
+    if (silent) ib.row.silentMs += event.holdMs;
+    if (event.holdMs > ib.row.worstHoldMs) ib.row.worstHoldMs = event.holdMs;
+  }
+}
+function recordFeedbackNavigation(event) {
+  const name = event.name ?? event.to;
+  if (name === undefined) return;
+  let row = feedbackNavigations.get(name);
+  if (row === undefined) {
+    row = {
+      name,
+      navigations: 0,
+      settledMs: 0,
+      worstMs: 0,
+      held: 0,
+      heldMs: 0,
+      silent: 0,
+      superseded: 0,
+      redirected: 0
+    };
+    feedbackNavigations.set(name, row);
+  }
+  row.navigations++;
+  if (event.redirects !== undefined) row.redirected++;
+  if (event.outcome === "superseded") {
+    row.superseded++;
+    return;
+  }
+  const ms = event.settledMs;
+  row.settledMs += ms;
+  if (ms > row.worstMs) row.worstMs = ms;
+  if (event.outcome === "held") {
+    row.held++;
+    row.heldMs += event.hold?.holdMs ?? ms;
+    if (event.hold !== undefined && isSilentHold(event.hold)) row.silent++;
+  }
+}
+function rankedCounts(counts, key) {
+  return [...counts].sort((a, b) => b[1] - a[1]).map(([name, holds]) => ({ [key]: name, holds }));
+}
+registerFold({
+  rerun: (_el, event) => recordFeedbackRun(event),
+  hold: recordFeedbackHold,
+  navigation: recordFeedbackNavigation,
+  flightStart(el, abandoned) {
+    const stats = flightBucket(el);
+    stats.flights++;
+    if (abandoned) stats.abandoned++;
+  },
+  flightLanded(el, ms) {
+    const stats = flightBucket(el);
+    stats.landed++;
+    stats.landedMs += ms;
+    if (ms > stats.worstMs) stats.worstMs = ms;
+  },
+  fallback: trackFallback,
+  reset() {
+    feedbackSources.clear();
+    feedbackInteractions.clear();
+    feedbackNavigations.clear();
+    flightStats.clear();
+    fallbackStats.clear();
+  }
+});
+/**
+ * What the user waited on, folded from holds and the interaction on each
+ * re-run: `sources` ranks async sources by the silent time writes spent held
+ * behind them (with which affordances answered, how often, and which
+ * interactions were held); `interactions` ranks user events by the total time
+ * they cost — re-run work caused (long-flush hazard) beside time held
+ * (silent-hold hazard). Facts at every duration; SILENT_HOLD is the
+ * thresholded verdict. Three more tables round out the picture: `navigations`
+ * ranks routes by the time spent held navigating to them (folded from settled
+ * navigations), `flights` counts each async source's flights and how many
+ * were abandoned before landing (the re-ask storm), and `fallbacks` measures
+ * how long each loading boundary showed its fallback and how often that was a
+ * flash.
+ */
+function feedback() {
+  const navigations = [...feedbackNavigations.values()]
+    .map(row => ({ ...row }))
+    .sort((a, b) => b.heldMs - a.heldMs || b.settledMs - a.settledMs);
+  const flights = [...flightStats.values()]
+    .map(row => ({ ...row }))
+    .sort((a, b) => b.abandoned - a.abandoned || b.flights - a.flights);
+  const fallbacks = [...fallbackStats.values()]
+    .map(bucket => ({ ...bucket.row }))
+    .sort((a, b) => b.flashes - a.flashes || b.shownMs - a.shownMs);
+  const sources = [...feedbackSources.values()]
+    .map(bucket => ({
+      ...bucket.row,
+      acknowledgedBy: rankedCounts(bucket.acks, "by"),
+      interactions: rankedCounts(bucket.interactions, "interaction"),
+      writes: [...bucket.writes]
+    }))
+    .sort((a, b) => b.silentMs - a.silentMs || b.heldMs - a.heldMs);
+  // Ranked by the total time the user spent on it: held plus synchronous work.
+  const interactions = [...feedbackInteractions.values()]
+    .map(bucket => ({ ...bucket.row }))
+    .sort((a, b) => b.heldMs + b.selfMs - (a.heldMs + a.selfMs));
+  return { sources, interactions, navigations, flights, fallbacks };
+}
+
+/**
+ * Point queries over the engine's live state — the devtools/console view of
+ * one scope. Their own module so a records-only consumer never ships them;
+ * they read the engine's ring buffer and the graph, and register nothing.
+ */
+/** The node behind a memo/effect accessor, or the raw node passed through. */
+function nodeOf(target) {
+  return target?.[$REFRESH] ?? target;
+}
+/** Re-run history for one node — pass a memo/effect accessor or raw node. */
+function why(target) {
+  const node = nodeOf(target);
+  return attribution.history().filter(event => subjectOf(event) === node);
+}
+/** Current dependency names of one scope — the devtools subscription view. */
+function subscriptions(target) {
+  const node = nodeOf(target);
+  const names = [];
+  for (let l = node?._deps ?? null; l !== null; l = l._nextDep) names.push(nodeName(l._dep));
+  return names;
+}
+
+export { attribution, costs, feedback, formatOrigin, formatRerun, subscriptions, why };