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

package/dist/observe/core/attribution.js

@@ -1,8 +1,8 @@
 import { setAttributionHooks } from "./attribution-hooks.js";
 
-import { $REFRESH, NOT_PENDING } from "./constants.js";
+import { NOT_PENDING, CONFIG_DERIVED_OVERRIDE } from "./constants.js";
 
-import { ownerPath, reportDiagnostic, emitDiagnostic, isSuppressed, anyExcluded, isExcluded, GRAPH_SIZE_WARN_AT } from "./dev.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
@@ -68,50 +68,22 @@ function clearListeners() {
     for (const e in recordListeners) recordListeners[e].clear();
 }
 
-const now = typeof performance !== "undefined" ? () => performance.now() : () => Date.now();
+/** @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 folds = [];
 
-const writeCosts = new Map;
+/** @internal */ function registerFold(e) {
+    folds.push(e);
+}
 
-function rootsOf(e, n) {
+/** @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 recordCosts(e) {
-    let n = scopeCosts.get(e.node);
-    if (n === undefined) {
-        n = {
-            name: e.nodeName,
-            kind: e.nodeKind,
-            runs: 0,
-            selfMs: 0,
-            wastedMs: 0,
-            overlayMs: 0
-        };
-        scopeCosts.set(e.node, n);
-    }
-    n.runs++;
-    n.selfMs += e.selfMs;
-    if (e.phase !== "plain") n.overlayMs += e.selfMs; else if (!e.changed && !e.held) n.wastedMs += e.selfMs;
-    const t = new Set;
-    rootsOf(e.causes, t);
-    for (const n of t) {
-        let t = writeCosts.get(n);
-        if (t === undefined) writeCosts.set(n, t = {
-            name: n,
-            runs: 0,
-            downstreamMs: 0
-        });
-        t.runs++;
-        t.downstreamMs += e.selfMs;
-    }
-}
-
 function nodeName(e) {
     return e._name ?? "anonymous";
 }
@@ -215,6 +187,40 @@ function currentOrigin() {
     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() {
@@ -234,7 +240,7 @@ function pushFrame(e, n, t, i) {
         if (e.we !== undefined) o.run = e.we;
         effectFrames.set(o, {
             node: i,
-            causes: e.ke
+            causes: e.ve
         });
     }
     originFrames.push(o);
@@ -320,7 +326,7 @@ function originEnd() {
 /** 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.se) n++;
+    for (let t = e.u; t !== null; t = t.ie) n++;
     return n;
 }
 
@@ -339,8 +345,8 @@ function originEnd() {
     const i = countSubscribers(e);
     const o = e;
     if (i < t || i >= GRAPH_SIZE_WARN_AT) return;
-    if (i < (o.ve ?? 0) * 2) return;
-    o.ve = i;
+    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({
@@ -369,10 +375,10 @@ function stampWrite(e, n, t = NO_VALUES, i = NO_VALUES) {
     o.origin = n === "async" ? asyncOrigin(e) : currentOrigin();
     o.at = now();
     o.stack = captureStack();
-    const r = e.$e;
-    e.$e = o;
+    const r = e.ke;
+    e.ke = o;
     noteNavigationWrite(r, o);
-    noteInteractionWrite(o.origin);
+    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
@@ -381,7 +387,7 @@ function stampWrite(e, n, t = NO_VALUES, i = NO_VALUES) {
 }
 
 /** Record a derived change (memo produced a new value) with its causes. */ function stampDerived(e, n) {
-    e.$e = {
+    e.ke = {
         seq: ++changeSeq,
         kind: "derived",
         name: nodeName(e),
@@ -397,10 +403,10 @@ function stampWrite(e, n, t = NO_VALUES, i = NO_VALUES) {
  */ function collectCauses(e) {
     const n = e.Le ?? 0;
     const t = [];
-    const i = e.$e;
+    const i = e.ke;
     if (i !== undefined && i.seq > n && i.kind === "refresh") t.push(i);
-    for (let i = e.te; i !== null; i = i.ne) {
-        const e = i.oe.$e;
+    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;
@@ -410,9 +416,19 @@ function stampWrite(e, n, t = NO_VALUES, i = NO_VALUES) {
     e.Le = changeSeq;
 }
 
-/** Snapshot the node's current dep identities (call before a run replaces them). */ function captureDeps(e) {
+/**
+ * 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.te; t !== null; t = t.ne) n.push(t.oe);
+    for (let t = e.ee; t !== null; t = t.te) {
+        n.push(t.re);
+        if (t === e.Fe) break;
+    }
     return n;
 }
 
@@ -426,14 +442,16 @@ function stampWrite(e, n, t = NO_VALUES, i = NO_VALUES) {
     if (n === false) return;
     let t = 0;
     const i = [];
-    for (let n = e.te; n !== null; n = n.ne) {
+    for (let n = e.ee; n !== null; n = n.te) {
         t++;
-        if (i.length < 12) i.push(nodeName(n.oe));
-    }
+        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.Me ?? 0) * 1.5) return;
-    o.Me = t;
-    const r = e.Re ? "effect" : "memo";
+    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",
@@ -462,14 +480,14 @@ const HOT_FANOUT_FIRST_MILESTONE = 5;
     if (t === false) return;
     const i = e;
     const o = Date.now();
-    if (i.Ce === undefined || o - i.Ce > t.windowMs) {
-        i.Ce = o;
-        i.Fe = 0;
-        i.He = false;
+    if (i.Me === undefined || o - i.Me > t.windowMs) {
+        i.Me = o;
+        i.He = 0;
+        i.qe = false;
     }
-    i.Fe = (i.Fe ?? 0) + 1;
-    if (i.He || i.Fe < t.count) return;
-    i.He = true;
+    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;
@@ -486,10 +504,10 @@ const HOT_FANOUT_FIRST_MILESTONE = 5;
         hotCauses.set(s, a);
     }
     a.scopes++;
-    a.runs += i.Fe;
+    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.Fe} times ` + `in ${Math.max(1, o - i.Ce)}ms — a hot signal is likely leaking into this ` + `scope. Latest cause: ${r || "(untracked pull)"}`;
+        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",
@@ -497,7 +515,7 @@ const HOT_FANOUT_FIRST_MILESTONE = 5;
             message: s,
             nodeName: n.nodeName,
             data: {
-                runs: i.Fe,
+                runs: i.He,
                 windowMs: t.windowMs,
                 causes: n.causes.map(e => e.name)
             }
@@ -535,16 +553,16 @@ const HOT_FANOUT_FIRST_MILESTONE = 5;
     if (t === false) return;
     const i = e;
     const o = now();
-    if (i.We === undefined || o - i.We > t.windowMs) {
-        i.We = o;
-        i.qe = 0;
-        i.Be = false;
+    if (i.xe === undefined || o - i.xe > t.windowMs) {
+        i.xe = o;
+        i.je = 0;
+        i.Ve = false;
     }
-    i.qe = (i.qe ?? 0) + n.selfMs;
-    if (i.Be || i.qe < t.budgetMs) return;
-    i.Be = true;
+    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.qe.toFixed(1)}ms of compute inside one ${t.windowMs}ms window ` + `(budget ${t.budgetMs}ms). Latest cause: ${r || "(untracked pull)"}`;
+    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",
@@ -552,7 +570,7 @@ const HOT_FANOUT_FIRST_MILESTONE = 5;
         message: s,
         nodeName: n.nodeName,
         data: {
-            spentMs: i.qe,
+            spentMs: i.je,
             budgetMs: t.budgetMs,
             windowMs: t.windowMs,
             causes: n.causes.map(e => e.name)
@@ -564,34 +582,34 @@ function recordRerun(e, n, t, i, o, r) {
     const s = n.causes;
     const a = n.prevDeps;
     const c = e;
-    const d = c.ke;
+    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.xe = n.interaction;
+        c.Ye = n.interaction;
         c.we = undefined;
-        c.ke = s;
+        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 f = captureDeps(e);
+        const d = captureDeps(e);
     const u = new Set(a);
-    const l = new Set(f);
+    const l = new Set(d);
     const h = [];
     const m = [];
-    for (const e of f) if (!u.has(e)) h.push(nodeName(e));
+    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.je = (c.je ?? 0) + 1,
-        nodeKind: e.Re ? "effect" : "memo",
+        nodeRuns: c.Be = (c.Be ?? 0) + 1,
+        nodeKind: e.Pe ? "effect" : "memo",
         nodeName: nodeName(e),
-        node: e,
+        nodeId: devId(e),
         causes: s,
-        depCount: f.length,
+        depCount: d.length,
         depsAdded: h,
         depsRemoved: m,
         selfMs: t.selfMs,
@@ -605,16 +623,19 @@ function recordRerun(e, n, t, i, o, r) {
     // 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.xe = g;
+        c.Ye = g;
     c.we = p.run;
-    c.ke = s;
+    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();
-    recordCosts(p);
-    recordFeedbackRun(p);
+    for (const n of folds) n.rerun?.(e, p);
     noteInteractionRun(g, t.selfMs, false);
     if (p.nodeKind === "effect") checkEffectCycle(e, s);
-    checkRelayTear(e, s, d);
+    checkRelayTear(e, s, f);
     checkHotRuns(e, p);
     checkHotTime(e, p);
     checkDepWidth(e);
@@ -710,15 +731,15 @@ function shallowEquivalent(e, n) {
     const o = e;
     if (n === t || // paranoia: changed runs should never hit this
     !isPlainShape(n) || !isPlainShape(t) || !shallowEquivalent(n, t)) {
-        o.Ye = 0;
-        o.Ve = false;
+        o.ze = 0;
+        o.Ke = false;
         return;
     }
-    o.Ye = (o.Ye ?? 0) + 1;
-    if (o.Ve || o.Ye < i) return;
-    o.Ve = true;
+    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.Ye} consecutive runs — its equality gate never closes, so every ` + `subscriber re-runs on every upstream change. Return stable references or pass an ` + `\`equals\` option.`;
+    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",
@@ -726,7 +747,7 @@ function shallowEquivalent(e, n) {
         message: s,
         nodeName: nodeName(e),
         data: {
-            runs: o.Ye,
+            runs: o.ze,
             shape: r
         }
     }, e));
@@ -860,17 +881,17 @@ const copyReported = new WeakSet;
     const r = o !== undefined && o.kind === "effect" ? effectFrames.get(o) : undefined;
     const s = r === undefined ? 0 : devId(r.node);
     recordNodes.set(n, e);
-    i.Ke = i.Ke === undefined || i.Ke === s ? s : null;
-    if (r !== undefined && t !== undefined && t === r.node.ge) {
+    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.Xe === s ? (i.ze ?? 0) + 1 : 1;
-        i.Xe = s;
-        if (i.ze >= 2 && i.Ke === s) checkCopyEffect(r.node, e);
-    } else i.ze = 0;
+        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.te; n !== null; n = n.ne) if (n.oe.ge === e.ge) return nodeName(n.oe);
+    for (let n = e.ee; n !== null; n = n.te) if (n.re.Ae === e.Ae) return nodeName(n.re);
     return undefined;
 }
 
@@ -941,27 +962,27 @@ function checkCopyEffect(e, n) {
         warned: false
     });
     c.count++;
-    const d = copyWrites.has(r);
-    const f = recordNodes.get(r);
-    const u = f !== undefined && f.Ke === devId(o.node);
+    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 = d && u;
+        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 && f !== undefined) {
-        if (copyReported.has(f)) return;
-        copyReported.add(f);
+        if (l && d !== undefined) {
+        if (copyReported.has(d)) return;
+        copyReported.add(d);
     }
     if (h === "warn") c.warned = true;
-    const m = e.Re ? "effect" : "memo";
+    const m = e.Pe ? "effect" : "memo";
     const p = nodeName(o.node);
-    const g = l ? copyRepair(o.node, r.name) : d ? `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 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",
@@ -974,8 +995,8 @@ function checkCopyEffect(e, n) {
             root: s.name,
             relay: p,
             wrote: r.name,
-            copy: d,
-            passthrough: d ? passthroughSource(o.node) ?? null : null,
+            copy: f,
+            passthrough: f ? passthroughSource(o.node) ?? null : null,
             soleWriter: u,
             occurrences: c.count
         }
@@ -997,33 +1018,37 @@ function checkCopyEffect(e, n) {
 // per store path.
 const immutableReported = new Set;
 
-function checkImmutableUpdate(e, n, t, i, o) {
+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 r = t - i;
-    const s = n ? "array" : "object";
-    const a = 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 c = `[IMMUTABLE_UPDATE_IN_STORE] "${e}" was replaced with a fresh ${s} whose ` + `${n ? "items" : "leaves"} are mostly the same values (${i} of ${t} unchanged` + `${r > 0 ? `, ${r} changed` : ""}) — a spread-copy update. The store already ` + `tracks ${n ? "items" : "leaves"}; a new container makes every reader of "${e}" ` + `re-run for the ${r === 1 ? "one that" : "few that"} moved. Instead, ${a}. For ` + `data arriving from outside (a fetch result), merge it with reconcile(data, key)(${e}).`;
-    const d = emitDiagnostic({
+    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: c,
+        message: f,
         nodeName: e,
         data: {
             path: e,
-            shape: s,
+            shape: a,
             total: t,
             unchanged: i,
-            changed: r
+            changed: s
         }
-    });
-    // 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.
+    }, 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);
 }
@@ -1046,7 +1071,7 @@ const listIdentityWarned = new WeakSet;
 function recordId(e) {
     if (e === null || typeof e !== "object") return undefined;
     const n = e;
-    return n.id ?? n.key ?? n.Ze ?? undefined;
+    return n.id ?? n.key ?? n.Qe ?? undefined;
 }
 
 function checkListIdentity(e, n, t, i, o) {
@@ -1073,15 +1098,15 @@ function checkListIdentity(e, n, t, i, o) {
     }
     if (s === 0 || a * 2 < s) return;
     listIdentityWarned.add(e);
-    const d = nodeName(e);
-    const f = 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 "${d}" 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. ${f}`;
+    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: d,
+        nodeName: f,
         data: {
             removed: n.length,
             created: t.length,
@@ -1133,21 +1158,19 @@ function trackFlightStart(e, n) {
     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.
-        const o = flightBucket(e);
-    o.flights++;
-    if (liveFlights.has(e)) o.abandoned++;
+        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 r = null;
+        let o = null;
     for (let e = frames.length - 1; e >= 0; e--) {
         if (frames[e].causes !== null) {
-            r = frames[e].causes;
+            o = frames[e].causes;
             break;
         }
     }
-    const s = {
+    const r = {
         origin: i,
         startSeq: changeSeq,
         chain: []
@@ -1155,19 +1178,19 @@ function trackFlightStart(e, n) {
     // 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 a = r !== null ? interactionIn(r) : currentInteraction ?? undefined;
-    if (a !== undefined) s.interaction = a;
-    if (options.waterfalls !== false && r !== null) {
-        let e = flightCauseIn(r);
+        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) s.chain = [ ...e.chain, {
+        if (e !== null) r.chain = [ ...e.chain, {
             name: e.name,
             ms: e.ms
         } ];
     }
-    liveFlights.set(e, s);
+    liveFlights.set(e, r);
 }
 
 /**
@@ -1180,14 +1203,11 @@ function trackFlightStart(e, n) {
     liveFlights.delete(e);
     const t = now();
     const i = t - n.origin;
-    const o = flightBucket(e);
-    o.landed++;
-    o.landedMs += i;
-    if (i > o.worstMs) o.worstMs = i;
-    const r = e.$e;
+    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 (r !== undefined && r.kind === "async" && r.seq > n.startSeq) landedFlights.set(r, {
+        if (o !== undefined && o.kind === "async" && o.seq > n.startSeq) landedFlights.set(o, {
         name: nodeName(e),
         ms: i,
         chain: n.chain,
@@ -1220,24 +1240,24 @@ function checkWaterfall(e, n, t) {
     }
     if (o < 2) return;
     const s = e;
-    if ((s.Je ?? 0) >= o) return;
-    s.Je = o;
+    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 d = `[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".`;
+    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 f = o > 2 ? "warn" : "info";
+        const d = o > 2 ? "warn" : "info";
     emitDiagnostic({
         code: "ASYNC_WATERFALL",
         kind: "perf",
-        severity: f,
-        message: d,
+        severity: d,
+        message: f,
         nodeName: nodeName(e),
         data: {
             chain: a.map(e => ({
@@ -1255,8 +1275,10 @@ let activeHold = null;
 
 let holdLog = [];
 
-/** Companions are optimistic nodes too; `_parentSource` marks them. */ function isCompanion(e) {
-    return !!e.o && e.o.Qe !== undefined;
+/** 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;
@@ -1281,8 +1303,8 @@ function censusRegistrations(e, n) {
     const t = {
         left: HOLD_CENSUS_CAP
     };
-    for (const i of e.en) if (!isCompanion(i)) acknowledge(n, "optimistic", nodeName(i), reachesEffect(i, t));
-    for (const t of e.nn) acknowledge(n, "optimistic", t?._name ?? "store", null);
+    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));
 }
 
@@ -1297,9 +1319,9 @@ function censusRegistrations(e, n) {
     const i = [ e ];
     while (i.length > 0 && n.left-- > 0) {
         const e = i.pop();
-        for (let n = e.u; n !== null; n = n.se) {
-            const e = n.le;
-            if (e.Re) return e;
+        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);
@@ -1322,11 +1344,11 @@ function censusRegistrations(e, n) {
         const r = e.o;
         if (r) {
             let t;
-            if (r.be !== undefined && (t = reachesEffect(r.be, o))) acknowledge(n, "isPending", nodeName(e), t);
-            if (r.pe !== undefined && (t = reachesEffect(r.pe, o))) acknowledge(n, "latest", nodeName(e), 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.se) i.push(n.le);
+        for (let n = e.u; n !== null; n = n.ie) i.push(n.se);
     }
 }
 
@@ -1354,8 +1376,8 @@ function trackHoldStart(e) {
     if (options.holds === false) return;
     const n = holdState(e);
     n.flushes++;
-    if (e.ut.length > 0) n.action = true;
-    for (const [t, i] of e.Ie) if (i.size > 0) n.blockers.add(t);
+    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;
 }
@@ -1392,9 +1414,9 @@ function trackHoldSettled(e) {
     let o;
     let r;
     let s = -Infinity;
-    for (const n of e.tn) {
-        if (typeof n.ot === "function" || isCompanion(n)) continue;
-        const e = n.$e;
+    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 = {
@@ -1421,18 +1443,18 @@ function trackHoldSettled(e) {
         return;
     }
     censusRegistrations(e, n);
-    censusCompanions([ ...e.tn, ...n.blockers ], 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 d = a - c;
-    const f = {
+    const f = a - c;
+    const d = {
         at: c,
-        holdMs: d,
-        tailMs: s === -Infinity ? d : Math.min(d, a - s),
+        holdMs: f,
+        tailMs: s === -Infinity ? f : Math.min(f, a - s),
         flushes: n.flushes,
         heldWrites: t,
         blockers: [ ...n.blockers ].map(nodeName),
@@ -1440,20 +1462,21 @@ function trackHoldSettled(e) {
         paintedDuringHold: n.painted,
         action: n.action
     };
-    if (o !== undefined) f.interaction = o;
-    if (r !== undefined) f.origin = r;
-    holdLog.push(f);
+    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", f);
-    settleNavigations(e, f);
-    settleInteractionsHeld(e, f);
-    recordFeedbackHold(f);
-    if (isSilentHold(f)) checkSilentHold(f, i); else checkLongHold(f, i);
+        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`. */ function isLongHold(e) {
+/** `isLongHold` — the tail outlasted `longHolds.infoMs`. */
+/** @internal */ function isLongHold(e) {
     const n = options.longHolds;
     return n !== false && n !== undefined && e.tailMs >= n.infoMs;
 }
@@ -1516,15 +1539,15 @@ function checkSilentHold(e, n) {
         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 d = isLongHold(e);
-    if (d) c += ` ${boundaryRepair(e)}`;
-    const f = e.holdMs >= t.warnMs ? "warn" : "info";
+    const f = isLongHold(e);
+    if (f) c += ` ${boundaryRepair(e)}`;
+    const d = e.holdMs >= t.warnMs ? "warn" : "info";
     const u = holdData(e);
-    u.long = d;
+    u.long = f;
     emitDiagnostic({
         code: "SILENT_HOLD",
         kind: "responsiveness",
-        severity: f,
+        severity: d,
         message: c,
         nodeName: nodeName(n),
         data: u
@@ -1541,8 +1564,8 @@ function checkLongHold(e, n) {
     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 d = e.tailMs < e.holdMs - 1 ? ` after the last input (${e.holdMs.toFixed(0)}ms in all)` : "";
-    const f = `[LONG_HOLD] ${a}${a ? "wrote" : "writes to"} ${o}; the screen kept the old ` + `content for ${i}ms${d}${r} — ${c}, but the hold ran on well past ` + `the point where "loading" over stale content reads as broken. ${boundaryRepair(e)}`;
+    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;
@@ -1550,7 +1573,7 @@ function checkLongHold(e, n) {
         code: "LONG_HOLD",
         kind: "responsiveness",
         severity: u,
-        message: f,
+        message: d,
         nodeName: nodeName(n),
         data: l
     }, n);
@@ -1661,8 +1684,8 @@ function closeNavigation(e) {
 
 /** 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.tn) {
-        const e = n.$e?.origin;
+    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;
@@ -1671,8 +1694,8 @@ function closeNavigation(e) {
 
 /** 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.tn) {
-        const e = t.$e?.origin;
+    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;
@@ -1696,7 +1719,7 @@ function settleNavigation(e, n, t) {
     i.settledMs = now() - i.at;
     i.outcome = n;
     if (t !== undefined) i.hold = t;
-    recordFeedbackNavigation(i);
+    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);
@@ -1728,7 +1751,8 @@ function openInteraction(e) {
         open: true,
         writeDrain: drainSeq,
         heldIn: new Set,
-        held: false
+        held: false,
+        excludedWrites: 0
     };
     interactionStates.set(e, t);
     openInteractions.add(t);
@@ -1752,11 +1776,15 @@ function openInteraction(e) {
     return t !== undefined && openInteractions.has(t) ? t : undefined;
 }
 
-/** stampWrite: a root write stamped `origin`. */ function noteInteractionWrite(e) {
-    const n = openInteractionOf(e);
-    if (n === undefined) return;
-    n.event.writes++;
-    n.writeDrain = drainSeq;
+/** 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) {
@@ -1773,8 +1801,8 @@ function openInteraction(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.tn) {
-        const t = openInteractionOf(n.$e?.origin);
+    for (const n of e.sn) {
+        const t = openInteractionOf(n.ke?.origin);
         if (t !== undefined) {
             t.heldIn.add(e);
             t.held = true;
@@ -1804,6 +1832,14 @@ function maybeSettleInteraction(e, n = now()) {
         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);
@@ -1818,239 +1854,10 @@ function maybeSettleInteraction(e, n = now()) {
     return n;
 }
 
-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(e) {
-    let n = flightStats.get(e);
-    if (n === undefined) {
-        n = {
-            source: nodeName(e),
-            flights: 0,
-            landed: 0,
-            abandoned: 0,
-            landedMs: 0,
-            worstMs: 0
-        };
-        flightStats.set(e, n);
-    }
-    return n;
-}
-
-function trackFallback(e, n, t) {
-    let i = fallbackStats.get(e);
-    if (i === undefined) {
-        i = {
-            row: {
-                boundary: "boundary",
-                shows: 0,
-                shownMs: 0,
-                worstMs: 0,
-                flashes: 0
-            },
-            shownAt: null
-        };
-        fallbackStats.set(e, i);
-    }
-    // The first show can fire before the subtree exists; name on first sight.
-        if (i.row.boundary === "boundary" && n !== undefined) {
-        const e = ownerPath(n);
-        if (e !== undefined) i.row.boundary = e.join(" › ");
-    }
-    if (t) {
-        if (i.shownAt === null) {
-            i.shownAt = now();
-            i.row.shows++;
-        }
-        return;
-    }
-    if (i.shownAt === null) return;
-    const o = now() - i.shownAt;
-    i.shownAt = null;
-    i.row.shownMs += o;
-    if (o > i.row.worstMs) i.row.worstMs = o;
-    if (o < FALLBACK_FLASH_MS) i.row.flashes++;
-}
-
-/** No affordance answered and nothing painted while held. */ function isSilentHold(e) {
+/** @internal No affordance answered and nothing painted while held. */ function isSilentHold(e) {
     return e.paintedDuringHold === 0 && e.acknowledgements.length === 0;
 }
 
-function interactionBucket(e) {
-    const n = formatOrigin(e);
-    let t = feedbackInteractions.get(n);
-    if (t === undefined) {
-        t = {
-            row: {
-                interaction: n,
-                dispatches: 0,
-                runs: 0,
-                selfMs: 0,
-                worstDispatchMs: 0,
-                holds: 0,
-                heldMs: 0,
-                silentMs: 0,
-                worstHoldMs: 0
-            },
-            dispatches: new Map
-        };
-        feedbackInteractions.set(n, t);
-    }
-    const i = e.at ?? 0;
-    if (!t.dispatches.has(i)) {
-        t.dispatches.set(i, 0);
-        t.row.dispatches++;
-    }
-    return t;
-}
-
-function recordFeedbackRun(e) {
-    if (e.interaction === undefined) return;
-    const n = interactionBucket(e.interaction);
-    n.row.runs++;
-    n.row.selfMs += e.selfMs;
-    const t = e.interaction.at ?? 0;
-    const i = n.dispatches.get(t) + e.selfMs;
-    n.dispatches.set(t, i);
-    if (i > n.row.worstDispatchMs) n.row.worstDispatchMs = i;
-}
-
-function recordFeedbackHold(e) {
-    const n = [ ...e.blockers ].sort();
-    const t = n.join("\0");
-    let i = feedbackSources.get(t);
-    if (i === undefined) {
-        i = {
-            row: {
-                sources: n,
-                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(t, i);
-    }
-    const o = i.row;
-    const r = isSilentHold(e);
-    o.holds++;
-    o.heldMs += e.holdMs;
-    if (e.holdMs > o.worstMs) o.worstMs = e.holdMs;
-    if (r) {
-        o.silent++;
-        o.silentMs += e.holdMs;
-    } else if (e.acknowledgements.length > 0 && e.acknowledgements.every(e => e.kind === "latest")) o.latestOnly++;
-    if (isLongHold(e)) {
-        o.long++;
-        o.longMs += e.tailMs;
-    }
-    if (e.action) o.actions++;
-    for (const n of e.acknowledgements) {
-        const e = `${n.kind}:${n.source}`;
-        i.acks.set(e, (i.acks.get(e) ?? 0) + 1);
-    }
-    for (const n of e.heldWrites) i.writes.add(n.name);
-    if (e.interaction !== undefined) {
-        const n = formatOrigin(e.interaction);
-        i.interactions.set(n, (i.interactions.get(n) ?? 0) + 1);
-        const t = interactionBucket(e.interaction);
-        t.row.holds++;
-        t.row.heldMs += e.holdMs;
-        if (r) t.row.silentMs += e.holdMs;
-        if (e.holdMs > t.row.worstHoldMs) t.row.worstHoldMs = e.holdMs;
-    }
-}
-
-function recordFeedbackNavigation(e) {
-    const n = e.name ?? e.to;
-    if (n === undefined) return;
-    let t = feedbackNavigations.get(n);
-    if (t === undefined) {
-        t = {
-            name: n,
-            navigations: 0,
-            settledMs: 0,
-            worstMs: 0,
-            held: 0,
-            heldMs: 0,
-            silent: 0,
-            superseded: 0,
-            redirected: 0
-        };
-        feedbackNavigations.set(n, t);
-    }
-    t.navigations++;
-    if (e.redirects !== undefined) t.redirected++;
-    if (e.outcome === "superseded") {
-        t.superseded++;
-        return;
-    }
-    const i = e.settledMs;
-    t.settledMs += i;
-    if (i > t.worstMs) t.worstMs = i;
-    if (e.outcome === "held") {
-        t.held++;
-        t.heldMs += e.hold?.holdMs ?? i;
-        if (e.hold !== undefined && isSilentHold(e.hold)) t.silent++;
-    }
-}
-
-function rankedCounts(e, n) {
-    return [ ...e ].sort((e, n) => n[1] - e[1]).map(([e, t]) => ({
-        [n]: e,
-        holds: t
-    }));
-}
-
-function feedbackTables() {
-    const e = [ ...feedbackNavigations.values() ].map(e => ({
-        ...e
-    })).sort((e, n) => n.heldMs - e.heldMs || n.settledMs - e.settledMs);
-    const n = [ ...flightStats.values() ].map(e => ({
-        ...e
-    })).sort((e, n) => n.abandoned - e.abandoned || n.flights - e.flights);
-    const t = [ ...fallbackStats.values() ].map(e => ({
-        ...e.row
-    })).sort((e, n) => n.flashes - e.flashes || n.shownMs - e.shownMs);
-    const i = [ ...feedbackSources.values() ].map(e => ({
-        ...e.row,
-        acknowledgedBy: rankedCounts(e.acks, "by"),
-        interactions: rankedCounts(e.interactions, "interaction"),
-        writes: [ ...e.writes ]
-    })).sort((e, n) => n.silentMs - e.silentMs || n.heldMs - e.heldMs);
-    // Ranked by the total time the user spent on it: held plus synchronous work.
-        const o = [ ...feedbackInteractions.values() ].map(e => ({
-        ...e.row
-    })).sort((e, n) => n.heldMs + n.selfMs - (e.heldMs + e.selfMs));
-    return {
-        sources: i,
-        interactions: o,
-        navigations: e,
-        flights: n,
-        fallbacks: t
-    };
-}
-
 // 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.
@@ -2077,7 +1884,7 @@ const engineHooks = {
             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.Pe !== NOT_PENDING ? e.Pe : e.ge,
+            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.
@@ -2103,8 +1910,8 @@ const engineHooks = {
         // 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.Re) {
-            const n = e.Pe !== NOT_PENDING ? e.Pe : e.ge;
+                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
@@ -2112,7 +1919,7 @@ const engineHooks = {
         // 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.Re) checkUnstableOutput(e, s.prevValue, e.Pe !== NOT_PENDING ? e.Pe : e.ge);
+                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
@@ -2135,9 +1942,9 @@ const engineHooks = {
         trackFlightStart(e, n);
     },
     asyncStart(e) {
-        asyncStartSeq = e.$e?.seq ?? 0;
-        asyncStartTime = e.ae;
-        asyncStartValue = e.ge;
+        asyncStartSeq = e.ke?.seq ?? 0;
+        asyncStartTime = e.fe;
+        asyncStartValue = e.Ae;
     },
     asyncEnd(e, n, t, i) {
         if (i) {
@@ -2147,7 +1954,7 @@ const engineHooks = {
             // (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.ge !== asyncStartValue || e.ae !== asyncStartTime || e.Pe === t;
+            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).
@@ -2157,12 +1964,12 @@ const engineHooks = {
         // 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.$e;
+                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.xe, e);
+        pushFrame("effect", nodeName(e), e.Ye, e);
     },
     effectRunEnd() {
         popFrame("effect");
@@ -2194,14 +2001,17 @@ const engineHooks = {
     transitionMerged(e, n) {
         trackHoldMerge(e, n);
     },
-    storeReplaced(e, n, t, i, o) {
-        checkImmutableUpdate(e, n, t, i, o);
+    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) {
-        trackFallback(e, n, t);
+        for (const i of folds) i.fallback?.(e, n, t);
+    },
+    currentOrigin() {
+        return ambientOrigin();
     }
 };
 
@@ -2212,14 +2022,9 @@ const attribution = {
             ...e
         };
         frames.length = 0;
-        scopeCosts.clear();
-        writeCosts.clear();
         waterfallLog = [];
         holdLog = [];
         activeHold = null;
-        feedbackSources.clear();
-        feedbackInteractions.clear();
-        feedbackNavigations.clear();
         navigationLog = [];
         openNavs.clear();
         interactionLog = [];
@@ -2228,26 +2033,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 e of folds) e.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 = [];
@@ -2256,12 +2055,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 e of folds) e.reset?.();
         setAttributionHooks(null);
     },
     subscribe(e, n) {
@@ -2274,22 +2072,6 @@ const attribution = {
     history() {
         return history;
     },
-    why(e) {
-        const n = e?.[$REFRESH] ?? e;
-        return history.filter(e => e.node === n);
-    },
-    subscriptions(e) {
-        const n = e?.[$REFRESH] ?? e;
-        const t = [];
-        for (let e = n?.te ?? null; e !== null; e = e.ne) t.push(nodeName(e.oe));
-        return t;
-    },
-    costs() {
-        return {
-            scopes: [ ...scopeCosts.values() ].sort((e, n) => n.selfMs - e.selfMs),
-            writes: [ ...writeCosts.values() ].sort((e, n) => n.downstreamMs - e.downstreamMs)
-        };
-    },
     waterfalls() {
         return waterfallLog;
     },
@@ -2302,17 +2084,12 @@ const attribution = {
     interactions() {
         return interactionLog;
     },
-    feedback() {
-        return feedbackTables();
-    },
     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);
-    },
-    format: formatRerun,
-    formatOrigin: formatOrigin
+    }
 };
 
-export { attribution, formatOrigin, formatRerun };
+export { attribution, formatOrigin, formatRerun, isLongHold, isSilentHold, nodeName, now, registerFold, rootsOf };