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

package/dist/observe/core/attribution.js

@@ -0,0 +1,2095 @@
+import { setAttributionHooks } from "./attribution-hooks.js";
+
+import { NOT_PENDING, CONFIG_DERIVED_OVERRIDE } from "./constants.js";
+
+import { reportDiagnostic, emitDiagnostic, isSuppressed, recordSubject, anyExcluded, isExcluded, GRAPH_SIZE_WARN_AT, ownerPath } from "./dev.js";
+
+/**
+ * Under an owner the observer marked as its own (`OBSERVE.exclude`): the
+ * engine records nothing about the node. Cached per node once any exclusion
+ * exists; before that the answer is a flag read.
+ */ function excludedNode(e) {
+    if (!anyExcluded()) return false;
+    const n = e;
+    if (n.me === undefined) n.me = isExcluded(e);
+    return n.me;
+}
+
+let changeSeq = 0;
+
+let runSeq = 0;
+
+const defaultOptions = {
+    log: true,
+    stacks: false,
+    historyLimit: 200,
+    hotRuns: {
+        count: 120,
+        windowMs: 1e3
+    },
+    wideDeps: 30,
+    hotTime: {
+        budgetMs: 8,
+        windowMs: 1e3
+    },
+    unstableMemos: 4,
+    wideWrites: 250,
+    waterfalls: {
+        minFlightMs: 50
+    },
+    holds: {
+        infoMs: 100,
+        warnMs: 200
+    },
+    longHolds: {
+        infoMs: 500,
+        warnMs: 1e3
+    }
+};
+
+let options = {
+    ...defaultOptions
+};
+
+let history = [];
+
+const recordListeners = {
+    rerun: new Set,
+    interaction: new Set,
+    hold: new Set,
+    navigation: new Set
+};
+
+function emitRecord(e, n) {
+    for (const t of recordListeners[e]) t(n);
+}
+
+function clearListeners() {
+    for (const e in recordListeners) recordListeners[e].clear();
+}
+
+/** @internal The engine's clock: `performance.now()` where it exists. */ const now = typeof performance !== "undefined" ? () => performance.now() : () => Date.now();
+
+const frames = [];
+
+const folds = [];
+
+/** @internal */ function registerFold(e) {
+    folds.push(e);
+}
+
+/** @internal Root cause names of a cause chain — the writes/landings/refreshes the chain bottoms out in. */ function rootsOf(e, n) {
+    for (const t of e) {
+        if (t.kind === "derived" && t.causes && t.causes.length > 0) rootsOf(t.causes, n); else n.add(t.name);
+    }
+}
+
+function nodeName(e) {
+    return e._name ?? "anonymous";
+}
+
+function preview(e) {
+    if (e === null) return "null";
+    switch (typeof e) {
+      case "undefined":
+        return "undefined";
+
+      case "string":
+        return JSON.stringify(e.length > 40 ? e.slice(0, 40) + "…" : e);
+
+      case "number":
+      case "boolean":
+      case "bigint":
+        return String(e);
+
+      case "function":
+        return "[function]";
+
+      case "symbol":
+        return e.toString();
+
+      default:
+        return Array.isArray(e) ? `Array(${e.length})` : `[${e.constructor?.name ?? "object"}]`;
+    }
+}
+
+function captureStack() {
+    if (!options.stacks) return undefined;
+    const e = (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 e.slice(1).filter(e => !/(?:^|[/\\])(?:packages[/\\])?signals[/\\](src|dist)[/\\]/.test(e)).slice(0, 3).map(e => e.trim());
+}
+
+/** Sentinel for "no value transition to record" (refresh() stamps). */ const NO_VALUES = Symbol("no-values");
+
+// --- Provenance -------------------------------------------------------------
+
+// Who performed a write is not a graph fact — the graph only sees the write.
+// The engine keeps an ambient answer: a stack of imperative frames the core
+// announces (effect callbacks, action steps) and the interaction the web
+// runtime declares around event dispatch. A write stamps the innermost frame;
+// frames nested under an interaction carry it. Effects run in a later flush
+// than the click that caused them, so their frame inherits the interaction
+// from the run's cause chain instead (recorded at recomputeEnd).
+const EXTERNAL_ORIGIN = {
+    kind: "external"
+};
+
+const originFrames = [];
+
+/** Per action invocation (keyed by its iterator): the interaction its first step ran under. */ const actionInteractions = new WeakMap;
+
+/**
+ * The interaction frame the core's `withInteraction` opened (via the
+ * `interactionStart`/`interactionEnd` hooks) for the duration of a handler.
+ * Frames nest strictly, so the enclosing one is kept on a stack to restore.
+ * The core pins the engine per frame: an `interactionEnd` can arrive after
+ * `disable()` cleared the stack, so popping an empty stack is tolerated.
+ */ let currentInteraction = null;
+
+const interactionStack = [];
+
+function interactionStart(e) {
+    interactionStack.push(currentInteraction);
+    const n = {
+        kind: "interaction",
+        name: e.type,
+        at: e.at ?? now()
+    };
+    if (e.target) n.target = e.target;
+    currentInteraction = n;
+    openInteraction(n);
+}
+
+function interactionEnd() {
+    const e = currentInteraction;
+    currentInteraction = interactionStack.length ? interactionStack.pop() : null;
+    if (e !== null) closeInteraction(e);
+}
+
+/** The interaction an origin runs under (itself, when it is one). */ function interactionOf(e) {
+    if (e === undefined) return undefined;
+    return e.kind === "interaction" ? e : e.interaction;
+}
+
+/** The interaction a cause list traces back to — root writes only, derived links walked. */ function interactionIn(e) {
+    for (const n of e) {
+        const e = n.kind === "derived" ? n.causes !== undefined ? interactionIn(n.causes) : undefined : interactionOf(n.origin);
+        if (e !== undefined) return e;
+    }
+    return undefined;
+}
+
+function currentOrigin() {
+    const e = originFrames[originFrames.length - 1];
+    if (e !== undefined) return e;
+    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(e) {
+    for (const n of e) {
+        const e = n.kind === "derived" ? n.causes !== undefined ? originIn(n.causes) : undefined : n.origin;
+        if (e !== undefined && e.kind !== "external") return e;
+    }
+    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 e = frames.length - 1; e >= 0; e--) {
+        const n = frames[e].causes;
+        if (n !== null) {
+            const e = originIn(n);
+            if (e !== undefined) return e;
+            break;
+        }
+    }
+    const e = currentOrigin();
+    return e === EXTERNAL_ORIGIN ? undefined : e;
+}
+
+const effectFrames = new WeakMap;
+
+/** The interaction the innermost open frame runs under, else the ambient one. */ function enclosingInteraction() {
+    const e = originFrames[originFrames.length - 1];
+    return (e !== undefined ? interactionOf(e) : undefined) ?? currentInteraction ?? undefined;
+}
+
+function pushFrame(e, n, t, i) {
+    const o = {
+        kind: e
+    };
+    if (n) o.name = n;
+    const r = t ?? currentInteraction ?? undefined;
+    if (r !== undefined) o.interaction = r;
+    if (i !== undefined) {
+        const e = i;
+        if (e.we !== undefined) o.run = e.we;
+        effectFrames.set(o, {
+            node: i,
+            causes: e.ve
+        });
+    }
+    originFrames.push(o);
+}
+
+function popFrame(e) {
+    // 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 n = originFrames[originFrames.length - 1];
+    if (n !== undefined && n.kind === e) originFrames.pop();
+}
+
+/**
+ * `withOrigin` opened a declared frame. The frame object IS the origin every
+ * write inside stamps, and the key the navigation record hangs off (see
+ * "Navigations" below), so a hold or re-run that later resolves a write's
+ * origin lands on the same record. It runs under the interaction of the frame
+ * it opened inside — a `navigate()` from an action step, whose ambient
+ * interaction is long gone but whose frame remembers it — else the ambient
+ * one (a link click's handler).
+ */ function originStart(e) {
+    // 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 (e.redirect !== undefined && e.redirect > 0) {
+        const n = lastOpenNavigation();
+        if (n !== undefined) {
+            redirectNavigation(n, e);
+            originFrames.push(n.event.origin);
+            return;
+        }
+    }
+    const n = {
+        kind: e.kind,
+        at: e.at ?? now()
+    };
+    if (e.from !== undefined) n.from = e.from;
+    const t = enclosingInteraction();
+    if (t !== undefined) n.interaction = t;
+    originFrames.push(n);
+    openNavigation(n, e);
+}
+
+function originEnd() {
+    const e = originFrames[originFrames.length - 1];
+    popFrame("navigation");
+    if (e !== undefined && e.kind === "navigation") closeNavigation(e);
+}
+
+/** `click on button#next "Next →"`, `effect "syncTitle"`, `action "save"`, `navigation to /users/:id`, … */ function formatOrigin(e) {
+    switch (e.kind) {
+      case "interaction":
+        return `${e.name} on ${e.target ?? "an element"}`;
+
+      case "effect":
+        return `effect${e.name ? ` "${e.name}"` : ""}`;
+
+      case "action":
+        return `action${e.name ? ` "${e.name}"` : ""}`;
+
+      case "async":
+        return `async landing${e.name ? ` on "${e.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 n = e.name ?? e.to;
+            if (n === undefined) return "navigation";
+            const t = [];
+            if (e.to !== undefined && e.to !== n) t.push(e.to);
+            const i = navStates.get(e)?.event.redirects;
+            if (i !== undefined) t.push(`redirected from ${i.map(e => e.to ?? e.name ?? "?").join(" → ")}`);
+            return `navigation to ${n}${t.length > 0 ? ` (${t.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(e) {
+    let n = 0;
+    for (let t = e.u; t !== null; t = t.ie) n++;
+    return n;
+}
+
+/**
+ * Written-fan-out warning — the engine's lower-bar sibling of the always-on
+ * HUGE_FAN_OUT (see dev.ts): a committed root invalidation reaching hundreds
+ * of subscribers re-runs all of them this flush. Counts the subscriber list
+ * itself (an engine-only walk, on the write; the core keeps no per-node
+ * count — a live `_subCount` was a post-construction field that forked node
+ * shapes). Once per node; re-warns only when the subscriber count has
+ * doubled since the last warning. Stops at GRAPH_SIZE_WARN_AT, where
+ * HUGE_FAN_OUT takes over, so the two never fire for the same write.
+ */ function checkWideWrite(e, n) {
+    const t = options.wideWrites;
+    if (typeof t !== "number") return;
+    const i = countSubscribers(e);
+    const o = e;
+    if (i < t || i >= GRAPH_SIZE_WARN_AT) return;
+    if (i < (o.$e ?? 0) * 2) return;
+    o.$e = i;
+    const r = n === "refresh" ? "refresh of" : n === "async" ? "async landing on" : "write to";
+    const s = `[WIDE_WRITE] ${r} "${nodeName(e)}" reached ${i} subscribers — every one ` + `re-runs this flush. If consumers ask keyed questions of this value (for example every ` + `row comparing against one selected id), invert it: keep the answer in a store used as a ` + `map keyed by id, so each consumer reads its own key and only the keys that flipped update.`;
+    reportDiagnostic(emitDiagnostic({
+        code: "WIDE_WRITE",
+        kind: "perf",
+        severity: "warn",
+        message: s,
+        nodeName: nodeName(e),
+        data: {
+            subscribers: i,
+            write: n
+        }
+    }, e));
+}
+
+function stampWrite(e, n, t = NO_VALUES, i = NO_VALUES) {
+    const o = {
+        seq: ++changeSeq,
+        kind: n,
+        name: nodeName(e)
+    };
+    if (i !== NO_VALUES) {
+        o.prev = t === NO_VALUES ? undefined : preview(t);
+        o.value = preview(i);
+    }
+    o.origin = n === "async" ? asyncOrigin(e) : currentOrigin();
+    o.at = now();
+    o.stack = captureStack();
+    const r = e.ke;
+    e.ke = o;
+    noteNavigationWrite(r, o);
+    noteInteractionWrite(o.origin, excludedNode(e));
+    if (n === "write") trackEffectWrite(e, o, i);
+    // stampWrite is the single funnel for committed root invalidations (sync
+    // writes, refresh(), async landings), which makes it the one place the
+    // written-fan-out check needs to live.
+        checkWideWrite(e, n);
+}
+
+/** Record a derived change (memo produced a new value) with its causes. */ function stampDerived(e, n) {
+    e.ke = {
+        seq: ++changeSeq,
+        kind: "derived",
+        name: nodeName(e),
+        causes: n
+    };
+}
+
+/**
+ * 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(e) {
+    const n = e.Le ?? 0;
+    const t = [];
+    const i = e.ke;
+    if (i !== undefined && i.seq > n && i.kind === "refresh") t.push(i);
+    for (let i = e.ee; i !== null; i = i.te) {
+        const e = i.re.ke;
+        if (e !== undefined && e.seq > n) t.push(e);
+    }
+    return t;
+}
+
+/** Advance the node's seen-cursor to the present. Call after every run. */ function markSeen(e) {
+    e.Le = 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(e) {
+    const n = [];
+    for (let t = e.ee; t !== null; t = t.te) {
+        n.push(t.re);
+        if (t === e.Fe) break;
+    }
+    return n;
+}
+
+/**
+ * Wide-scope warning — the coarse-read / helper-leak signature: one scope
+ * subscribed to dozens of sources re-runs when ANY of them change. Fired from
+ * 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(e) {
+    const n = options.wideDeps;
+    if (n === false) return;
+    let t = 0;
+    const i = [];
+    for (let n = e.ee; n !== null; n = n.te) {
+        t++;
+        if (i.length < 12) i.push(nodeName(n.re));
+        if (n === e.Fe) break;
+ // the validated prefix, as captureDeps
+        }
+    const o = e;
+    if (t < n || t < (o.We ?? 0) * 1.5) return;
+    o.We = t;
+    const r = e.Pe ? "effect" : "memo";
+    const s = `[WIDE_SCOPE_DEPS] ${r} "${nodeName(e)}" is subscribed to ${t} sources — ` + `it re-runs when any of them change. Narrow its reads or split it into smaller memos. ` + `Sources: ${i.join(", ")}${t > i.length ? ", …" : ""}`;
+    reportDiagnostic(emitDiagnostic({
+        code: "WIDE_SCOPE_DEPS",
+        kind: "perf",
+        severity: "warn",
+        message: s,
+        nodeName: nodeName(e),
+        data: {
+            depCount: t,
+            deps: i
+        }
+    }, e));
+}
+
+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(e, n) {
+    const t = options.hotRuns;
+    if (t === false) return;
+    const i = e;
+    const o = Date.now();
+    if (i.Me === undefined || o - i.Me > t.windowMs) {
+        i.Me = o;
+        i.He = 0;
+        i.qe = false;
+    }
+    i.He = (i.He ?? 0) + 1;
+    if (i.qe || i.He < t.count) return;
+    i.qe = 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 r = new Set;
+    rootsOf(n.causes, r);
+    const s = r.size > 0 ? [ ...r ].sort().join(", ") : "(untracked)";
+    let a = hotCauses.get(s);
+    if (a === undefined || o - a.winStart > t.windowMs) {
+        a = {
+            winStart: o,
+            scopes: 0,
+            runs: 0,
+            nextMilestone: HOT_FANOUT_FIRST_MILESTONE
+        };
+        hotCauses.set(s, a);
+    }
+    a.scopes++;
+    a.runs += i.He;
+    if (a.scopes === 1) {
+        const r = n.causes.map(e => `"${e.name}" (${e.kind})`).join(", ");
+        const s = `[HOT_SCOPE_RERUNS] ${n.nodeKind} "${n.nodeName}" re-ran ${i.He} times ` + `in ${Math.max(1, o - i.Me)}ms — a hot signal is likely leaking into this ` + `scope. Latest cause: ${r || "(untracked pull)"}`;
+        reportDiagnostic(emitDiagnostic({
+            code: "HOT_SCOPE_RERUNS",
+            kind: "perf",
+            severity: "warn",
+            message: s,
+            nodeName: n.nodeName,
+            data: {
+                runs: i.He,
+                windowMs: t.windowMs,
+                causes: n.causes.map(e => e.name)
+            }
+        }, e));
+        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 (a.scopes < a.nextMilestone) return;
+    a.nextMilestone *= 10;
+    const c = `[HOT_SCOPE_FANOUT] ${a.scopes} scopes have gone hot (${a.runs} re-runs) within ` + `${t.windowMs}ms, all driven by ${s} — 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: c,
+        nodeName: s,
+        data: {
+            cause: s,
+            scopes: a.scopes,
+            runs: a.runs,
+            windowMs: t.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(e, n) {
+    const t = options.hotTime;
+    if (t === false) return;
+    const i = e;
+    const o = now();
+    if (i.xe === undefined || o - i.xe > t.windowMs) {
+        i.xe = o;
+        i.je = 0;
+        i.Ve = false;
+    }
+    i.je = (i.je ?? 0) + n.selfMs;
+    if (i.Ve || i.je < t.budgetMs) return;
+    i.Ve = true;
+    const r = n.causes.map(e => `"${e.name}" (${e.kind})`).join(", ");
+    const s = `[HOT_SCOPE_TIME] ${n.nodeKind} "${n.nodeName}" spent ` + `${i.je.toFixed(1)}ms of compute inside one ${t.windowMs}ms window ` + `(budget ${t.budgetMs}ms). Latest cause: ${r || "(untracked pull)"}`;
+    reportDiagnostic(emitDiagnostic({
+        code: "HOT_SCOPE_TIME",
+        kind: "perf",
+        severity: "warn",
+        message: s,
+        nodeName: n.nodeName,
+        data: {
+            spentMs: i.je,
+            budgetMs: t.budgetMs,
+            windowMs: t.windowMs,
+            causes: n.causes.map(e => e.name)
+        }
+    }, e));
+}
+
+function recordRerun(e, n, t, i, o, r) {
+    const s = n.causes;
+    const a = n.prevDeps;
+    const c = e;
+    const f = c.ve;
+    if (excludedNode(e)) {
+        // The observer's own computation: keep the per-node bookkeeping its
+        // effect phase reads (see effectRunStart) and record nothing.
+        c.Ye = n.interaction;
+        c.we = undefined;
+        c.ve = s;
+        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 d = captureDeps(e);
+    const u = new Set(a);
+    const l = new Set(d);
+    const h = [];
+    const m = [];
+    for (const e of d) if (!u.has(e)) h.push(nodeName(e));
+    for (const e of a) if (!l.has(e)) m.push(nodeName(e));
+    const p = {
+        run: ++runSeq,
+        at: n.start,
+        nodeRuns: c.Be = (c.Be ?? 0) + 1,
+        nodeKind: e.Pe ? "effect" : "memo",
+        nodeName: nodeName(e),
+        nodeId: devId(e),
+        causes: s,
+        depCount: d.length,
+        depsAdded: h,
+        depsRemoved: m,
+        selfMs: t.selfMs,
+        totalMs: t.totalMs,
+        changed: i,
+        phase: o,
+        held: r
+    };
+    const g = n.interaction;
+    if (g !== undefined) p.interaction = g;
+    // The effect phase runs later in the flush with no cause list of its own:
+    // it inherits this run's interaction and is joined to this run's causes
+    // (see effectRunStart / pushFrame).
+        c.Ye = g;
+    c.we = p.run;
+    c.ve = s;
+    // 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(p, e);
+    history.push(p);
+    if (history.length > options.historyLimit) history.shift();
+    for (const n of folds) n.rerun?.(e, p);
+    noteInteractionRun(g, t.selfMs, false);
+    if (p.nodeKind === "effect") checkEffectCycle(e, s);
+    checkRelayTear(e, s, f);
+    checkHotRuns(e, p);
+    checkHotTime(e, p);
+    checkDepWidth(e);
+    emitRecord("rerun", p);
+    if (options.log) logRerun(p);
+}
+
+function formatCause(e, n, t) {
+    const i = "  ".repeat(n + 1);
+    let o = `${i}← ${e.kind === "derived" ? "memo" : "signal"} "${e.name}" ${e.kind === "derived" ? "changed" : e.kind} (#${e.seq})`;
+    if (e.prev !== undefined) o += ` ${e.prev} → ${e.value}`;
+    if (e.origin !== undefined && e.origin.kind !== "external") {
+        o += ` — ${formatOrigin(e.origin)}`;
+        const n = e.origin.interaction;
+        if (n !== undefined) o += ` (under ${formatOrigin(n)})`;
+    }
+    t.push(o);
+    if (e.stack) for (const n of e.stack) t.push(`${i}    ${n}`);
+    if (e.causes && n < 10) {
+        for (const i of e.causes) formatCause(i, n + 1, t);
+    }
+}
+
+function formatRerun(e) {
+    const n = [ `[why-run] ${e.nodeKind} "${e.nodeName}" ran (run ${e.nodeRuns}, ` + `${e.selfMs.toFixed(2)}ms${e.changed ? "" : ", unchanged"}` + `${e.phase === "plain" ? "" : `, ${e.phase}`}${e.held ? ", held" : ""})` + (e.causes.length === 0 ? " — no tracked cause (pull or retry)" : "") ];
+    for (const t of e.causes) formatCause(t, 0, n);
+    if (e.depsAdded.length > 0 || e.depsRemoved.length > 0) {
+        const t = [ ...e.depsAdded.map(e => `+"${e}"`), ...e.depsRemoved.map(e => `-"${e}"`) ].join(" ");
+        n.push(`  deps changed: ${t} (${e.depCount} total)`);
+    }
+    return n.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(e) {
+    const n = formatRerun(e);
+    const t = n.indexOf("\n");
+    if (t === -1 || typeof console.groupCollapsed !== "function") {
+        console.log(n);
+        return;
+    }
+    console.groupCollapsed(n.slice(0, t));
+    console.log(n.slice(t + 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(e) {
+    if (e === null || typeof e !== "object") return false;
+    if (Array.isArray(e)) return true;
+    const n = Object.getPrototypeOf(e);
+    return n === Object.prototype || n === null;
+}
+
+/** Shallow structural equivalence, capped so hot paths stay cheap. */ const UNSTABLE_KEY_CAP = 64;
+
+function shallowEquivalent(e, n) {
+    const t = Array.isArray(e);
+    if (t !== Array.isArray(n)) return false;
+    if (t) {
+        const t = e;
+        const i = n;
+        if (t.length !== i.length || t.length > UNSTABLE_KEY_CAP) return false;
+        for (let e = 0; e < t.length; e++) if (t[e] !== i[e]) return false;
+        return true;
+    }
+    const i = Object.keys(e);
+    if (i.length > UNSTABLE_KEY_CAP || i.length !== Object.keys(n).length) return false;
+    for (const t of i) {
+        if (!(t in n) || e[t] !== n[t]) 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(e, n, t) {
+    const i = 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 i !== "number") return;
+    const o = e;
+    if (n === t || // paranoia: changed runs should never hit this
+    !isPlainShape(n) || !isPlainShape(t) || !shallowEquivalent(n, t)) {
+        o.ze = 0;
+        o.Ke = false;
+        return;
+    }
+    o.ze = (o.ze ?? 0) + 1;
+    if (o.Ke || o.ze < i) return;
+    o.Ke = true;
+    const r = Array.isArray(t) ? "array" : "object";
+    const s = `[UNSTABLE_MEMO_OUTPUT] memo "${nodeName(e)}" produced a new-but-equivalent ${r} on ` + `${o.ze} 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: s,
+        nodeName: nodeName(e),
+        data: {
+            runs: o.ze,
+            shape: r
+        }
+    }, e));
+}
+
+const EFFECT_CYCLE_MAX_HOPS = 6;
+
+const reportedCycles = new Set;
+
+let nextDevId = 0;
+
+const devIds = new WeakMap;
+
+function devId(e) {
+    let n = devIds.get(e);
+    if (n === undefined) devIds.set(e, n = ++nextDevId);
+    return n;
+}
+
+function rootWrites(e, n) {
+    for (const t of e) {
+        if (t.kind === "derived") {
+            if (t.causes !== undefined) rootWrites(t.causes, n);
+        } else n.push(t);
+    }
+}
+
+/**
+ * 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(e, n, t, i) {
+    const o = [];
+    rootWrites(n, o);
+    for (const n of o) {
+        const o = n.origin;
+        if (o === undefined || o.kind !== "effect") continue;
+        const r = effectFrames.get(o);
+        if (r === undefined) continue;
+        if (r.node === e) return [ {
+            effect: r.node,
+            write: n
+        } ];
+        if (i >= EFFECT_CYCLE_MAX_HOPS || t.has(r.node) || r.causes === undefined) continue;
+        t.add(r.node);
+        const s = findEffectCycle(e, r.causes, t, i + 1);
+        if (s !== null) {
+            s.push({
+                effect: r.node,
+                write: n
+            });
+            return s;
+        }
+    }
+    return null;
+}
+
+/** Names of the memos between a direct cause of a run and `write`, root-first. */ function derivedPath(e, n, t) {
+    for (const i of e) {
+        if (i === n) return true;
+        if (i.kind === "derived" && i.causes !== undefined) {
+            t.unshift(i.name);
+            if (derivedPath(i.causes, n, t)) return true;
+            t.shift();
+        }
+    }
+    return false;
+}
+
+function describeWrite(e) {
+    if (e.kind === "refresh") return `refreshed "${e.name}"`;
+    const n = e.prev !== undefined ? ` (${e.prev} → ${e.value})` : "";
+    return `wrote "${e.name}"${n}`;
+}
+
+function checkEffectCycle(e, n) {
+    const t = findEffectCycle(e, n, new Set([ e ]), 0);
+    if (t === null) return;
+    const i = t.map(e => devId(e.effect)).sort((e, n) => e - n).join(",");
+    if (reportedCycles.has(i)) return;
+    reportedCycles.add(i);
+    const o = t.length + 1;
+    let r;
+    if (t.length === 1) {
+        const [{write: i}] = t;
+        const o = [];
+        derivedPath(n, i, o);
+        const s = o.length > 0 ? ` through ${o.map(e => `memo "${e}"`).join(" → ")}` : "";
+        r = `[EFFECT_WRITES_OWN_SOURCE] effect "${nodeName(e)}" re-ran because of its own write: it ` + `${describeWrite(i)}, which fed back into its inputs${s}. 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 e = t.map(e => `"${nodeName(e.effect)}"`);
+        const n = t.map((n, t) => `effect ${e[t]}${t > 0 ? " re-ran and" : ""} ${describeWrite(n.write)}`).join("; ");
+        r = `[EFFECT_WRITES_OWN_SOURCE] effects ${[ ...e, e[0] ].join(" → ")} relay writes in a ` + `cycle: ${n}; which fed back into effect ${e[0]}'s inputs — ${o} 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 s = t.length === 1 ? "warn" : "info";
+    emitDiagnostic({
+        code: "EFFECT_WRITES_OWN_SOURCE",
+        kind: "perf",
+        severity: s,
+        message: r,
+        nodeName: nodeName(e),
+        data: {
+            effects: t.map(e => nodeName(e.effect)),
+            writes: t.map(e => ({
+                effect: nodeName(e.effect),
+                kind: e.write.kind,
+                name: e.write.name,
+                prev: e.write.prev,
+                value: e.write.value
+            })),
+            flushes: o
+        }
+    }, e);
+}
+
+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(e, n, t) {
+    const i = e;
+    const o = n.origin;
+    const r = o !== undefined && o.kind === "effect" ? effectFrames.get(o) : undefined;
+    const s = r === undefined ? 0 : devId(r.node);
+    recordNodes.set(n, e);
+    i.Xe = i.Xe === undefined || i.Xe === s ? s : null;
+    if (r !== undefined && t !== undefined && t === r.node.Ae) {
+        copyWrites.add(n);
+        i.Ze = i.Je === s ? (i.Ze ?? 0) + 1 : 1;
+        i.Je = s;
+        if (i.Ze >= 2 && i.Xe === s) checkCopyEffect(r.node, e);
+    } else i.Ze = 0;
+}
+
+/** The effect's source whose current value the compute output is, if any (the prop-to-state port). */ function passthroughSource(e) {
+    for (let n = e.ee; n !== null; n = n.te) if (n.re.Ae === e.Ae) return nodeName(n.re);
+    return undefined;
+}
+
+/** The repair for a write that is the effect's compute output. */ function copyRepair(e, n) {
+    const t = passthroughSource(e);
+    return t !== undefined ? `The written value is "${t}" itself: read "${t}" where "${n}" 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 "${n}" a memo of that computation and delete the effect.`;
+}
+
+function checkCopyEffect(e, n) {
+    if (copyReported.has(n)) return;
+    copyReported.add(n);
+    const t = nodeName(n);
+    const i = `[EFFECT_RELAY_TEAR] effect "${nodeName(e)}" writes its compute output into ` + `"${t}" on every run, and nothing else writes "${t}" — it is derived state kept ` + `one flush late: everything reading it paints a frame behind everything reading the ` + `source. ${copyRepair(e, t)}`;
+    reportDiagnostic(emitDiagnostic({
+        code: "EFFECT_RELAY_TEAR",
+        kind: "perf",
+        severity: "warn",
+        message: i,
+        nodeName: nodeName(e),
+        data: {
+            relay: nodeName(e),
+            wrote: t,
+            copy: true,
+            passthrough: passthroughSource(e) ?? null,
+            soleWriter: true
+        }
+    }, e));
+}
+
+/**
+ * `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(e, n, t) {
+    if (t === undefined || n.length === 0) return;
+    const i = [];
+    rootWrites(n, i);
+    if (i.length === 0) return;
+    let o;
+    let r;
+    let s;
+    for (const n of i) {
+        const i = n.origin;
+        if (i === undefined || i.kind !== "effect") return;
+        const a = effectFrames.get(i);
+        // Own-source cycles are EFFECT_WRITES_OWN_SOURCE's; a create-run relay
+        // is initial sync, not a tear for one change.
+                if (a === undefined || a.node === e || a.causes === undefined) return;
+        if (s === undefined) {
+            const e = [];
+            rootWrites(a.causes, e);
+            const i = [];
+            rootWrites(t, i);
+            const c = e.find(e => i.includes(e));
+            if (c !== undefined) {
+                s = c;
+                o = a;
+                r = n;
+            }
+        }
+    }
+    if (s === undefined || o === undefined || r === undefined) return;
+    const a = `${devId(o.node)}:${r.name}`;
+    let c = relays.get(a);
+    if (c === undefined) relays.set(a, c = {
+        count: 0,
+        warned: false
+    });
+    c.count++;
+    const f = copyWrites.has(r);
+    const d = recordNodes.get(r);
+    const u = d !== undefined && d.Xe === devId(o.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 l = f && u;
+    const h = l || c.count >= RELAY_WARN_AT ? "warn" : "info";
+    // First sighting always reports (advisory); afterwards only the escalation.
+        if (c.count > 1 && (h !== "warn" || c.warned)) return;
+    // One verdict per derivable signal: the copy report (checkCopyEffect) and
+    // the tear report carry the same repair.
+        if (l && d !== undefined) {
+        if (copyReported.has(d)) return;
+        copyReported.add(d);
+    }
+    if (h === "warn") c.warned = true;
+    const m = e.Pe ? "effect" : "memo";
+    const p = nodeName(o.node);
+    const g = l ? copyRepair(o.node, r.name) : f ? `The written value is the effect's compute output, but "${r.name}" has other ` + `writers — editable state reset from a source. If the reset is the intent, the tear ` + `is its cost; if "${r.name}" only ever mirrors the source, drop the local copy ` + `and read the source.` : u ? `Nothing else writes "${r.name}" — it is derived state: make it a memo over what ` + `the effect reads and every reader gets it in the same flush.` : `If "${r.name}" is computed from what the effect reads, make it a memo so readers ` + `get it in the same flush; if the write reads something outside the graph (layout, ` + `time), the tear is the cost of measuring.`;
+    const w = `[EFFECT_RELAY_TEAR] ${m} "${nodeName(e)}" ran twice for one write of ` + `"${s.name}": once in the flush where "${s.name}" changed, and again after ` + `effect "${p}" relayed it by writing "${r.name}" — the first frame showed the ` + `new "${s.name}" with the stale "${r.name}"` + (c.count > 1 ? ` (${c.count} times so far)` : "") + `. ${g}`;
+    emitDiagnostic({
+        code: "EFFECT_RELAY_TEAR",
+        kind: "perf",
+        severity: h,
+        message: w,
+        nodeName: nodeName(e),
+        data: {
+            victim: nodeName(e),
+            root: s.name,
+            relay: p,
+            wrote: r.name,
+            copy: f,
+            passthrough: f ? passthroughSource(o.node) ?? null : null,
+            soleWriter: u,
+            occurrences: c.count
+        }
+    }, e);
+}
+
+// --- 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(e, n, t, i, o, r) {
+    if (immutableReported.has(e) || t < 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 (n && Math.abs(o - t) > Math.max(1, t >> 2)) return;
+    // At least half the leaves carried over unchanged, and at least one did.
+        if (i === 0 || i * 2 < t) return;
+    const s = t - i;
+    const a = n ? "array" : "object";
+    const c = n ? `mutate the draft in place (push/splice/index assignment) so only the touched ` + `indices notify` : `assign the leaf on the draft (\`${e}.<key> = …\`) so only readers of that key re-run`;
+    const f = `[IMMUTABLE_UPDATE_IN_STORE] "${e}" was replaced with a fresh ${a} whose ` + `${n ? "items" : "leaves"} are mostly the same values (${i} of ${t} unchanged` + `${s > 0 ? `, ${s} changed` : ""}) — a spread-copy update. The store already ` + `tracks ${n ? "items" : "leaves"}; a new container makes every reader of "${e}" ` + `re-run for the ${s === 1 ? "one that" : "few that"} moved. Instead, ${c}. For ` + `data arriving from outside (a fetch result), merge it with reconcile(data, key)(${e}).`;
+    // 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 d = emitDiagnostic({
+        code: "IMMUTABLE_UPDATE_IN_STORE",
+        kind: "perf",
+        severity: "warn",
+        message: f,
+        nodeName: e,
+        data: {
+            path: e,
+            shape: a,
+            total: t,
+            unchanged: i,
+            changed: s
+        }
+    }, r);
+    // 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(d)) return;
+    immutableReported.add(e);
+}
+
+// --- 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(e) {
+    if (e === null || typeof e !== "object") return undefined;
+    const n = e;
+    return n.id ?? n.key ?? n.Qe ?? undefined;
+}
+
+function checkListIdentity(e, n, t, i, o) {
+    if (listIdentityWarned.has(e)) return;
+    // Most of the list turned over, and the turnover was a swap (rows out ≈ rows in).
+        if (t.length < 2 || t.length * 2 < i) return;
+    if (Math.abs(n.length - t.length) > Math.max(1, t.length >> 2)) return;
+    // Pair exited with entered: by record id when present, else by position.
+        const r = new Map;
+    for (const e of n) {
+        const n = recordId(e);
+        if (n !== undefined) r.set(n, e);
+    }
+    let s = 0;
+    let a = 0;
+    const c = Math.max(1, Math.floor(t.length / LIST_CHURN_SAMPLE));
+    for (let e = 0; e < t.length && s < LIST_CHURN_SAMPLE; e += c) {
+        const i = t[e];
+        const o = recordId(i);
+        const c = o !== undefined ? r.get(o) : n[e];
+        if (c === undefined || !isPlainShape(c) || !isPlainShape(i)) continue;
+        s++;
+        if (shallowEquivalent(c, i)) a++;
+    }
+    if (s === 0 || a * 2 < s) return;
+    listIdentityWarned.add(e);
+    const f = nodeName(e);
+    const d = o ? `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 u = `[UNSTABLE_LIST_IDENTITY] list "${f}" recreated ${t.length} of ${i} rows on ` + `an update where the entering items are equivalent to the ones they replaced ` + `(${a} of ${s} 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. ${d}`;
+    reportDiagnostic(emitDiagnostic({
+        code: "UNSTABLE_LIST_IDENTITY",
+        kind: "perf",
+        severity: "warn",
+        message: u,
+        nodeName: f,
+        data: {
+            removed: n.length,
+            created: t.length,
+            length: i,
+            sampled: s,
+            equivalent: a,
+            keyed: o
+        }
+    }, e));
+}
+
+/** Provenance of an async landing: the flight, under the interaction that started it. */ function asyncOrigin(e) {
+    const n = {
+        kind: "async",
+        name: nodeName(e)
+    };
+    const t = liveFlights.get(e)?.interaction;
+    if (t !== undefined) n.interaction = t;
+    return n;
+}
+
+// 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(e) {
+    let n = null;
+    for (const t of e) {
+        let e = null;
+        if (t.kind === "async") e = landedFlights.get(t) ?? null; else if (t.kind === "derived" && t.causes) e = flightCauseIn(t.causes);
+        if (e !== null && (n === null || e.chain.length > n.chain.length)) n = e;
+    }
+    return n;
+}
+
+function trackFlightStart(e, n) {
+    const t = now();
+    const i = flightOrigins.get(n) ?? t;
+    if (i === t) flightOrigins.set(n, t);
+    // Census: a flight still in the air when the node starts another was
+    // superseded — its answer will be discarded.
+        for (const n of folds) n.flightStart?.(e, liveFlights.has(e));
+    // Nearest enclosing frame with causes: create runs carry null (a node born
+    // inside a parent's recompute inherits the parent's causality — the
+    // boundary-reveal case, and the lazy sibling whose first pull is gated
+    // behind an earlier not-ready read), so walk down to the first re-run frame.
+        let o = null;
+    for (let e = frames.length - 1; e >= 0; e--) {
+        if (frames[e].causes !== null) {
+            o = frames[e].causes;
+            break;
+        }
+    }
+    const r = {
+        origin: i,
+        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 s = o !== null ? interactionIn(o) : currentInteraction ?? undefined;
+    if (s !== undefined) r.interaction = s;
+    if (options.waterfalls !== false && o !== null) {
+        let e = flightCauseIn(o);
+        // The sequentiality test. A marked/previously-seen flight whose origin
+        // predates the upstream landing was in the air alongside it: parallel.
+                if (e !== null && i < e.landedAt) e = null;
+        if (e !== null) r.chain = [ ...e.chain, {
+            name: e.name,
+            ms: e.ms
+        } ];
+    }
+    liveFlights.set(e, r);
+}
+
+/**
+ * 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(e) {
+    const n = liveFlights.get(e);
+    if (n === undefined) return;
+    liveFlights.delete(e);
+    const t = now();
+    const i = t - n.origin;
+    for (const n of folds) n.flightLanded?.(e, i);
+    const o = e.ke;
+    // Only a stamp this landing produced may carry the measurement — a stale
+    // async record from a previous landing must not be re-labeled.
+        if (o !== undefined && o.kind === "async" && o.seq > n.startSeq) landedFlights.set(o, {
+        name: nodeName(e),
+        ms: i,
+        chain: n.chain,
+        landedAt: t
+    });
+    checkWaterfall(e, n.chain, i);
+}
+
+function checkWaterfall(e, n, t) {
+    const i = options.waterfalls;
+    if (i === false) return;
+    if (n.length > 0) {
+        waterfallLog.push({
+            chain: [ ...n, {
+                name: nodeName(e),
+                ms: t
+            } ],
+            sequentialMs: n.reduce((e, n) => e + n.ms, t)
+        });
+        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 (t < i.minFlightMs) return;
+    let o = 1;
+    let r = t;
+    for (let e = n.length - 1; e >= 0 && n[e].ms >= i.minFlightMs; e--) {
+        o++;
+        r += n[e].ms;
+    }
+    if (o < 2) return;
+    const s = e;
+    if ((s.en ?? 0) >= o) return;
+    s.en = o;
+    const a = [ ...n.slice(n.length - (o - 1)), {
+        name: nodeName(e),
+        ms: t
+    } ];
+    const c = a.map(e => `"${e.name}" (${e.ms.toFixed(0)}ms)`).join(" → ");
+    const f = `[ASYNC_WATERFALL] ${o} sequential async flights — ${c} — ` + `${r.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 d = o > 2 ? "warn" : "info";
+    emitDiagnostic({
+        code: "ASYNC_WATERFALL",
+        kind: "perf",
+        severity: d,
+        message: f,
+        nodeName: nodeName(e),
+        data: {
+            chain: a.map(e => ({
+                name: e.name,
+                ms: e.ms
+            })),
+            sequentialMs: r
+        }
+    }, e);
+}
+
+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(e) {
+    return !!e.o && e.o.nn !== undefined || (e.C & CONFIG_DERIVED_OVERRIDE) !== 0;
+}
+
+const HOLD_CENSUS_CAP = 1e4;
+
+function acknowledge(e, n, t, i) {
+    const o = `${n}:${t}`;
+    const r = e.acknowledgements.get(o);
+    const s = i !== null ? ownerPath(i) : undefined;
+    // A later census (a merged transition, the settle pass) may find the
+    // reader an earlier one missed.
+        if (r === undefined) e.acknowledgements.set(o, s !== undefined ? {
+        kind: n,
+        source: t,
+        reader: s
+    } : {
+        kind: n,
+        source: t
+    }); else if (s !== undefined) r.reader ??= s;
+}
+
+function censusRegistrations(e, n) {
+    const t = {
+        left: HOLD_CENSUS_CAP
+    };
+    for (const i of e.tn) if (!isCompanion(i)) acknowledge(n, "optimistic", nodeName(i), reachesEffect(i, t));
+    for (const t of e.rn) acknowledge(n, "optimistic", t?._name ?? "store", null);
+    for (const i of e.A) acknowledge(n, "affects", nodeName(i), reachesEffect(i, t));
+}
+
+/**
+ * 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(e, n) {
+    const t = new Set([ e ]);
+    const i = [ e ];
+    while (i.length > 0 && n.left-- > 0) {
+        const e = i.pop();
+        for (let n = e.u; n !== null; n = n.ie) {
+            const e = n.se;
+            if (e.Pe) return e;
+            if (!t.has(e)) {
+                t.add(e);
+                i.push(e);
+            }
+        }
+    }
+    return null;
+}
+
+/** Companions an effect reads, anywhere downstream of the hold's nodes. */ function censusCompanions(e, n) {
+    const t = new Set;
+    const i = [ ...e ];
+    const o = {
+        left: HOLD_CENSUS_CAP
+    };
+    while (i.length > 0 && t.size < HOLD_CENSUS_CAP) {
+        const e = i.pop();
+        if (t.has(e)) continue;
+        t.add(e);
+        const r = e.o;
+        if (r) {
+            let t;
+            if (r.he !== undefined && (t = reachesEffect(r.he, o))) acknowledge(n, "isPending", nodeName(e), t);
+            if (r.Ge !== undefined && (t = reachesEffect(r.Ge, o))) acknowledge(n, "latest", nodeName(e), t);
+            for (let e = r.i ?? null; e !== null; e = e.ue ?? null) i.push(e);
+        }
+        for (let n = e.u; n !== null; n = n.ie) i.push(n.se);
+    }
+}
+
+function holdState(e) {
+    let n = holdStates.get(e);
+    if (n === undefined) {
+        n = {
+            start: now(),
+            flushes: 0,
+            blockers: new Set,
+            acknowledgements: new Map,
+            painted: 0,
+            action: false
+        };
+        holdStates.set(e, n);
+    }
+    return n;
+}
+
+function trackHoldStart(e) {
+    // Navigations and interactions learn they are held regardless of hold
+    // tracking: their settle must wait for the transition either way (see flushEnd).
+    markNavigationsHeld(e);
+    markInteractionsHeld(e);
+    if (options.holds === false) return;
+    const n = holdState(e);
+    n.flushes++;
+    if (e.dt.length > 0) n.action = true;
+    for (const [t, i] of e.ot) if (i.size > 0) n.blockers.add(t);
+    censusRegistrations(e, n);
+    activeHold = n;
+}
+
+function trackHoldMerge(e, n) {
+    mergeInteractionsHeld(e, n);
+    const t = holdStates.get(n);
+    if (t === undefined) return;
+    holdStates.delete(n);
+    const i = holdState(e);
+    if (t.start < i.start) i.start = t.start;
+    i.flushes += t.flushes;
+    i.painted += t.painted;
+    i.action ||= t.action;
+    for (const e of t.blockers) i.blockers.add(e);
+    for (const [e, n] of t.acknowledgements) if (!i.acknowledgements.has(e)) i.acknowledgements.set(e, n);
+}
+
+function trackHoldSettled(e) {
+    const n = holdStates.get(e);
+    if (n === 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(e, undefined);
+        settleInteractionsHeld(e, undefined);
+        return;
+    }
+    holdStates.delete(e);
+    // Root writes only: a memo in _pendingNodes is a derived hold, and the
+    // question is whether the USER's input went unanswered.
+        const t = [];
+    let i = null;
+    let o;
+    let r;
+    let s = -Infinity;
+    for (const n of e.sn) {
+        if (typeof n.ht === "function" || isCompanion(n)) continue;
+        const e = n.ke;
+        if (e === undefined || e.kind !== "write") continue;
+        if (i === null) i = n;
+        const a = {
+            name: nodeName(n),
+            prev: e.prev,
+            value: e.value
+        };
+        if (e.origin !== undefined) a.origin = e.origin;
+        t.push(a);
+        // Earliest interaction among the held writes: the user has been waiting
+        // since the first thing they did that this transaction is holding.
+                const c = interactionOf(e.origin);
+        if (c !== undefined && (o === undefined || c.at < o.at)) o = c;
+        // The declared frame the writes belong to — earliest navigation, by the
+        // same reasoning.
+                if (e.origin?.kind === "navigation" && (r === undefined || e.origin.at < r.at)) r = e.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 (e.at !== undefined && e.at > s) s = e.at;
+    }
+    if (t.length === 0) {
+        settleNavigations(e, undefined);
+        settleInteractionsHeld(e, undefined);
+        return;
+    }
+    censusRegistrations(e, n);
+    censusCompanions([ ...e.sn, ...n.blockers ], n);
+    const a = now();
+    // The hold began no later than its first parked flush; an interaction stamp
+    // reaches further back (dispatch). A node rewritten mid-hold keeps only its
+    // latest record, so the surviving interaction may be a later one — the
+    // flush clock keeps the first wait from being forgotten.
+        const c = Math.min(n.start, o !== undefined ? o.at : Infinity);
+    const f = a - c;
+    const d = {
+        at: c,
+        holdMs: f,
+        tailMs: s === -Infinity ? f : Math.min(f, a - s),
+        flushes: n.flushes,
+        heldWrites: t,
+        blockers: [ ...n.blockers ].map(nodeName),
+        acknowledgements: [ ...n.acknowledgements.values() ],
+        paintedDuringHold: n.painted,
+        action: n.action
+    };
+    if (o !== undefined) d.interaction = o;
+    if (r !== undefined) d.origin = r;
+    holdLog.push(d);
+    if (holdLog.length > options.historyLimit) holdLog.shift();
+    // Bottom-up delivery: the hold, then the navigations it held, then the
+    // interactions those belong to — each record complete when its parent is.
+        emitRecord("hold", d);
+    settleNavigations(e, d);
+    settleInteractionsHeld(e, d);
+    for (const e of folds) e.hold?.(d);
+    if (isSilentHold(d)) checkSilentHold(d, i); else checkLongHold(d, i);
+}
+
+/** `isLongHold` — the tail outlasted `longHolds.infoMs`. */
+/** @internal */ function isLongHold(e) {
+    const n = options.longHolds;
+    return n !== false && n !== undefined && e.tailMs >= n.infoMs;
+}
+
+function describeHeldWrites(e) {
+    return e.heldWrites.map(e => e.prev !== undefined ? `"${e.name}" (${e.prev} → ${e.value})` : `"${e.name}"`).join(", ");
+}
+
+function describeBlockers(e, n) {
+    return e.blockers.length > 0 ? ` ${n} ${e.blockers.map(e => `"${e}"`).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(e) {
+    const n = e.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={${n}()} ` + `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(e) {
+    const n = {
+        holdMs: e.holdMs,
+        tailMs: e.tailMs,
+        flushes: e.flushes,
+        heldWrites: e.heldWrites.map(e => e.name),
+        blockers: e.blockers,
+        action: e.action
+    };
+    if (e.interaction !== undefined) n.interaction = {
+        type: e.interaction.name,
+        target: e.interaction.target
+    };
+    if (e.origin?.kind === "navigation") n.navigation = navigationData(e.origin);
+    return n;
+}
+
+/**
+ * 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(e) {
+    const n = e.origin !== undefined ? formatOrigin(e.origin) : "";
+    if (e.interaction !== undefined) return `${formatOrigin(e.interaction)}${n ? ` (${n})` : ""}`;
+    return n;
+}
+
+function checkSilentHold(e, n) {
+    const t = options.holds;
+    if (t === false) return;
+    if (e.holdMs < t.infoMs) return;
+    const i = e.holdMs.toFixed(0);
+    const o = describeHeldWrites(e);
+    const r = describeBlockers(e, "waiting on");
+    // With the interaction (or navigation) stamped the sentence starts from
+    // what the user did; without it, from the writes.
+        const s = holdActor(e);
+    const a = s ? `${s} ` : "";
+    let c = e.action ? `[SILENT_HOLD] ${a}${a ? "started an action that" : "an action"} held ${o} for ` + `${i}ms${r} 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] ${a}${a ? "wrote" : "writes to"} ${o}${a ? "; the write was" : " were"} ` + `held ${i}ms${r} 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 ${i}ms. Show the wait: ` + `read isPending(() => ${e.blockers[0] ?? "source"}()) to render a busy state, or ` + `latest(${e.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 f = isLongHold(e);
+    if (f) c += ` ${boundaryRepair(e)}`;
+    const d = e.holdMs >= t.warnMs ? "warn" : "info";
+    const u = holdData(e);
+    u.long = f;
+    emitDiagnostic({
+        code: "SILENT_HOLD",
+        kind: "responsiveness",
+        severity: d,
+        message: c,
+        nodeName: nodeName(n),
+        data: u
+    }, n);
+}
+
+function checkLongHold(e, n) {
+    const t = options.longHolds;
+    if (t === false || t === undefined) return;
+    if (e.tailMs < t.infoMs) return;
+    const i = e.tailMs.toFixed(0);
+    const o = describeHeldWrites(e);
+    const r = describeBlockers(e, "waiting on");
+    const s = holdActor(e);
+    const a = s ? `${s} ` : "";
+    const c = e.acknowledgements.length > 0 ? `${e.acknowledgements.map(e => `"${e.kind}:${e.source}"`).join(", ")} said it was pending` : `an effect painted meanwhile`;
+    const f = e.tailMs < e.holdMs - 1 ? ` after the last input (${e.holdMs.toFixed(0)}ms in all)` : "";
+    const d = `[LONG_HOLD] ${a}${a ? "wrote" : "writes to"} ${o}; the screen kept the old ` + `content for ${i}ms${f}${r} — ${c}, but the hold ran on well past ` + `the point where "loading" over stale content reads as broken. ${boundaryRepair(e)}`;
+    const u = e.tailMs >= t.warnMs ? "warn" : "info";
+    const l = holdData(e);
+    l.acknowledgements = e.acknowledgements;
+    emitDiagnostic({
+        code: "LONG_HOLD",
+        kind: "responsiveness",
+        severity: u,
+        message: d,
+        nodeName: nodeName(n),
+        data: l
+    }, n);
+}
+
+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(e) {
+    const {event: n, ref: t} = e;
+    const i = n.origin;
+    if (t.name === undefined) {
+        delete i.name;
+        delete n.name;
+    } else i.name = n.name = t.name;
+    if (t.to === undefined) {
+        delete i.to;
+        delete n.to;
+    } else i.to = n.to = t.to;
+    if (t.params === undefined) {
+        delete i.params;
+        delete n.params;
+    } else i.params = n.params = t.params;
+}
+
+function openNavigation(e, n) {
+    const t = {
+        at: e.at,
+        writes: 0,
+        origin: e
+    };
+    if (e.from !== undefined) t.from = e.from;
+    if (e.interaction !== undefined) t.interaction = e.interaction;
+    const i = {
+        event: t,
+        ref: n,
+        open: 1,
+        held: false,
+        writeDrain: drainSeq
+    };
+    syncNavigation(i);
+    navStates.set(e, i);
+    openNavs.add(i);
+    navigationLog.push(t);
+    if (navigationLog.length > options.historyLimit) navigationLog.shift();
+    noteInteractionNavigation(t);
+}
+
+/** The navigation a redirect hop folds onto: the most recently opened one still pending. */ function lastOpenNavigation() {
+    let e;
+    for (const n of openNavs) e = n;
+    return e;
+}
+
+/** A redirect re-describes `state`: the current destination becomes a hop it abandoned. */ function redirectNavigation(e, n) {
+    const t = e.event;
+    // As the router last described the destination being left behind.
+        syncNavigation(e);
+    const i = {
+        at: n.at ?? now()
+    };
+    if (t.name !== undefined) i.name = t.name;
+    if (t.to !== undefined) i.to = t.to;
+    if (t.params !== undefined) i.params = t.params;
+    (t.redirects ??= []).push(i);
+    e.ref = n;
+    e.open++;
+    syncNavigation(e);
+}
+
+function closeNavigation(e) {
+    const n = navStates.get(e);
+    if (n === undefined || --n.open > 0) return;
+    syncNavigation(n);
+    // 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 (n.event.writes === 0 || !n.held && drainSeq > n.writeDrain) settleNavigation(n, "committed");
+}
+
+/** stampWrite: the record replacing `prior` on a node was just stamped. */ function noteNavigationWrite(e, n) {
+    const t = n.origin;
+    if (t.kind === "navigation") {
+        const e = navStates.get(t);
+        if (e !== undefined) {
+            e.event.writes++;
+            e.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 i = e?.origin;
+    if (i !== undefined && i !== t && i.kind === "navigation") {
+        const e = navStates.get(i);
+        if (e !== undefined && openNavs.has(e)) settleNavigation(e, "superseded");
+    }
+}
+
+/** holdStart: `t`'s staged writes are parked — their navigations settle with `t`. */ function markNavigationsHeld(e) {
+    if (openNavs.size === 0) return;
+    for (const n of e.sn) {
+        const e = n.ke?.origin;
+        if (e?.kind !== "navigation") continue;
+        const t = navStates.get(e);
+        if (t !== undefined) t.held = true;
+    }
+}
+
+/** transitionSettled: `t` commits — the navigations whose writes it staged are done. */ function settleNavigations(e, n) {
+    if (openNavs.size === 0) return;
+    for (const t of e.sn) {
+        const e = t.ke?.origin;
+        if (e?.kind !== "navigation") continue;
+        const i = navStates.get(e);
+        if (i === undefined || !openNavs.has(i)) continue;
+        // A navigation whose frame is still open when its transition commits
+        // (`until()` inside the frame) settles here too: its writes are through.
+                settleNavigation(i, i.held ? "held" : "committed", n);
+    }
+}
+
+/** flushEnd: every open, closed, unheld navigation's (and interaction's) writes just committed. */ function trackFlushEnd() {
+    drainSeq++;
+    for (const e of openNavs) if (e.open === 0 && !e.held) settleNavigation(e, "committed");
+    for (const e of openInteractions) maybeSettleInteraction(e);
+}
+
+function settleNavigation(e, n, t) {
+    if (!openNavs.has(e)) return;
+    openNavs.delete(e);
+    syncNavigation(e);
+    const i = e.event;
+    i.settledMs = now() - i.at;
+    i.outcome = n;
+    if (t !== undefined) i.hold = t;
+    for (const e of folds) e.navigation?.(i);
+    emitRecord("navigation", i);
+    // The interaction that performed it may have been waiting only on this.
+        const o = openInteractionOf(i.interaction);
+    if (o !== undefined) maybeSettleInteraction(o);
+}
+
+const interactionStates = new WeakMap;
+
+/** Opened, not yet settled. */ const openInteractions = new Set;
+
+let interactionLog = [];
+
+function openInteraction(e) {
+    const n = {
+        name: e.name,
+        at: e.at,
+        handlerMs: 0,
+        writes: 0,
+        runs: 0,
+        created: 0,
+        runMs: 0,
+        holds: [],
+        navigations: [],
+        origin: e
+    };
+    if (e.target !== undefined) n.target = e.target;
+    const t = {
+        event: n,
+        open: true,
+        writeDrain: drainSeq,
+        heldIn: new Set,
+        held: false,
+        excludedWrites: 0
+    };
+    interactionStates.set(e, t);
+    openInteractions.add(t);
+    interactionLog.push(n);
+    if (interactionLog.length > options.historyLimit) interactionLog.shift();
+}
+
+/** interactionEnd: the handler returned. */ function closeInteraction(e) {
+    const n = interactionStates.get(e);
+    if (n === undefined) return;
+    n.open = false;
+    const t = now();
+    n.event.handlerMs = t - n.event.at;
+    maybeSettleInteraction(n, t);
+}
+
+/** The open record a frame runs under, if any. */ function openInteractionOf(e) {
+    const n = interactionOf(e);
+    if (n === undefined) return undefined;
+    const t = interactionStates.get(n);
+    return t !== undefined && openInteractions.has(t) ? t : undefined;
+}
+
+/** stampWrite: a root write stamped `origin`. */ function noteInteractionWrite(e, n) {
+    const t = openInteractionOf(e);
+    if (t === undefined) return;
+    if (n) {
+        t.excludedWrites++;
+        return;
+    }
+    t.event.writes++;
+    t.writeDrain = drainSeq;
+}
+
+/** recordRerun / a create run: work attributed to the interaction. */ function noteInteractionRun(e, n, t) {
+    const i = openInteractionOf(e);
+    if (i === undefined) return;
+    i.event[t ? "created" : "runs"]++;
+    i.event.runMs += n;
+}
+
+/** openNavigation: a navigation frame opened under the interaction. */ function noteInteractionNavigation(e) {
+    const n = openInteractionOf(e.interaction);
+    if (n !== undefined) n.event.navigations.push(e);
+}
+
+/** holdStart: `t` parked writes — the interactions that performed them wait for `t`. */ function markInteractionsHeld(e) {
+    if (openInteractions.size === 0) return;
+    for (const n of e.sn) {
+        const t = openInteractionOf(n.ke?.origin);
+        if (t !== undefined) {
+            t.heldIn.add(e);
+            t.held = true;
+        }
+    }
+}
+
+/** transitionMerged: whoever waited for `outgoing` now waits for `target`. */ function mergeInteractionsHeld(e, n) {
+    for (const t of openInteractions) if (t.heldIn.delete(n)) t.heldIn.add(e);
+}
+
+/** transitionSettled: `t` committed — its holders' writes are through. */ function settleInteractionsHeld(e, n) {
+    if (openInteractions.size === 0) return;
+    for (const t of openInteractions) {
+        if (!t.heldIn.delete(e)) continue;
+        if (n !== undefined) t.event.holds.push(n);
+        maybeSettleInteraction(t);
+    }
+}
+
+function maybeSettleInteraction(e, n = now()) {
+    const t = e.event;
+    if (e.open || e.heldIn.size > 0) return;
+    // A drain must have committed the last write (the handler's, or a redirect
+    // hop's after the click's own drain) — the handler returning is not the
+    // screen having it.
+        if (t.writes > 0 && drainSeq <= e.writeDrain) return;
+    for (const e of t.navigations) if (e.outcome === undefined) return;
+    openInteractions.delete(e);
+    // Every write went to an excluded subject and nothing of the app's ran: the
+    // click was on the observer's own UI (a devtools panel's button). Not a
+    // fact about the app — forget it rather than report a dead interaction.
+        if (t.writes === 0 && e.excludedWrites > 0 && t.runs === 0 && t.created === 0) {
+        const e = interactionLog.indexOf(t);
+        if (e !== -1) interactionLog.splice(e, 1);
+        return;
+    }
+    t.settledMs = n - t.at;
+    t.outcome = t.writes === 0 ? "idle" : e.held ? "held" : "committed";
+    emitRecord("interaction", t);
+}
+
+/** The serializable face of a navigation origin for diagnostic `data`. */ function navigationData(e) {
+    const n = {};
+    if (e.name !== undefined) n.name = e.name;
+    if (e.to !== undefined) n.to = e.to;
+    if (e.from !== undefined) n.from = e.from;
+    if (e.params !== undefined) n.params = e.params;
+    return n;
+}
+
+/** @internal No affordance answered and nothing painted while held. */ function isSilentHold(e) {
+    return e.paintedDuringHold === 0 && e.acknowledgements.length === 0;
+}
+
+// The engine's implementation of the core's dev hook points. Installed by
+// enable(), uninstalled by disable() — while uninstalled the core pays one
+// null check per site and nothing else.
+let asyncStartSeq = 0;
+
+let asyncStartTime = 0;
+
+let asyncStartValue;
+
+const engineHooks = {
+    interactionStart: interactionStart,
+    interactionEnd: interactionEnd,
+    originStart: originStart,
+    originEnd: originEnd,
+    flushEnd() {
+        trackFlushEnd();
+    },
+    recomputeStart(e, n) {
+        const t = n ? null : collectCauses(e);
+        frames.push({
+            start: now(),
+            childMs: 0,
+            causes: t,
+            prevDeps: n ? null : captureDeps(e),
+            // Mirror recompute's own prev-value resolution: an earlier run in the
+            // same flush may still be holding in _pendingValue.
+            prevValue: e._e !== NOT_PENDING ? e._e : e.Ae,
+            // 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: t !== null ? interactionIn(t) : frames.length > 0 ? frames[frames.length - 1].interaction : enclosingInteraction()
+        });
+    },
+    derivedChanged(e) {
+        const n = frames[frames.length - 1];
+        stampDerived(e, n !== undefined && n.causes !== null ? n.causes : []);
+    },
+    recomputeEnd(e, n, t, i, o, r) {
+        const s = frames.pop();
+        // enable() can land mid-recompute: no opening frame, nothing to report.
+                if (s === undefined) return;
+        const a = now() - s.start;
+        if (frames.length > 0) frames[frames.length - 1].childMs += a;
+        const c = Math.max(0, a - s.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 (t && s.causes !== null && e.Pe) {
+            const n = e._e !== NOT_PENDING ? e._e : e.Ae;
+            if (n !== undefined && n === s.prevValue) t = 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 (s.causes !== null && t && !i && !o && !e.Pe) checkUnstableOutput(e, s.prevValue, e._e !== NOT_PENDING ? e._e : e.Ae);
+        if (s.causes !== null) recordRerun(e, s, {
+            selfMs: c,
+            totalMs: a
+        }, t, i ? "optimistic" : o ? "held" : "plain", r); else if (!excludedNode(e)) {
+            // 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(e);
+            noteInteractionRun(s.interaction, c, true);
+        }
+        markSeen(e);
+    },
+    write(e, n, t) {
+        stampWrite(e, "write", n, t);
+    },
+    refreshed(e) {
+        stampWrite(e, "refresh");
+    },
+    flightStart(e, n) {
+        trackFlightStart(e, n);
+    },
+    asyncStart(e) {
+        asyncStartSeq = e.ke?.seq ?? 0;
+        asyncStartTime = e.fe;
+        asyncStartValue = e.Ae;
+    },
+    asyncEnd(e, n, t, i) {
+        if (i) {
+            // 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 i = e.Ae !== asyncStartValue || e.fe !== asyncStartTime || e._e === t;
+            if (i) stampWrite(e, "async", n === undefined ? NO_VALUES : n, t);
+            // Flight over either way — an equality-swallowed landing still spent
+            // the wall time (finalizeFlight only chains through a fresh stamp).
+                        finalizeFlight(e);
+            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 o = e.ke;
+        if (o !== undefined && o.seq > asyncStartSeq && o.kind === "write") stampWrite(e, "async", NO_VALUES, t);
+        finalizeFlight(e);
+    },
+    effectRunStart(e) {
+        pushFrame("effect", nodeName(e), e.Ye, e);
+    },
+    effectRunEnd() {
+        popFrame("effect");
+        if (activeHold !== null) activeHold.painted++;
+    },
+    actionStepStart(e, n) {
+        // 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 t = actionInteractions.get(e);
+        if (t === undefined && !actionInteractions.has(e)) {
+            t = currentInteraction ?? undefined;
+            actionInteractions.set(e, t);
+        }
+        pushFrame("action", n, t);
+    },
+    actionStepEnd() {
+        popFrame("action");
+    },
+    holdStart(e) {
+        trackHoldStart(e);
+    },
+    holdEnd() {
+        activeHold = null;
+    },
+    transitionSettled(e) {
+        trackHoldSettled(e);
+    },
+    transitionMerged(e, n) {
+        trackHoldMerge(e, n);
+    },
+    storeReplaced(e, n, t, i, o, r) {
+        checkImmutableUpdate(e, n, t, i, o, r);
+    },
+    listChurn(e, n, t, i, o) {
+        checkListIdentity(e, n, t, i, o);
+    },
+    boundaryFallback(e, n, t) {
+        for (const i of folds) i.fallback?.(e, n, t);
+    },
+    currentOrigin() {
+        return ambientOrigin();
+    }
+};
+
+const attribution = {
+    enable(e) {
+        options = {
+            ...defaultOptions,
+            ...e
+        };
+        frames.length = 0;
+        waterfallLog = [];
+        holdLog = [];
+        activeHold = null;
+        navigationLog = [];
+        openNavs.clear();
+        interactionLog = [];
+        openInteractions.clear();
+        drainSeq = 0;
+        reportedCycles.clear();
+        relays.clear();
+        immutableReported.clear();
+        originFrames.length = 0;
+        interactionStack.length = 0;
+        currentInteraction = null;
+        hotCauses.clear();
+        for (const e of folds) e.reset?.();
+        setAttributionHooks(engineHooks);
+    },
+    disable() {
+        clearListeners();
+        history = [];
+        frames.length = 0;
+        waterfallLog = [];
+        holdLog = [];
+        activeHold = null;
+        navigationLog = [];
+        openNavs.clear();
+        interactionLog = [];
+        openInteractions.clear();
+        drainSeq = 0;
+        reportedCycles.clear();
+        relays.clear();
+        immutableReported.clear();
+        originFrames.length = 0;
+        interactionStack.length = 0;
+        currentInteraction = null;
+        hotCauses.clear();
+        for (const e of folds) e.reset?.();
+        setAttributionHooks(null);
+    },
+    subscribe(e, n) {
+        const t = typeof e === "string" ? e : "rerun";
+        const i = typeof e === "string" ? n : e;
+        const o = recordListeners[t];
+        o.add(i);
+        return () => o.delete(i);
+    },
+    history() {
+        return history;
+    },
+    waterfalls() {
+        return waterfallLog;
+    },
+    holds() {
+        return holdLog;
+    },
+    navigations() {
+        return navigationLog;
+    },
+    interactions() {
+        return interactionLog;
+    },
+    markFlight(e, n = now()) {
+        // Earliest wins: re-marking (a cache re-serving the same promise) must
+        // not move the origin later.
+        const t = flightOrigins.get(e);
+        if (t === undefined || n < t) flightOrigins.set(e, n);
+    }
+};
+
+export { attribution, formatOrigin, formatRerun, isLongHold, isSilentHold, nodeName, now, registerFold, rootsOf };