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

package/dist/dev.js

@@ -183,6 +183,14 @@ const CONFIG_FRESH_READ = 1 << 16;
  * (A17). Cleared at commit (the commit IS the reveal); subscribers masked
  * during the hold are woken by finalizePureQueue's post-revert pass. */
 const CONFIG_HELD_TRUTH = 1 << 17;
+/** SLOT node (store leaf): created through `slotSignal` with `_host`/`_key`
+ * backrefs baked into the literal. The unobserved sweep dispatches these to
+ * the ONE shared hook (`setSlotUnobserved`) instead of a per-node closure
+ * held in a per-node extension — store mounts materialize one signal per
+ * touched leaf, so per-node allocations (options object, equals closure,
+ * unobserved closure, NodeExtension) were the measured create-floor bytes
+ * (warm dbmon profile: store node machinery ~36% + GC ~29%). */
+const CONFIG_SLOT_NODE = 1 << 18;
 const STATUS_PENDING = 1 << 0;
 const STATUS_ERROR = 1 << 1;
 const STATUS_UNINITIALIZED = 1 << 2;
@@ -233,7 +241,9 @@ const defaultOptions = {
   hotTime: { budgetMs: 8, windowMs: 1000 },
   unstableMemos: 4,
   wideWrites: 250,
-  waterfalls: { minFlightMs: 50 }
+  waterfalls: { minFlightMs: 50 },
+  holds: { infoMs: 100, warnMs: 200 },
+  longHolds: { infoMs: 500, warnMs: 1000 }
 };
 let options = { ...defaultOptions };
 const listeners = new Set();
@@ -309,6 +319,99 @@ function captureStack() {
 }
 /** 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();
+/**
+ * Set by `withInteraction` for the duration of a handler. Lives outside the
+ * enable/disable lifecycle on purpose: the web runtime marks dispatch whether
+ * or not an engine is listening, and enable() mid-handler must see the mark.
+ */
+let currentInteraction = null;
+/** The interaction an origin runs under (itself, when it is one). */
+function interactionOf(origin) {
+  if (origin === undefined) return undefined;
+  return origin.kind === "interaction" ? origin : origin.interaction;
+}
+/** The interaction a cause list traces back to — root writes only, derived links walked. */
+function interactionIn(causes) {
+  for (const c of causes) {
+    const found =
+      c.kind === "derived"
+        ? c.causes !== undefined
+          ? interactionIn(c.causes)
+          : undefined
+        : interactionOf(c.origin);
+    if (found !== undefined) return found;
+  }
+  return undefined;
+}
+function currentOrigin() {
+  const frame = originFrames[originFrames.length - 1];
+  if (frame !== undefined) return frame;
+  return currentInteraction ?? EXTERNAL_ORIGIN;
+}
+const effectFrames = new WeakMap();
+function pushFrame(kind, name, interaction, effect) {
+  const frame = { kind };
+  if (name) frame.name = name;
+  const under = interaction ?? currentInteraction ?? undefined;
+  if (under !== undefined) frame.interaction = under;
+  if (effect !== undefined) {
+    const node = effect;
+    if (node._devRunSeq !== undefined) frame.run = node._devRunSeq;
+    effectFrames.set(frame, { node: effect, causes: node._devRunCauses });
+  }
+  originFrames.push(frame);
+}
+function popFrame(kind) {
+  // Frames are strictly nested; a mismatch means enable() landed mid-frame
+  // (the opener never pushed) — leave the stack alone rather than pop a stranger.
+  const top = originFrames[originFrames.length - 1];
+  if (top !== undefined && top.kind === kind) originFrames.pop();
+}
+/**
+ * Run `fn` as the handler of a user interaction: every root write it performs
+ * (and every action step or effect the write causes) carries the interaction
+ * as provenance. The web runtime wraps event dispatch in this; it is dev-only
+ * and safe to call with no engine enabled.
+ */
+function withInteraction(ref, fn) {
+  const prev = currentInteraction;
+  const origin = { kind: "interaction", name: ref.type, at: ref.at ?? now() };
+  if (ref.target) origin.target = ref.target;
+  currentInteraction = origin;
+  try {
+    return fn();
+  } finally {
+    currentInteraction = prev;
+  }
+}
+/** `click on button#next "Next →"`, `effect "syncTitle"`, `action "save"`, … */
+function formatOrigin(origin) {
+  switch (origin.kind) {
+    case "interaction":
+      return `${origin.name} on ${origin.target ?? "an element"}`;
+    case "effect":
+      return `effect${origin.name ? ` "${origin.name}"` : ""}`;
+    case "action":
+      return `action${origin.name ? ` "${origin.name}"` : ""}`;
+    case "async":
+      return `async landing${origin.name ? ` on "${origin.name}"` : ""}`;
+    default:
+      return "outside the reactive system";
+  }
+}
 /** Record a root change (setSignal / refresh / async landing) on the node. */
 /**
  * Written-fan-out warning — the write-time complement of the always-on
@@ -332,17 +435,21 @@ function checkWideWrite(node, kind) {
   const message =
     `[WIDE_WRITE] ${verb} "${nodeName(node)}" reached ${subs} subscribers — every one ` +
     `re-runs this flush. If consumers ask keyed questions of this value (for example every ` +
-    `row comparing against one selected id), invert with createSelector or createProjection ` +
-    `so only the keys whose answer flipped update.`;
-  emitDiagnostic({
-    code: "WIDE_WRITE",
-    kind: "perf",
-    severity: "warn",
-    message,
-    nodeName: nodeName(node),
-    data: { subscribers: subs, write: kind }
-  });
-  console.warn(message);
+    `row comparing against one selected id), invert it: keep the answer in a store used as a ` +
+    `map keyed by id, so each consumer reads its own key and only the keys that flipped update.`;
+  reportDiagnostic(
+    emitDiagnostic(
+      {
+        code: "WIDE_WRITE",
+        kind: "perf",
+        severity: "warn",
+        message,
+        nodeName: nodeName(node),
+        data: { subscribers: subs, write: kind }
+      },
+      node
+    )
+  );
 }
 function stampWrite(node, kind, prev = NO_VALUES, value = NO_VALUES) {
   const record = { seq: ++changeSeq, kind, name: nodeName(node) };
@@ -350,8 +457,11 @@ function stampWrite(node, kind, prev = NO_VALUES, value = NO_VALUES) {
     record.prev = prev === NO_VALUES ? undefined : preview(prev);
     record.value = preview(value);
   }
+  record.origin = kind === "async" ? asyncOrigin(node) : currentOrigin();
+  record.at = now();
   record.stack = captureStack();
   node._devChange = record;
+  if (kind === "write") trackEffectWrite(node, record, value);
   // stampWrite is the single funnel for committed root invalidations (sync
   // writes, refresh(), async landings), which makes it the one place the
   // written-fan-out check needs to live.
@@ -416,15 +526,19 @@ function checkDepWidth(el) {
     `[WIDE_SCOPE_DEPS] ${kind} "${nodeName(el)}" is subscribed to ${count} sources — ` +
     `it re-runs when any of them change. Narrow its reads or split it into smaller memos. ` +
     `Sources: ${names.join(", ")}${count > names.length ? ", …" : ""}`;
-  emitDiagnostic({
-    code: "WIDE_SCOPE_DEPS",
-    kind: "perf",
-    severity: "warn",
-    message,
-    nodeName: nodeName(el),
-    data: { depCount: count, deps: names }
-  });
-  console.warn(message);
+  reportDiagnostic(
+    emitDiagnostic(
+      {
+        code: "WIDE_SCOPE_DEPS",
+        kind: "perf",
+        severity: "warn",
+        message,
+        nodeName: nodeName(el),
+        data: { depCount: count, deps: names }
+      },
+      el
+    )
+  );
 }
 const hotCauses = new Map();
 const HOT_FANOUT_FIRST_MILESTONE = 5;
@@ -465,19 +579,23 @@ function checkHotRuns(el, event) {
       `[HOT_SCOPE_RERUNS] ${event.nodeKind} "${event.nodeName}" re-ran ${node._devWinCount} times ` +
       `in ${Math.max(1, now - node._devWinStart)}ms — a hot signal is likely leaking into this ` +
       `scope. Latest cause: ${rootCause || "(untracked pull)"}`;
-    emitDiagnostic({
-      code: "HOT_SCOPE_RERUNS",
-      kind: "perf",
-      severity: "warn",
-      message,
-      nodeName: event.nodeName,
-      data: {
-        runs: node._devWinCount,
-        windowMs: cfg.windowMs,
-        causes: event.causes.map(c => c.name)
-      }
-    });
-    console.warn(message);
+    reportDiagnostic(
+      emitDiagnostic(
+        {
+          code: "HOT_SCOPE_RERUNS",
+          kind: "perf",
+          severity: "warn",
+          message,
+          nodeName: event.nodeName,
+          data: {
+            runs: node._devWinCount,
+            windowMs: cfg.windowMs,
+            causes: event.causes.map(c => c.name)
+          }
+        },
+        el
+      )
+    );
     return;
   }
   // Additional scopes hot from the same cause: silent until a milestone —
@@ -488,16 +606,22 @@ function checkHotRuns(el, event) {
     `[HOT_SCOPE_FANOUT] ${window.scopes} scopes have gone hot (${window.runs} re-runs) within ` +
     `${cfg.windowMs}ms, all driven by ${causeKey} — one hot cause is re-running a large part ` +
     `of the graph. Per-scope warnings are suppressed; fix the cause. If consumers ask keyed ` +
-    `questions of it, invert with createSelector or createProjection.`;
-  emitDiagnostic({
-    code: "HOT_SCOPE_FANOUT",
-    kind: "perf",
-    severity: "warn",
-    message,
-    nodeName: causeKey,
-    data: { cause: causeKey, scopes: window.scopes, runs: window.runs, windowMs: cfg.windowMs }
-  });
-  console.warn(message);
+    `questions of it, invert it: a store used as a map keyed by id, one key per consumer.`;
+  // The subject is the shared CAUSE, not this victim scope — no single owner
+  // path locates it, so the event carries none.
+  reportDiagnostic(
+    emitDiagnostic(
+      {
+        code: "HOT_SCOPE_FANOUT",
+        kind: "perf",
+        severity: "warn",
+        message,
+        nodeName: causeKey,
+        data: { cause: causeKey, scopes: window.scopes, runs: window.runs, windowMs: cfg.windowMs }
+      },
+      null
+    )
+  );
 }
 /**
  * Time-budget warning — the counterpart of checkHotRuns for the
@@ -522,23 +646,28 @@ function checkHotTime(el, event) {
     `[HOT_SCOPE_TIME] ${event.nodeKind} "${event.nodeName}" spent ` +
     `${node._devTimeWinMs.toFixed(1)}ms of compute inside one ${cfg.windowMs}ms window ` +
     `(budget ${cfg.budgetMs}ms). Latest cause: ${rootCause || "(untracked pull)"}`;
-  emitDiagnostic({
-    code: "HOT_SCOPE_TIME",
-    kind: "perf",
-    severity: "warn",
-    message,
-    nodeName: event.nodeName,
-    data: {
-      spentMs: node._devTimeWinMs,
-      budgetMs: cfg.budgetMs,
-      windowMs: cfg.windowMs,
-      causes: event.causes.map(c => c.name)
-    }
-  });
-  console.warn(message);
+  reportDiagnostic(
+    emitDiagnostic(
+      {
+        code: "HOT_SCOPE_TIME",
+        kind: "perf",
+        severity: "warn",
+        message,
+        nodeName: event.nodeName,
+        data: {
+          spentMs: node._devTimeWinMs,
+          budgetMs: cfg.budgetMs,
+          windowMs: cfg.windowMs,
+          causes: event.causes.map(c => c.name)
+        }
+      },
+      el
+    )
+  );
 }
 function recordRerun(el, causes, prevDeps, timing, changed, phase, held) {
   const node = el;
+  const prevCauses = node._devRunCauses;
   // 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.
@@ -565,19 +694,35 @@ function recordRerun(el, causes, prevDeps, timing, changed, phase, held) {
     phase,
     held
   };
+  const interaction = interactionIn(causes);
+  if (interaction !== undefined) event.interaction = interaction;
+  // The effect phase runs later in the flush with no cause list of its own:
+  // it inherits this run's interaction and is joined to this run's causes
+  // (see effectRunStart / pushFrame).
+  node._devRunInteraction = interaction;
+  node._devRunSeq = event.run;
+  node._devRunCauses = causes;
   history.push(event);
   if (history.length > options.historyLimit) history.shift();
   recordCosts(event);
+  recordFeedbackRun(event);
+  if (event.nodeKind === "effect") checkEffectCycle(el, causes);
+  checkRelayTear(el, causes, prevCauses);
   checkHotRuns(el, event);
   checkHotTime(el, event);
   checkDepWidth(el);
   for (const listener of listeners) listener(event);
-  if (options.log) console.log(formatRerun(event));
+  if (options.log) logRerun(event);
 }
 function formatCause(cause, depth, out) {
   const pad = "  ".repeat(depth + 1);
   let line = `${pad}← ${cause.kind === "derived" ? "memo" : "signal"} "${cause.name}" ${cause.kind === "derived" ? "changed" : cause.kind} (#${cause.seq})`;
   if (cause.prev !== undefined) line += ` ${cause.prev} → ${cause.value}`;
+  if (cause.origin !== undefined && cause.origin.kind !== "external") {
+    line += ` — ${formatOrigin(cause.origin)}`;
+    const under = cause.origin.interaction;
+    if (under !== undefined) line += ` (under ${formatOrigin(under)})`;
+  }
   out.push(line);
   if (cause.stack) for (const frame of cause.stack) out.push(`${pad}    ${frame}`);
   if (cause.causes && depth < 10) {
@@ -601,6 +746,22 @@ function formatRerun(event) {
   }
   return out.join("\n");
 }
+/**
+ * Console face of a re-run: the headline as a collapsed group with the
+ * why-chain and dep delta inside, so a busy console stays scannable (one line
+ * per run, evidence a click away). Consoles without grouping get the text.
+ */
+function logRerun(event) {
+  const text = formatRerun(event);
+  const nl = text.indexOf("\n");
+  if (nl === -1 || typeof console.groupCollapsed !== "function") {
+    console.log(text);
+    return;
+  }
+  console.groupCollapsed(text.slice(0, nl));
+  console.log(text.slice(nl + 1));
+  console.groupEnd();
+}
 /**
  * Values eligible for the unstable-output check: plain objects and arrays
  * only. Promises, iterators, Dates, Maps, class instances etc. all have no
@@ -664,15 +825,434 @@ function checkUnstableOutput(el, prevValue, newValue) {
     `${node._devUnstableRuns} consecutive runs — its equality gate never closes, so every ` +
     `subscriber re-runs on every upstream change. Return stable references or pass an ` +
     `\`equals\` option.`;
-  emitDiagnostic({
-    code: "UNSTABLE_MEMO_OUTPUT",
-    kind: "perf",
-    severity: "warn",
-    message,
-    nodeName: nodeName(el),
-    data: { runs: node._devUnstableRuns, shape }
-  });
-  console.warn(message);
+  reportDiagnostic(
+    emitDiagnostic(
+      {
+        code: "UNSTABLE_MEMO_OUTPUT",
+        kind: "perf",
+        severity: "warn",
+        message,
+        nodeName: nodeName(el),
+        data: { runs: node._devUnstableRuns, shape }
+      },
+      el
+    )
+  );
+}
+const EFFECT_CYCLE_MAX_HOPS = 6;
+const reportedCycles = new Set();
+let nextDevId = 0;
+const devIds = new WeakMap();
+function devId(node) {
+  let id = devIds.get(node);
+  if (id === undefined) devIds.set(node, (id = ++nextDevId));
+  return id;
+}
+function rootWrites(causes, out) {
+  for (const c of causes) {
+    if (c.kind === "derived") {
+      if (c.causes !== undefined) rootWrites(c.causes, out);
+    } else out.push(c);
+  }
+}
+/**
+ * The effect writes leading from an earlier run of `target` to the run whose
+ * `causes` these are, in causal order (target's own write first), or null.
+ */
+function findEffectCycle(target, causes, visited, hops) {
+  const roots = [];
+  rootWrites(causes, roots);
+  for (const write of roots) {
+    const origin = write.origin;
+    if (origin === undefined || origin.kind !== "effect") continue;
+    const info = effectFrames.get(origin);
+    if (info === undefined) continue;
+    if (info.node === target) return [{ effect: info.node, write }];
+    if (hops >= EFFECT_CYCLE_MAX_HOPS || visited.has(info.node) || info.causes === undefined)
+      continue;
+    visited.add(info.node);
+    const rest = findEffectCycle(target, info.causes, visited, hops + 1);
+    if (rest !== null) {
+      rest.push({ effect: info.node, write });
+      return rest;
+    }
+  }
+  return null;
+}
+/** Names of the memos between a direct cause of a run and `write`, root-first. */
+function derivedPath(causes, write, path) {
+  for (const c of causes) {
+    if (c === write) return true;
+    if (c.kind === "derived" && c.causes !== undefined) {
+      path.unshift(c.name);
+      if (derivedPath(c.causes, write, path)) return true;
+      path.shift();
+    }
+  }
+  return false;
+}
+function describeWrite(write) {
+  if (write.kind === "refresh") return `refreshed "${write.name}"`;
+  const values = write.prev !== undefined ? ` (${write.prev} → ${write.value})` : "";
+  return `wrote "${write.name}"${values}`;
+}
+function checkEffectCycle(el, causes) {
+  const links = findEffectCycle(el, causes, new Set([el]), 0);
+  if (links === null) return;
+  const key = links
+    .map(link => devId(link.effect))
+    .sort((a, b) => a - b)
+    .join(",");
+  if (reportedCycles.has(key)) return;
+  reportedCycles.add(key);
+  const flushes = links.length + 1;
+  let message;
+  if (links.length === 1) {
+    const [{ write }] = links;
+    const path = [];
+    derivedPath(causes, write, path);
+    const via = path.length > 0 ? ` through ${path.map(n => `memo "${n}"`).join(" → ")}` : "";
+    message =
+      `[EFFECT_WRITES_OWN_SOURCE] effect "${nodeName(el)}" re-ran because of its own write: it ` +
+      `${describeWrite(write)}, which fed back into its inputs${via}. Two flushes to settle, ` +
+      `and the screen rendered the pre-write value in between. The written value is a function ` +
+      `of what the effect reads — compute it in a memo (or normalize where the source is ` +
+      `written) instead of correcting it after the fact.`;
+  } else {
+    const names = links.map(link => `"${nodeName(link.effect)}"`);
+    const steps = links
+      .map(
+        (link, i) => `effect ${names[i]}${i > 0 ? " re-ran and" : ""} ${describeWrite(link.write)}`
+      )
+      .join("; ");
+    message =
+      `[EFFECT_WRITES_OWN_SOURCE] effects ${[...names, names[0]].join(" → ")} relay writes in a ` +
+      `cycle: ${steps}; which fed back into effect ${names[0]}'s inputs — ${flushes} flushes to ` +
+      `settle after each change, each rendering an intermediate state. Every relayed value is a ` +
+      `function of the original inputs: derive them in memos and drop the writes.`;
+  }
+  const severity = links.length === 1 ? "warn" : "info";
+  const entry = emitDiagnostic(
+    {
+      code: "EFFECT_WRITES_OWN_SOURCE",
+      kind: "perf",
+      severity,
+      message,
+      nodeName: nodeName(el),
+      data: {
+        effects: links.map(link => nodeName(link.effect)),
+        writes: links.map(link => ({
+          effect: nodeName(link.effect),
+          kind: link.write.kind,
+          name: link.write.name,
+          prev: link.write.prev,
+          value: link.write.value
+        })),
+        flushes
+      }
+    },
+    el
+  );
+  if (severity === "warn") reportDiagnostic(entry);
+}
+const RELAY_WARN_AT = 3;
+const relays = new Map();
+const copyWrites = new WeakSet();
+const copyReported = new WeakSet();
+/** The node each root write record was stamped on (records are serializable and cannot hold it). */
+const recordNodes = new WeakMap();
+/**
+ * Write-side bookkeeping for the relay heuristics: who has written this
+ * signal, and whether an effect just copied its compute output into it.
+ */
+function trackEffectWrite(node, record, value) {
+  const n = node;
+  const origin = record.origin;
+  const info =
+    origin !== undefined && origin.kind === "effect" ? effectFrames.get(origin) : undefined;
+  const writer = info === undefined ? 0 : devId(info.node);
+  recordNodes.set(record, node);
+  n._devSoleWriter = n._devSoleWriter === undefined || n._devSoleWriter === writer ? writer : null;
+  if (info !== undefined && value !== undefined && value === info.node._value) {
+    copyWrites.add(record);
+    n._devCopyRuns = n._devCopyFrom === writer ? (n._devCopyRuns ?? 0) + 1 : 1;
+    n._devCopyFrom = writer;
+    if (n._devCopyRuns >= 2 && n._devSoleWriter === writer) checkCopyEffect(info.node, node);
+  } else n._devCopyRuns = 0;
+}
+/** The effect's source whose current value the compute output is, if any (the prop-to-state port). */
+function passthroughSource(effect) {
+  for (let l = effect._deps; l !== null; l = l._nextDep)
+    if (l._dep._value === effect._value) return nodeName(l._dep);
+  return undefined;
+}
+/** The repair for a write that is the effect's compute output. */
+function copyRepair(effect, target) {
+  const source = passthroughSource(effect);
+  return source !== undefined
+    ? `The written value is "${source}" itself: read "${source}" where "${target}" is read ` +
+        `(or createMemo it if a stable derivation is needed) and delete the effect.`
+    : `The written value is the effect's compute output — by contract a pure function of ` +
+        `what it tracks: make "${target}" a memo of that computation and delete the effect.`;
+}
+function checkCopyEffect(effect, target) {
+  if (copyReported.has(target)) return;
+  copyReported.add(target);
+  const name = nodeName(target);
+  const message =
+    `[EFFECT_RELAY_TEAR] effect "${nodeName(effect)}" writes its compute output into ` +
+    `"${name}" on every run, and nothing else writes "${name}" — it is derived state kept ` +
+    `one flush late: everything reading it paints a frame behind everything reading the ` +
+    `source. ${copyRepair(effect, name)}`;
+  reportDiagnostic(
+    emitDiagnostic(
+      {
+        code: "EFFECT_RELAY_TEAR",
+        kind: "perf",
+        severity: "warn",
+        message,
+        nodeName: nodeName(effect),
+        data: {
+          relay: nodeName(effect),
+          wrote: name,
+          copy: true,
+          passthrough: passthroughSource(effect) ?? null,
+          soleWriter: true
+        }
+      },
+      effect
+    )
+  );
+}
+/**
+ * `victim` re-ran with `causes`; its previous run had `prevCauses`. A tear is
+ * a re-run whose root writes ALL came from effects (no independent outside
+ * cause) and at least one of which was made by a run that shares a root
+ * write with the victim's previous run.
+ */
+function checkRelayTear(victim, causes, prevCauses) {
+  if (prevCauses === undefined || causes.length === 0) return;
+  const roots = [];
+  rootWrites(causes, roots);
+  if (roots.length === 0) return;
+  let relay;
+  let write;
+  let shared;
+  for (const root of roots) {
+    const origin = root.origin;
+    if (origin === undefined || origin.kind !== "effect") return;
+    const info = effectFrames.get(origin);
+    // Own-source cycles are EFFECT_WRITES_OWN_SOURCE's; a create-run relay
+    // is initial sync, not a tear for one change.
+    if (info === undefined || info.node === victim || info.causes === undefined) return;
+    if (shared === undefined) {
+      const relayRoots = [];
+      rootWrites(info.causes, relayRoots);
+      const prevRoots = [];
+      rootWrites(prevCauses, prevRoots);
+      const hit = relayRoots.find(r => prevRoots.includes(r));
+      if (hit !== undefined) {
+        shared = hit;
+        relay = info;
+        write = root;
+      }
+    }
+  }
+  if (shared === undefined || relay === undefined || write === undefined) return;
+  const key = `${devId(relay.node)}:${write.name}`;
+  let state = relays.get(key);
+  if (state === undefined) relays.set(key, (state = { count: 0, warned: false }));
+  state.count++;
+  const copy = copyWrites.has(write);
+  const target = recordNodes.get(write);
+  const soleWriter = target !== undefined && target._devSoleWriter === devId(relay.node);
+  // Derivable outright: the value is the compute output and nothing else
+  // writes the signal. A copy INTO a signal that has other writers is the
+  // "reset editable state from a source" shape — the tear is real, but a memo
+  // is not the answer, so it stays advisory like any other non-derivable tear.
+  const derivable = copy && soleWriter;
+  const severity = derivable || state.count >= RELAY_WARN_AT ? "warn" : "info";
+  // First sighting always reports (advisory); afterwards only the escalation.
+  if (state.count > 1 && (severity !== "warn" || state.warned)) return;
+  // One verdict per derivable signal: the copy report (checkCopyEffect) and
+  // the tear report carry the same repair.
+  if (derivable && target !== undefined) {
+    if (copyReported.has(target)) return;
+    copyReported.add(target);
+  }
+  if (severity === "warn") state.warned = true;
+  const victimKind = victim._type ? "effect" : "memo";
+  const relayName = nodeName(relay.node);
+  const repair = derivable
+    ? copyRepair(relay.node, write.name)
+    : copy
+      ? `The written value is the effect's compute output, but "${write.name}" has other ` +
+        `writers — editable state reset from a source. If the reset is the intent, the tear ` +
+        `is its cost; if "${write.name}" only ever mirrors the source, drop the local copy ` +
+        `and read the source.`
+      : soleWriter
+        ? `Nothing else writes "${write.name}" — it is derived state: make it a memo over what ` +
+          `the effect reads and every reader gets it in the same flush.`
+        : `If "${write.name}" is computed from what the effect reads, make it a memo so readers ` +
+          `get it in the same flush; if the write reads something outside the graph (layout, ` +
+          `time), the tear is the cost of measuring.`;
+  const message =
+    `[EFFECT_RELAY_TEAR] ${victimKind} "${nodeName(victim)}" ran twice for one write of ` +
+    `"${shared.name}": once in the flush where "${shared.name}" changed, and again after ` +
+    `effect "${relayName}" relayed it by writing "${write.name}" — the first frame showed the ` +
+    `new "${shared.name}" with the stale "${write.name}"` +
+    (state.count > 1 ? ` (${state.count} times so far)` : "") +
+    `. ${repair}`;
+  const entry = emitDiagnostic(
+    {
+      code: "EFFECT_RELAY_TEAR",
+      kind: "perf",
+      severity,
+      message,
+      nodeName: nodeName(victim),
+      data: {
+        victim: nodeName(victim),
+        root: shared.name,
+        relay: relayName,
+        wrote: write.name,
+        copy,
+        passthrough: copy ? (passthroughSource(relay.node) ?? null) : null,
+        soleWriter,
+        occurrences: state.count
+      }
+    },
+    victim
+  );
+  if (severity === "warn") reportDiagnostic(entry);
+}
+// --- Immutable updates in stores ---------------------------------------------
+//
+// `draft.user = { ...draft.user, name }` / `draft.items = [...draft.items,
+// x]` / `draft.items = draft.items.filter(...)` — the React habit of
+// producing a fresh container to change one leaf. The store tracks leaves, so
+// a fresh container is pure cost: every reader of `user` (any path below it)
+// re-runs for the one leaf that moved, where a draft mutation would re-run
+// only the readers of `name`. The store's notify sees both containers at the
+// write and reports a leaf census (identity on unwrapped values, capped); the
+// verdict is the whole detector: a replacement whose leaves are mostly the
+// SAME values is a spread-copy, and one whose leaves are mostly different is
+// new data (reconcile's job — and UNSTABLE_LIST_IDENTITY's, downstream). Once
+// per store path.
+const immutableReported = new Set();
+function checkImmutableUpdate(path, isArray, total, same, prevTotal) {
+  if (immutableReported.has(path) || total < 2) return;
+  // Push/filter/splice copies change the length by a little; a wholesale
+  // resize is a different operation even if some items survive.
+  if (isArray && Math.abs(prevTotal - total) > Math.max(1, total >> 2)) return;
+  // At least half the leaves carried over unchanged, and at least one did.
+  if (same === 0 || same * 2 < total) return;
+  immutableReported.add(path);
+  const changed = total - same;
+  const shape = isArray ? "array" : "object";
+  const repair = isArray
+    ? `mutate the draft in place (push/splice/index assignment) so only the touched ` +
+      `indices notify`
+    : `assign the leaf on the draft (\`${path}.<key> = …\`) so only readers of that key re-run`;
+  const message =
+    `[IMMUTABLE_UPDATE_IN_STORE] "${path}" was replaced with a fresh ${shape} whose ` +
+    `${isArray ? "items" : "leaves"} are mostly the same values (${same} of ${total} unchanged` +
+    `${changed > 0 ? `, ${changed} changed` : ""}) — a spread-copy update. The store already ` +
+    `tracks ${isArray ? "items" : "leaves"}; a new container makes every reader of "${path}" ` +
+    `re-run for the ${changed === 1 ? "one that" : "few that"} moved. Instead, ${repair}. For ` +
+    `data arriving from outside (a fetch result), merge it with reconcile(data, key)(${path}).`;
+  reportDiagnostic(
+    emitDiagnostic({
+      code: "IMMUTABLE_UPDATE_IN_STORE",
+      kind: "perf",
+      severity: "warn",
+      message,
+      nodeName: path,
+      data: { path, shape, total, unchanged: same, changed }
+    })
+  );
+}
+// --- Unstable list identity -----------------------------------------------------
+//
+// `<For>` keyed by identity (the default) treats every new object as a new
+// row. When a re-fetch hands back fresh objects for the same records, or a
+// spread-copy rebuilds the array, most rows are disposed and recreated —
+// DOM, state, focus, and all — for data that did not change. mapArray knows
+// exactly which items exited and entered; pairing them (by `id` when the
+// items carry one, else by position) and sampling shallow equivalence turns
+// that into a verdict: churn that replaced equivalent records is unstable
+// identity, not a new list. A key function that still churns has the same
+// disease one level up (its keys are not stable). Once per list.
+const LIST_CHURN_SAMPLE = 8;
+const listIdentityWarned = new WeakSet();
+function recordId(item) {
+  if (item === null || typeof item !== "object") return undefined;
+  const o = item;
+  return o.id ?? o.key ?? o._id ?? undefined;
+}
+function checkListIdentity(el, removed, created, newLen, keyed) {
+  if (listIdentityWarned.has(el)) return;
+  // Most of the list turned over, and the turnover was a swap (rows out ≈ rows in).
+  if (created.length < 2 || created.length * 2 < newLen) return;
+  if (Math.abs(removed.length - created.length) > Math.max(1, created.length >> 2)) return;
+  // Pair exited with entered: by record id when present, else by position.
+  const byId = new Map();
+  for (const item of removed) {
+    const id = recordId(item);
+    if (id !== undefined) byId.set(id, item);
+  }
+  let sampled = 0;
+  let equivalent = 0;
+  const step = Math.max(1, Math.floor(created.length / LIST_CHURN_SAMPLE));
+  for (let i = 0; i < created.length && sampled < LIST_CHURN_SAMPLE; i += step) {
+    const item = created[i];
+    const id = recordId(item);
+    const prev = id !== undefined ? byId.get(id) : removed[i];
+    if (prev === undefined || !isPlainShape(prev) || !isPlainShape(item)) continue;
+    sampled++;
+    if (shallowEquivalent(prev, item)) equivalent++;
+  }
+  if (sampled === 0 || equivalent * 2 < sampled) return;
+  listIdentityWarned.add(el);
+  const name = nodeName(el);
+  const repair = keyed
+    ? `The key function returned different keys for equivalent records — return a stable ` +
+      `field (\`keyed: item => item.id\`), not the object or a computed value that changes ` +
+      `with the fetch.`
+    : `Key the list by a stable field (\`keyed: item => item.id\`), or merge the data into ` +
+      `a store with reconcile(data, "id") so the same records keep the same identity.`;
+  const message =
+    `[UNSTABLE_LIST_IDENTITY] list "${name}" recreated ${created.length} of ${newLen} rows on ` +
+    `an update where the entering items are equivalent to the ones they replaced ` +
+    `(${equivalent} of ${sampled} sampled pairs identical field-for-field) — fresh objects ` +
+    `for the same records, so identity keying threw away every row's DOM and state and ` +
+    `rebuilt it. ${repair}`;
+  reportDiagnostic(
+    emitDiagnostic(
+      {
+        code: "UNSTABLE_LIST_IDENTITY",
+        kind: "perf",
+        severity: "warn",
+        message,
+        nodeName: name,
+        data: {
+          removed: removed.length,
+          created: created.length,
+          length: newLen,
+          sampled,
+          equivalent,
+          keyed
+        }
+      },
+      el
+    )
+  );
+}
+/** Provenance of an async landing: the flight, under the interaction that started it. */
+function asyncOrigin(el) {
+  const origin = { kind: "async", name: nodeName(el) };
+  const interaction = liveFlights.get(el)?.interaction;
+  if (interaction !== undefined) origin.interaction = interaction;
+  return origin;
 }
 // WeakMaps: an errored/abandoned flight must not leak its node or block GC.
 const liveFlights = new WeakMap();
@@ -697,30 +1277,39 @@ function flightCauseIn(causes) {
   return best;
 }
 function trackFlightStart(el, flight) {
-  if (options.waterfalls === false) return;
   const at = now();
   const origin = flightOrigins.get(flight) ?? at;
   if (origin === at) flightOrigins.set(flight, at);
+  // Census: a flight still in the air when the node starts another was
+  // superseded — its answer will be discarded.
+  const stats = flightBucket(el);
+  stats.flights++;
+  if (liveFlights.has(el)) stats.abandoned++;
   // 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 parent = null;
+  let causes = null;
   for (let i = frames.length - 1; i >= 0; i--) {
-    const causes = frames[i].causes;
-    if (causes !== null) {
-      parent = flightCauseIn(causes);
+    if (frames[i].causes !== null) {
+      causes = frames[i].causes;
       break;
     }
   }
-  // The sequentiality test. A marked/previously-seen flight whose origin
-  // predates the upstream landing was in the air alongside it: parallel.
-  if (parent !== null && origin < parent.landedAt) parent = null;
-  liveFlights.set(el, {
-    origin,
-    startSeq: changeSeq,
-    chain: parent === null ? [] : [...parent.chain, { name: parent.name, ms: parent.ms }]
-  });
+  const live = { origin, startSeq: changeSeq, chain: [] };
+  // Provenance: the flight belongs to whatever interaction caused the
+  // recompute that started it (a create run under a click's handler — a
+  // freshly mounted async node — inherits the ambient interaction instead).
+  const interaction = causes !== null ? interactionIn(causes) : (currentInteraction ?? undefined);
+  if (interaction !== undefined) live.interaction = interaction;
+  if (options.waterfalls !== false && causes !== null) {
+    let parent = flightCauseIn(causes);
+    // The sequentiality test. A marked/previously-seen flight whose origin
+    // predates the upstream landing was in the air alongside it: parallel.
+    if (parent !== null && origin < parent.landedAt) parent = null;
+    if (parent !== null) live.chain = [...parent.chain, { name: parent.name, ms: parent.ms }];
+  }
+  liveFlights.set(el, live);
 }
 /**
  * Flight landed (whether or not the value committed — the wall time was
@@ -733,6 +1322,10 @@ function finalizeFlight(el) {
   liveFlights.delete(el);
   const landedAt = now();
   const ms = landedAt - flight.origin;
+  const stats = flightBucket(el);
+  stats.landed++;
+  stats.landedMs += ms;
+  if (ms > stats.worstMs) stats.worstMs = ms;
   const record = el._devChange;
   // Only a stamp this landing produced may carry the measurement — a stale
   // async record from a previous landing must not be re-labeled.
@@ -778,15 +1371,429 @@ function checkWaterfall(el, chain, ms) {
   // preload. A 3+ chain that survived the origin test is near-certainly
   // structural — that one earns the console.
   const severity = seq > 2 ? "warn" : "info";
-  emitDiagnostic({
-    code: "ASYNC_WATERFALL",
-    kind: "perf",
-    severity,
-    message,
-    nodeName: nodeName(el),
-    data: { chain: links.map(l => ({ name: l.name, ms: l.ms })), sequentialMs: totalMs }
-  });
-  if (severity === "warn") console.warn(message);
+  const entry = emitDiagnostic(
+    {
+      code: "ASYNC_WATERFALL",
+      kind: "perf",
+      severity,
+      message,
+      nodeName: nodeName(el),
+      data: { chain: links.map(l => ({ name: l.name, ms: l.ms })), sequentialMs: totalMs }
+    },
+    el
+  );
+  if (severity === "warn") reportDiagnostic(entry);
+}
+const holdStates = new WeakMap();
+let activeHold = null;
+let holdLog = [];
+/** Companions are optimistic nodes too; `_parentSource` marks them. */
+function isCompanion(node) {
+  return !!node._x && node._x._parentSource !== undefined;
+}
+function censusRegistrations(t, state) {
+  for (const node of t._optimisticNodes)
+    if (!isCompanion(node)) state.acknowledgedBy.add(`optimistic:${nodeName(node)}`);
+  for (const store of t._optimisticStores)
+    state.acknowledgedBy.add(`optimistic:${store?._name ?? "store"}`);
+  for (const node of t._affectsNodes) state.acknowledgedBy.add(`affects:${nodeName(node)}`);
+}
+const HOLD_CENSUS_CAP = 10_000;
+/** Companions with live readers, anywhere downstream of the hold's nodes. */
+function censusCompanions(roots, out) {
+  const visited = new Set();
+  const stack = [...roots];
+  while (stack.length > 0 && visited.size < HOLD_CENSUS_CAP) {
+    const node = stack.pop();
+    if (visited.has(node)) continue;
+    visited.add(node);
+    const x = node._x;
+    if (x) {
+      if (x._pendingSignal !== undefined && x._pendingSignal._subs !== null)
+        out.add(`isPending:${nodeName(node)}`);
+      if (x._latestValueComputed !== undefined && x._latestValueComputed._subs !== null)
+        out.add(`latest:${nodeName(node)}`);
+      for (let child = x._child ?? null; child !== null; child = child._nextChild ?? null)
+        stack.push(child);
+    }
+    for (let s = node._subs; s !== null; s = s._nextSub) stack.push(s._sub);
+  }
+}
+function holdState(t) {
+  let state = holdStates.get(t);
+  if (state === undefined) {
+    state = {
+      start: now(),
+      flushes: 0,
+      blockers: new Set(),
+      acknowledgedBy: new Set(),
+      painted: 0,
+      action: false
+    };
+    holdStates.set(t, state);
+  }
+  return state;
+}
+function trackHoldStart(t) {
+  if (options.holds === false) return;
+  const state = holdState(t);
+  state.flushes++;
+  if (t._actions.length > 0) state.action = true;
+  for (const [source, reporters] of t._asyncReporters)
+    if (reporters.size > 0) state.blockers.add(source);
+  censusRegistrations(t, state);
+  activeHold = state;
+}
+function trackHoldMerge(target, outgoing) {
+  const from = holdStates.get(outgoing);
+  if (from === undefined) return;
+  holdStates.delete(outgoing);
+  const into = holdState(target);
+  if (from.start < into.start) into.start = from.start;
+  into.flushes += from.flushes;
+  into.painted += from.painted;
+  into.action ||= from.action;
+  for (const b of from.blockers) into.blockers.add(b);
+  for (const a of from.acknowledgedBy) into.acknowledgedBy.add(a);
+}
+function trackHoldSettled(t) {
+  const state = holdStates.get(t);
+  if (state === undefined) return;
+  holdStates.delete(t);
+  // Root writes only: a memo in _pendingNodes is a derived hold, and the
+  // question is whether the USER's input went unanswered.
+  const heldWrites = [];
+  let subject = null;
+  let interaction;
+  let lastJoinAt = -Infinity;
+  for (const node of t._pendingNodes) {
+    if (typeof node._fn === "function" || isCompanion(node)) continue;
+    const change = node._devChange;
+    if (change === undefined || change.kind !== "write") continue;
+    if (subject === null) subject = node;
+    const held = { name: nodeName(node), prev: change.prev, value: change.value };
+    if (change.origin !== undefined) held.origin = change.origin;
+    heldWrites.push(held);
+    // Earliest interaction among the held writes: the user has been waiting
+    // since the first thing they did that this transaction is holding.
+    const under = interactionOf(change.origin);
+    if (under !== undefined && (interaction === undefined || under.at < interaction.at))
+      interaction = under;
+    // Latest write: a signal written twice while held carries the later
+    // stamp, so this is the user's final input, not their first.
+    if (change.at !== undefined && change.at > lastJoinAt) lastJoinAt = change.at;
+  }
+  if (heldWrites.length === 0) return;
+  censusRegistrations(t, state);
+  censusCompanions([...t._pendingNodes, ...state.blockers], state.acknowledgedBy);
+  const end = now();
+  // The hold began no later than its first parked flush; an interaction stamp
+  // reaches further back (dispatch). A node rewritten mid-hold keeps only its
+  // latest record, so the surviving interaction may be a later one — the
+  // flush clock keeps the first wait from being forgotten.
+  const holdMs = end - Math.min(state.start, interaction !== undefined ? interaction.at : Infinity);
+  const event = {
+    holdMs,
+    tailMs: lastJoinAt === -Infinity ? holdMs : Math.min(holdMs, end - lastJoinAt),
+    flushes: state.flushes,
+    heldWrites,
+    blockers: [...state.blockers].map(nodeName),
+    acknowledgedBy: [...state.acknowledgedBy],
+    paintedDuringHold: state.painted,
+    action: state.action
+  };
+  if (interaction !== undefined) event.interaction = interaction;
+  holdLog.push(event);
+  if (holdLog.length > options.historyLimit) holdLog.shift();
+  recordFeedbackHold(event);
+  if (isSilentHold(event)) checkSilentHold(event, subject);
+  else checkLongHold(event, subject);
+}
+/** `isLongHold` — the tail outlasted `longHolds.infoMs`. */
+function isLongHold(event) {
+  const cfg = options.longHolds;
+  return cfg !== false && cfg !== undefined && event.tailMs >= cfg.infoMs;
+}
+function describeHeldWrites(event) {
+  return event.heldWrites
+    .map(w => (w.prev !== undefined ? `"${w.name}" (${w.prev} → ${w.value})` : `"${w.name}"`))
+    .join(", ");
+}
+function describeBlockers(event, lead) {
+  return event.blockers.length > 0
+    ? ` ${lead} ${event.blockers.map(b => `"${b}"`).join(", ")}`
+    : "";
+}
+/**
+ * The boundary repair, shared by LONG_HOLD and a long SILENT_HOLD: a wait
+ * this long should show a fallback, not a stale screen. A `Loading` boundary
+ * lifts the write out of the hold only when it has not revealed yet or its
+ * `on` prop changed — a revealed boundary with no `on` IS the stale screen.
+ */
+function boundaryRepair(event) {
+  const key = event.heldWrites[0]?.name ?? "key";
+  return (
+    `A wait this long is past what a stale screen should carry: show a fallback instead. Put ` +
+    `the reader behind a Loading boundary keyed on what changed — <Loading on={${key}()} ` +
+    `fallback={…}> — so the write commits at once and the fallback shows where the data lands; ` +
+    `a boundary that has already revealed keeps the old content unless \`on\` changes. If the ` +
+    `data itself is the problem, preload it or cache it so the wait never gets this long.`
+  );
+}
+function holdData(event) {
+  const data = {
+    holdMs: event.holdMs,
+    tailMs: event.tailMs,
+    flushes: event.flushes,
+    heldWrites: event.heldWrites.map(w => w.name),
+    blockers: event.blockers,
+    action: event.action
+  };
+  if (event.interaction !== undefined)
+    data.interaction = { type: event.interaction.name, target: event.interaction.target };
+  return data;
+}
+function checkSilentHold(event, subject) {
+  const cfg = options.holds;
+  if (cfg === false) return;
+  if (event.holdMs < cfg.infoMs) return;
+  const ms = event.holdMs.toFixed(0);
+  const writes = describeHeldWrites(event);
+  const waitedOn = describeBlockers(event, "waiting on");
+  // With the interaction stamped the sentence starts from what the user did;
+  // without it, from the writes.
+  const who = event.interaction !== undefined ? `${formatOrigin(event.interaction)} ` : "";
+  let message = event.action
+    ? `[SILENT_HOLD] ${who}${who ? "started an action that" : "an action"} held ${writes} for ` +
+      `${ms}ms${waitedOn} and the screen showed nothing for the whole round-trip: no optimistic ` +
+      `value, no isPending() reader, no affects() mark, and no effect ran while it was held. ` +
+      `Pair the action with a createOptimistic/createOptimisticStore write for the expected ` +
+      `outcome (it reverts on failure), or co-write a createOptimistic(false) "saving" flag ` +
+      `the UI reads.`
+    : `[SILENT_HOLD] ${who}${who ? "wrote" : "writes to"} ${writes}${who ? "; the write was" : " were"} ` +
+      `held ${ms}ms${waitedOn} and the screen showed nothing for the wait: no ` +
+      `isPending()/latest() reader downstream, no optimistic value, no affects() mark, and no ` +
+      `effect ran while it was held — the interaction was dead for ${ms}ms. Show the wait: ` +
+      `read isPending(() => ${event.blockers[0] ?? "source"}()) to render a busy state, or ` +
+      `latest(${event.heldWrites[0].name}) to reveal the new input immediately while the data ` +
+      `catches up. The hold itself is correct — do not "fix" this by moving the write off the ` +
+      `async path.`;
+  const long = isLongHold(event);
+  if (long) message += ` ${boundaryRepair(event)}`;
+  const severity = event.holdMs >= cfg.warnMs ? "warn" : "info";
+  const data = holdData(event);
+  data.long = long;
+  const entry = emitDiagnostic(
+    {
+      code: "SILENT_HOLD",
+      kind: "responsiveness",
+      severity,
+      message,
+      nodeName: nodeName(subject),
+      data
+    },
+    subject
+  );
+  if (severity === "warn") reportDiagnostic(entry);
+}
+function checkLongHold(event, subject) {
+  const cfg = options.longHolds;
+  if (cfg === false || cfg === undefined) return;
+  if (event.tailMs < cfg.infoMs) return;
+  const tail = event.tailMs.toFixed(0);
+  const writes = describeHeldWrites(event);
+  const waitedOn = describeBlockers(event, "waiting on");
+  const who = event.interaction !== undefined ? `${formatOrigin(event.interaction)} ` : "";
+  const answered =
+    event.acknowledgedBy.length > 0
+      ? `${event.acknowledgedBy.map(a => `"${a}"`).join(", ")} said it was pending`
+      : `an effect painted meanwhile`;
+  const sinceLast =
+    event.tailMs < event.holdMs - 1
+      ? ` after the last input (${event.holdMs.toFixed(0)}ms in all)`
+      : "";
+  const message =
+    `[LONG_HOLD] ${who}${who ? "wrote" : "writes to"} ${writes}; the screen kept the old ` +
+    `content for ${tail}ms${sinceLast}${waitedOn} — ${answered}, but the hold ran on well past ` +
+    `the point where "loading" over stale content reads as broken. ${boundaryRepair(event)}`;
+  const severity = event.tailMs >= cfg.warnMs ? "warn" : "info";
+  const data = holdData(event);
+  data.acknowledgedBy = event.acknowledgedBy;
+  const entry = emitDiagnostic(
+    {
+      code: "LONG_HOLD",
+      kind: "responsiveness",
+      severity,
+      message,
+      nodeName: nodeName(subject),
+      data
+    },
+    subject
+  );
+  if (severity === "warn") reportDiagnostic(entry);
+}
+const feedbackSources = new Map();
+const feedbackInteractions = new Map();
+const flightStats = new Map();
+const fallbackStats = new Map();
+const FALLBACK_FLASH_MS = 150;
+function flightBucket(el) {
+  let row = flightStats.get(el);
+  if (row === undefined) {
+    row = { source: nodeName(el), flights: 0, landed: 0, abandoned: 0, landedMs: 0, worstMs: 0 };
+    flightStats.set(el, row);
+  }
+  return row;
+}
+function trackFallback(boundary, tree, shown) {
+  let bucket = fallbackStats.get(boundary);
+  if (bucket === undefined) {
+    bucket = {
+      row: { boundary: "boundary", shows: 0, shownMs: 0, worstMs: 0, flashes: 0 },
+      shownAt: null
+    };
+    fallbackStats.set(boundary, bucket);
+  }
+  // The first show can fire before the subtree exists; name on first sight.
+  if (bucket.row.boundary === "boundary" && tree !== undefined) {
+    const path = ownerPath(tree);
+    if (path !== undefined) bucket.row.boundary = path.join(" › ");
+  }
+  if (shown) {
+    if (bucket.shownAt === null) {
+      bucket.shownAt = now();
+      bucket.row.shows++;
+    }
+    return;
+  }
+  if (bucket.shownAt === null) return;
+  const ms = now() - bucket.shownAt;
+  bucket.shownAt = null;
+  bucket.row.shownMs += ms;
+  if (ms > bucket.row.worstMs) bucket.row.worstMs = ms;
+  if (ms < FALLBACK_FLASH_MS) bucket.row.flashes++;
+}
+/** No affordance answered and nothing painted while held. */
+function isSilentHold(event) {
+  return event.paintedDuringHold === 0 && event.acknowledgedBy.length === 0;
+}
+function interactionBucket(interaction) {
+  const key = formatOrigin(interaction);
+  let bucket = feedbackInteractions.get(key);
+  if (bucket === undefined) {
+    bucket = {
+      row: {
+        interaction: key,
+        dispatches: 0,
+        runs: 0,
+        selfMs: 0,
+        worstDispatchMs: 0,
+        holds: 0,
+        heldMs: 0,
+        silentMs: 0,
+        worstHoldMs: 0
+      },
+      dispatches: new Map()
+    };
+    feedbackInteractions.set(key, bucket);
+  }
+  const at = interaction.at ?? 0;
+  if (!bucket.dispatches.has(at)) {
+    bucket.dispatches.set(at, 0);
+    bucket.row.dispatches++;
+  }
+  return bucket;
+}
+function recordFeedbackRun(event) {
+  if (event.interaction === undefined) return;
+  const bucket = interactionBucket(event.interaction);
+  bucket.row.runs++;
+  bucket.row.selfMs += event.selfMs;
+  const at = event.interaction.at ?? 0;
+  const dispatchMs = bucket.dispatches.get(at) + event.selfMs;
+  bucket.dispatches.set(at, dispatchMs);
+  if (dispatchMs > bucket.row.worstDispatchMs) bucket.row.worstDispatchMs = dispatchMs;
+}
+function recordFeedbackHold(event) {
+  const sources = [...event.blockers].sort();
+  const key = sources.join("\u0000");
+  let bucket = feedbackSources.get(key);
+  if (bucket === undefined) {
+    bucket = {
+      row: {
+        sources,
+        holds: 0,
+        heldMs: 0,
+        worstMs: 0,
+        silent: 0,
+        silentMs: 0,
+        latestOnly: 0,
+        long: 0,
+        longMs: 0,
+        acknowledgedBy: [],
+        interactions: [],
+        writes: [],
+        actions: 0
+      },
+      acks: new Map(),
+      interactions: new Map(),
+      writes: new Set()
+    };
+    feedbackSources.set(key, bucket);
+  }
+  const row = bucket.row;
+  const silent = isSilentHold(event);
+  row.holds++;
+  row.heldMs += event.holdMs;
+  if (event.holdMs > row.worstMs) row.worstMs = event.holdMs;
+  if (silent) {
+    row.silent++;
+    row.silentMs += event.holdMs;
+  } else if (
+    event.acknowledgedBy.length > 0 &&
+    event.acknowledgedBy.every(by => by.startsWith("latest:"))
+  )
+    row.latestOnly++;
+  if (isLongHold(event)) {
+    row.long++;
+    row.longMs += event.tailMs;
+  }
+  if (event.action) row.actions++;
+  for (const by of event.acknowledgedBy) bucket.acks.set(by, (bucket.acks.get(by) ?? 0) + 1);
+  for (const w of event.heldWrites) bucket.writes.add(w.name);
+  if (event.interaction !== undefined) {
+    const key = formatOrigin(event.interaction);
+    bucket.interactions.set(key, (bucket.interactions.get(key) ?? 0) + 1);
+    const ib = interactionBucket(event.interaction);
+    ib.row.holds++;
+    ib.row.heldMs += event.holdMs;
+    if (silent) ib.row.silentMs += event.holdMs;
+    if (event.holdMs > ib.row.worstHoldMs) ib.row.worstHoldMs = event.holdMs;
+  }
+}
+function rankedCounts(counts, key) {
+  return [...counts].sort((a, b) => b[1] - a[1]).map(([name, holds]) => ({ [key]: name, holds }));
+}
+function feedbackTables() {
+  const flights = [...flightStats.values()]
+    .map(row => ({ ...row }))
+    .sort((a, b) => b.abandoned - a.abandoned || b.flights - a.flights);
+  const fallbacks = [...fallbackStats.values()]
+    .map(bucket => ({ ...bucket.row }))
+    .sort((a, b) => b.flashes - a.flashes || b.shownMs - a.shownMs);
+  const sources = [...feedbackSources.values()]
+    .map(bucket => ({
+      ...bucket.row,
+      acknowledgedBy: rankedCounts(bucket.acks, "by"),
+      interactions: rankedCounts(bucket.interactions, "interaction"),
+      writes: [...bucket.writes]
+    }))
+    .sort((a, b) => b.silentMs - a.silentMs || b.heldMs - a.heldMs);
+  // Ranked by the total time the user spent on it: held plus synchronous work.
+  const interactions = [...feedbackInteractions.values()]
+    .map(bucket => ({ ...bucket.row }))
+    .sort((a, b) => b.heldMs + b.selfMs - (a.heldMs + a.selfMs));
+  return { sources, interactions, flights, fallbacks };
 }
 // The engine's implementation of the core's dev hook points. Installed by
 // enable(), uninstalled by disable() — while uninstalled the core pays one
@@ -847,7 +1854,7 @@ const engineHooks = {
         frame.prevDeps,
         { selfMs, totalMs },
         changed,
-        optimistic ? "optimistic" : transition ? "transition" : "plain",
+        optimistic ? "optimistic" : transition ? "held" : "plain",
         held
       );
     // Creation runs still get the wide-scope check: a memo can be born with
@@ -892,6 +1899,48 @@ const engineHooks = {
     if (change !== undefined && change.seq > asyncStartSeq && change.kind === "write")
       stampWrite(el, "async", NO_VALUES, value);
     finalizeFlight(el);
+  },
+  effectRunStart(el) {
+    pushFrame("effect", nodeName(el), el._devRunInteraction, el);
+  },
+  effectRunEnd() {
+    popFrame("effect");
+    if (activeHold !== null) activeHold.painted++;
+  },
+  actionStepStart(it, name) {
+    // Steps after a yield resume from a promise callback with no ambient
+    // interaction; the one that started the action (its first step) is the
+    // action's interaction for every step.
+    let interaction = actionInteractions.get(it);
+    if (interaction === undefined && !actionInteractions.has(it)) {
+      interaction = currentInteraction ?? undefined;
+      actionInteractions.set(it, interaction);
+    }
+    pushFrame("action", name, interaction);
+  },
+  actionStepEnd() {
+    popFrame("action");
+  },
+  holdStart(t) {
+    trackHoldStart(t);
+  },
+  holdEnd() {
+    activeHold = null;
+  },
+  transitionSettled(t) {
+    trackHoldSettled(t);
+  },
+  transitionMerged(target, outgoing) {
+    trackHoldMerge(target, outgoing);
+  },
+  storeReplaced(path, isArray, total, unchanged, prevTotal) {
+    checkImmutableUpdate(path, isArray, total, unchanged, prevTotal);
+  },
+  listChurn(el, removed, created, newLen, keyed) {
+    checkListIdentity(el, removed, created, newLen, keyed);
+  },
+  boundaryFallback(boundary, tree, shown) {
+    trackFallback(boundary, tree, shown);
   }
 };
 const attribution = {
@@ -901,6 +1950,16 @@ const attribution = {
     scopeCosts.clear();
     writeCosts.clear();
     waterfallLog = [];
+    holdLog = [];
+    activeHold = null;
+    feedbackSources.clear();
+    feedbackInteractions.clear();
+    reportedCycles.clear();
+    relays.clear();
+    immutableReported.clear();
+    flightStats.clear();
+    fallbackStats.clear();
+    originFrames.length = 0;
     hotCauses.clear();
     setAttributionHooks(engineHooks);
   },
@@ -911,6 +1970,16 @@ const attribution = {
     scopeCosts.clear();
     writeCosts.clear();
     waterfallLog = [];
+    holdLog = [];
+    activeHold = null;
+    feedbackSources.clear();
+    feedbackInteractions.clear();
+    reportedCycles.clear();
+    relays.clear();
+    immutableReported.clear();
+    flightStats.clear();
+    fallbackStats.clear();
+    originFrames.length = 0;
     hotCauses.clear();
     setAttributionHooks(null);
   },
@@ -940,13 +2009,21 @@ const attribution = {
   waterfalls() {
     return waterfallLog;
   },
+  holds() {
+    return holdLog;
+  },
+  feedback() {
+    return feedbackTables();
+  },
   markFlight(flight, startedAt = now()) {
     // Earliest wins: re-marking (a cache re-serving the same promise) must
     // not move the origin later.
     const existing = flightOrigins.get(flight);
     if (existing === undefined || startedAt < existing) flightOrigins.set(flight, startedAt);
   },
-  format: formatRerun
+  withInteraction,
+  format: formatRerun,
+  formatOrigin
 };
 
 /** First warning when a node's live edge count reaches this size. */
@@ -1000,22 +2077,88 @@ const DEV$1 = {
   getSources,
   getObservers
 };
-function emitDiagnostic(event) {
+/**
+ * Root-first names of the owners enclosing `subject` (inclusive when the
+ * subject is itself a named owner). Signals hop to their registering owner
+ * (`_owner`, set by registerGraph). Unnamed owners are skipped so the path
+ * reads as the component tree plus the scope: `<App> › <TodoRow> › effect`.
+ */
+function ownerPath(subject) {
+  if (!subject) return undefined;
+  let owner = "_parent" in subject ? subject : (subject._owner ?? null);
+  const path = [];
+  for (; owner !== null; owner = owner._parent) {
+    const name = owner._name;
+    if (typeof name === "string" && name.length) path.push(name);
+  }
+  return path.length ? path.reverse() : undefined;
+}
+/**
+ * Records a diagnostic on the structured channel (listeners, captures) and
+ * returns the entry. `subject` locates it: the current reactive `context` by
+ * default (right for the synchronous rule checks — they fire inside the
+ * scope that misbehaved); pass the node for scheduler-time findings whose
+ * ambient context is the flush, or `null` for events that have no location
+ * by nature. Console output is a separate step — see `reportDiagnostic`.
+ */
+function emitDiagnostic(event, subject = context) {
   const entry = {
     sequence: ++diagnosticSequence,
     ...event
   };
+  const path = ownerPath(subject);
+  if (path) entry.ownerPath = path;
+  if (subject) eventSubjects.set(entry, subject);
   for (const listener of diagnosticListeners) listener(entry);
   for (const capture of diagnosticCaptures) capture.push(entry);
-  if (consoleFooter && !footeredCodes.has(entry.code)) {
-    footeredCodes.add(entry.code);
-    const footer = consoleFooter(entry);
-    // Call sites console.warn/error their message after emitDiagnostic
-    // returns; a microtask lands the footer right below that report.
-    if (footer) queueMicrotask(() => console.warn(footer));
+  // Footer for events that never reach reportDiagnostic because the call site
+  // throws the message instead (every such site is severity "error"): a
+  // microtask lands it below the thrown error. Sites that DO report consume
+  // the once-per-code slot synchronously first, so this finds it taken and
+  // stays silent — one console entry per finding. Advisory (`info`) events
+  // are structured-channel only and get no footer: nothing on the console
+  // for it to follow.
+  if (entry.severity === "error" && consoleFooter && !footeredCodes.has(entry.code)) {
+    queueMicrotask(() => {
+      const footer = takeFooter(entry);
+      if (footer) console.warn(footer);
+    });
   }
   return entry;
 }
+/** The once-per-code footer text, consuming the slot. Undefined if taken or unregistered. */
+function takeFooter(entry) {
+  if (!consoleFooter || footeredCodes.has(entry.code)) return undefined;
+  footeredCodes.add(entry.code);
+  return consoleFooter(entry);
+}
+/**
+ * The subject each emitted event was about, for the console step: events are
+ * serializable records and cannot carry the node, but the console can show
+ * what the node knows — a rendering runtime may stamp a binding effect with
+ * the DOM element it writes (`_devElement`), and a live element reference
+ * beside the message is the most addressable pointer a console can print.
+ */
+const eventSubjects = new WeakMap();
+/**
+ * The console face of a diagnostic — ONE entry per finding: the message, the
+ * owner path (`in <App> › <TodoRow> › effect`) so a human can locate it, the
+ * once-per-code footer as trailing lines, and — when the subject is a
+ * binding effect the rendering runtime tagged — the element it writes, as a
+ * second console argument (hover highlights it, click jumps to Elements).
+ * Severity picks the console method. Call sites report the entry
+ * `emitDiagnostic` returned so the structured and console channels never
+ * disagree.
+ */
+function reportDiagnostic(entry) {
+  let text = entry.message;
+  if (entry.ownerPath) text += `\n  in ${entry.ownerPath.join(" › ")}`;
+  const footer = takeFooter(entry);
+  if (footer) text += `\n${footer}`;
+  const element = eventSubjects.get(entry)?._devElement;
+  const args = element !== undefined ? [text, element] : [text];
+  entry.severity === "error" ? console.error(...args) : console.warn(...args);
+}
 /**
  * Shared strict-read diagnostics for core read() and the store proxy traps.
  * Single source for the message text — the #2897 safeguard parity between
@@ -1039,15 +2182,16 @@ function warnStrictReadUntracked(strictReadLabel, fields) {
   const message =
     `[STRICT_READ_UNTRACKED] Reactive value read directly in ${strictReadLabel} will not update. ` +
     `Move it into a tracking scope (JSX, a memo, or an effect's compute function).`;
-  emitDiagnostic({
-    code: "STRICT_READ_UNTRACKED",
-    kind: "strict-read",
-    severity: "warn",
-    message,
-    data: { strictRead: strictReadLabel },
-    ...fields
-  });
-  console.warn(message);
+  reportDiagnostic(
+    emitDiagnostic({
+      code: "STRICT_READ_UNTRACKED",
+      kind: "strict-read",
+      severity: "warn",
+      message,
+      data: { strictRead: strictReadLabel },
+      ...fields
+    })
+  );
 }
 function registerGraph(value, owner) {
   value._owner = owner;
@@ -1114,17 +2258,21 @@ function noteGraphLink(dep, sub) {
       `Each will re-run when it changes. If many independent computations read the same value ` +
       `(for example every row of a list comparing against one selected id), prefer a per-key ` +
       `store or projection so only the items whose result flipped update.`;
-    emitDiagnostic({
-      code: "HUGE_FAN_OUT",
-      kind: "graph",
-      severity: "warn",
-      message,
-      nodeName: name,
-      ownerId: dep.id,
-      ownerName: name,
-      data: { count: fanOut }
-    });
-    console.warn(message);
+    reportDiagnostic(
+      emitDiagnostic(
+        {
+          code: "HUGE_FAN_OUT",
+          kind: "graph",
+          severity: "warn",
+          message,
+          nodeName: name,
+          ownerId: dep.id,
+          ownerName: name,
+          data: { count: fanOut }
+        },
+        dep
+      )
+    );
   }
   if (shouldWarnGraphSize(fanIn)) {
     const name = sub._name;
@@ -1132,17 +2280,21 @@ function noteGraphLink(dep, sub) {
       `[HUGE_FAN_IN] ${name ? `Computation "${name}"` : "A computation"} has ${fanIn} sources. ` +
       `It will re-run when any of them change. Narrow the read or split the derivation so each ` +
       `computation tracks only what it needs.`;
-    emitDiagnostic({
-      code: "HUGE_FAN_IN",
-      kind: "graph",
-      severity: "warn",
-      message,
-      nodeName: name,
-      ownerId: sub.id,
-      ownerName: name,
-      data: { count: fanIn }
-    });
-    console.warn(message);
+    reportDiagnostic(
+      emitDiagnostic(
+        {
+          code: "HUGE_FAN_IN",
+          kind: "graph",
+          severity: "warn",
+          message,
+          nodeName: name,
+          ownerId: sub.id,
+          ownerName: name,
+          data: { count: fanIn }
+        },
+        sub
+      )
+    );
   }
 }
 /** DEV-only: drop live edge counts when a link is removed. */
@@ -1250,6 +2402,22 @@ function findLane(lane) {
   while (lane._mergedInto) lane = lane._mergedInto;
   return lane;
 }
+/**
+ * Is the lane held? `_pendingAsync` records the async the lane OWNS (derived
+ * under it); the transaction's reporter map records the async a render effect
+ * OBSERVED pending with no boundary taking it (INV-3, the one registration
+ * site). A hold needs both — the same rule the transaction itself uses, so a
+ * memo nobody renders, or one a fallback-showing boundary caught, cannot tear
+ * a frame and holds nothing (#3289). An orphan lane has no observation record
+ * and never holds.
+ */
+function laneHeld(lane) {
+  const t = lane._transition;
+  if (t)
+    for (const node of lane._pendingAsync)
+      if (currentTransition(t)._asyncReporters.has(node)) return true;
+  return false;
+}
 /**
  * Merge two lanes when their dependency graphs overlap.
  */
@@ -1359,7 +2527,7 @@ function cancelZombieRecompute(el) {
 }
 let clock = 0;
 let activeTransition = null;
-let scheduled$1 = false;
+let scheduled = false;
 let halted = false;
 let haltNotified = false;
 let syncDepth = 0;
@@ -1367,6 +2535,10 @@ let projectionWriteActive = false;
 let inTrackedQueueCallback = false;
 let _enforceLoadingBoundary = false;
 let _hitUnhandledAsync = false;
+// Once per enforcement window: the ASYNC_OUTSIDE_LOADING_BOUNDARY finding is a
+// fact about the MOUNT ("the root mount will be deferred"), not about each
+// pending render effect — N async siblings at mount used to produce N copies.
+let _reportedUnhandledAsync = false;
 // Store property nodes that were created solely to carry a pending write (no
 // subscribers at write time). Swept after each flush that commits pending
 // values — any still without subs get disposed via their `_unobserved` hook,
@@ -1398,11 +2570,19 @@ function sweepTransientStoreNodes() {
     // unmarked node for the same property).
     if (node._x?._affectsCount) continue;
     transientStoreNodes.delete(node);
-    node._x?._unobserved?.();
+    if (node._config & CONFIG_SLOT_NODE) slotUnobservedHook(node);
+    else node._x?._unobserved?.();
   }
 }
+/**
+ * Consume the unhandled-async hit. Returns whether this is the first report
+ * of the current enforcement window — the caller warns only then.
+ */
 function resetUnhandledAsync() {
   _hitUnhandledAsync = false;
+  if (_reportedUnhandledAsync) return false;
+  _reportedUnhandledAsync = true;
+  return true;
 }
 /**
  * Toggles the dev-mode "must be inside a `<Loading>` boundary" enforcement
@@ -1414,6 +2594,7 @@ function resetUnhandledAsync() {
  */
 function enforceLoadingBoundary(enabled) {
   _enforceLoadingBoundary = enabled;
+  if (enabled) _reportedUnhandledAsync = false;
 }
 function setProjectionWriteActive(value) {
   projectionWriteActive = value;
@@ -1451,6 +2632,7 @@ function createBatch() {
   };
 }
 function mergeTransitionState(target, outgoing) {
+  if (attrHooks !== null) attrHooks.transitionMerged(target, outgoing);
   outgoing._done = target;
   target._actions.push(...outgoing._actions);
   for (const lane of activeLanes) if (lane._transition === outgoing) lane._transition = target;
@@ -1469,27 +2651,6 @@ function mergeTransitionState(target, outgoing) {
     outgoing._affectsNodes.length = 0;
   }
   for (const store of outgoing._optimisticStores) target._optimisticStores.add(store);
-  // Patch-channel stash (store/next/patch.ts): entries held for the outgoing
-  // transition must ride the merge like every other per-transition
-  // collection — releaseBatch only reads the COMMITTING transition's stash,
-  // so a stranded sidecar would silently drop its patches. Move (don't
-  // copy), same aliasing rule as the collections above. The field is an
-  // expando so this module stays free of patch imports (pay-for-use).
-  const heldPatches = outgoing._heldPatches;
-  if (heldPatches !== undefined) {
-    outgoing._heldPatches = undefined;
-    let dest = target._heldPatches;
-    if (dest !== undefined) dest.push(...heldPatches);
-    else dest = target._heldPatches = heldPatches;
-    // Retarget the entries' coalescing stamps to the surviving stash
-    // (opaque backref contract with store/next/patch.ts): without this a
-    // post-merge emission misses the stamp and pushes a SECOND entry —
-    // the record's patch applies twice at commit (re-audit 5, P1-2).
-    for (let i = 0; i < heldPatches.length; i++) {
-      const pc = heldPatches[i].pc;
-      if (pc !== undefined && pc.qe === heldPatches[i]) pc.qa = dest;
-    }
-  }
   for (const [source, reporters] of outgoing._asyncReporters) {
     let targetReporters = target._asyncReporters.get(source);
     if (!targetReporters) target._asyncReporters.set(source, (targetReporters = new Set()));
@@ -1603,8 +2764,8 @@ function schedule() {
     notifyHalted();
     return;
   }
-  if (scheduled$1) return;
-  scheduled$1 = true;
+  if (scheduled) return;
+  scheduled = true;
   if (!syncDepth && !globalQueue._running && !projectionWriteActive) queueMicrotask(flush);
 }
 /**
@@ -1709,6 +2870,9 @@ class Queue {
     schedule();
   }
   stashQueues(stub) {
+    // Attribution hook: the parking transition's lane effects have run; its
+    // queues are being stashed. Root call only (children recurse below).
+    if (attrHooks !== null && this === globalQueue) attrHooks.holdEnd();
     stub._queues[0].push(...this._queues[0]);
     stub._queues[1].push(...this._queues[1]);
     this._queues = [[], []];
@@ -1796,9 +2960,10 @@ class GlobalQueue extends Queue {
   static _laneReadsCommitted = null;
   static _recomputeLane = null;
   static _laneAsyncPending = null;
-  /** Authoritative-view reader wakeup (until()): installed at first until() call.
-   * Call sites are gated by CONFIG_AUTHORITATIVE_OBSERVED, which only until()'s
-   * carve-out read can set, so `!` invocations are safe once the gate holds. */
+  /** Authoritative-view reader wakeup: installed by until() and refresh() before
+   * their first read. Call sites are gated by CONFIG_AUTHORITATIVE_OBSERVED, which
+   * only such a reader's carve-out read can set, so `!` invocations are safe once
+   * the gate holds (#3303). */
   static _notifyAuthoritativeObservers = null;
   static _laneAsyncSettled = null;
   static _trackOptimisticStore = null;
@@ -1845,7 +3010,7 @@ class GlobalQueue extends Queue {
           // A kept ambient batch may hold pending nodes (#2916): stay
           // scheduled so the outer drain loop commits them via the plain
           // flush path instead of leaving them until the next natural flush.
-          scheduled$1 = dirtyQueue._max >= dirtyQueue._min || this._batch._pendingNodes.length > 0;
+          scheduled = dirtyQueue._max >= dirtyQueue._min || this._batch._pendingNodes.length > 0;
           reassignPendingTransition(stashedTransition._pendingNodes);
           activeTransition = null;
           finalizePureQueue(null, true);
@@ -1885,7 +3050,7 @@ class GlobalQueue extends Queue {
       }
       clock++;
       // Check if finalization added items to the heap (from optimistic reversion)
-      scheduled$1 = dirtyQueue._max >= dirtyQueue._min;
+      scheduled = dirtyQueue._max >= dirtyQueue._min;
       // Run lane effects first (for ready lanes), then regular effects
       activeLanes.size && GlobalQueue._runLaneEffects(EFFECT_RENDER);
       this.run(EFFECT_RENDER);
@@ -1902,7 +3067,7 @@ class GlobalQueue extends Queue {
       }
       if (
         true &&
-        !scheduled$1 &&
+        !scheduled &&
         !activeTransition &&
         transitions.size === 0 &&
         activeLanes.size === 0
@@ -1919,21 +3084,32 @@ class GlobalQueue extends Queue {
     // Only track async if the boundary is propagating STATUS_PENDING (not caught by boundary)
     if (mask & STATUS_PENDING) {
       if (flags & STATUS_PENDING) {
-        const actualError = error !== undefined ? error : node._x?._error;
+        // Callers pass either nothing or this node's own `_x._error`, so `??`
+        // is exact (a null error falls back to the same null).
+        const actualError = error ?? node._x?._error;
         // A visibility-only mark notification (the affects() boundary
         // channel) updates display state on its way up but must be invisible
         // to completion accounting BY CONSTRUCTION: it never registers a
         // reporter and never counts toward the loading-boundary diagnostic.
         if (actualError?._markVisual) return true;
-        if (activeTransition && actualError) {
-          const source = actualError.source;
-          let reporters = activeTransition._asyncReporters.get(source);
-          if (!reporters) activeTransition._asyncReporters.set(source, (reporters = new Set()));
-          const prevSize = reporters.size;
-          reporters.add(node);
-          if (reporters.size !== prevSize) {
-            schedule();
-            GlobalQueue._wakeSuppressedProbes?.(activeTransition);
+        if (actualError) {
+          // A reveal can discover a flight started in an earlier flush. Hold
+          // the staged writes with that reader (A15), even if the reader is
+          // new. Fresh/reset loading boundaries consume pending before it
+          // reaches here. A reader already parked in a transition must not
+          // open a second one.
+          if (!activeTransition && !node._transition && currentBatch._pendingNodes.length)
+            this.initTransition();
+          if (activeTransition) {
+            const source = actualError.source;
+            let reporters = activeTransition._asyncReporters.get(source);
+            if (!reporters) activeTransition._asyncReporters.set(source, (reporters = new Set()));
+            const prevSize = reporters.size;
+            reporters.add(node);
+            if (reporters.size !== prevSize) {
+              schedule();
+              GlobalQueue._wakeSuppressedProbes?.(activeTransition);
+            }
           }
         }
         if (_enforceLoadingBoundary) _hitUnhandledAsync = true;
@@ -1960,6 +3136,11 @@ class GlobalQueue extends Queue {
     } else if (transition) {
       const outgoing = activeTransition;
       mergeTransitionState(transition, outgoing);
+      // Effects the outgoing transaction parked belong to the surviving one
+      // now: back onto the live queue, where this flush parks them under
+      // `transition` or runs them at its completion. The outgoing stash is
+      // never read again — the transaction is dead (#3310).
+      this.restoreQueues(outgoing._queueStash);
       transitions.delete(outgoing);
       activeTransition = transition;
     }
@@ -2117,16 +3298,6 @@ let storeCommitHook = null;
 function setStoreCommitHook(fn) {
   storeCommitHook = fn;
 }
-/** Patch-channel release hook (next/patch.ts): transition-stamped patch
- * emissions are released when THEIR batch commits. Transitions never
- * abort: failed actions still commit (only optimistic overrides revert),
- * and merged-away transitions hand their stash to the survivor
- * (mergeTransitionState) — every stash drains exactly once. Injected like
- * storeCommitHook to stay tree-shakeable. */
-let patchCommitHook = null;
-function setPatchCommitHook(fn) {
-  patchCommitHook = fn;
-}
 /** Held truth committed this finalize, awaiting its post-revert wake (see
  * finalizePureQueue): the commit IS the reveal, but subscribers must not
  * re-derive until the settling transaction's optimistic overrides have
@@ -2158,7 +3329,6 @@ function commitPendingNodes() {
   }
   pendingNodes.length = 0;
   storeCommitHook?.();
-  patchCommitHook?.(currentBatch);
 }
 function finalizePureQueue(completingTransition = null, incomplete = false) {
   // For incomplete transitions, skip pending resolution and optimistic reversion
@@ -2287,13 +3457,14 @@ function flush(fn) {
       const message =
         "[FLUSH_IN_EFFECT_CALLBACK] flush() called from inside an effect callback is a no-op: the flush that runs effects is already in progress. " +
         "Writes made here are processed in the same flush's continuation; to force a drain afterwards, defer it: queueMicrotask(() => flush()).";
-      emitDiagnostic({
-        code: "FLUSH_IN_EFFECT_CALLBACK",
-        kind: "lifecycle",
-        severity: "warn",
-        message
-      });
-      console.warn(message);
+      reportDiagnostic(
+        emitDiagnostic({
+          code: "FLUSH_IN_EFFECT_CALLBACK",
+          kind: "lifecycle",
+          severity: "warn",
+          message
+        })
+      );
     }
     return;
   }
@@ -2301,7 +3472,7 @@ function flush(fn) {
   let count = 0;
   // `flush()` is an explicit drain point, so it must also process an active
   // transition even if no microtask was scheduled for it yet.
-  while (scheduled$1 || activeTransition) {
+  while (scheduled || activeTransition) {
     if (++count === 1e5) {
       // Attribution beats a bare guard (#3140): say what kept the loop alive.
       // A completed transition being re-activated reads `done=true` here —
@@ -2309,7 +3480,7 @@ function flush(fn) {
       // (#2843) usually show staged work naming the culprit node.
       const t = activeTransition;
       throw new Error(
-        `Potential Infinite Loop Detected. Kept alive by ${scheduled$1 ? "scheduled work" : "an active transition"}${
+        `Potential Infinite Loop Detected. Kept alive by ${scheduled ? "scheduled work" : "an active transition"}${
           t
             ? `; transition: done=${t._done === true}, pending=${t._pendingNodes.length}, optimistic=${t._optimisticNodes.length}, asyncReporters=${t._asyncReporters.size}`
             : ""
@@ -2340,7 +3511,11 @@ function reporterBlocksSource(reporter, source) {
 }
 function transitionComplete(transition) {
   if (transition._done) return true;
-  if (transition._actions.length) return false;
+  if (transition._actions.length) {
+    // A live action parks the transaction regardless of async state.
+    if (attrHooks !== null) attrHooks.holdStart(transition);
+    return false;
+  }
   let done = true;
   for (const [source, reporters] of transition._asyncReporters) {
     let hasLive = false;
@@ -2361,6 +3536,13 @@ function transitionComplete(transition) {
   // blockage"); the hook's loops over _optimisticNodes/_optimisticStores are
   // no-ops when the transition holds neither, so no pre-check is needed.
   if (done && GlobalQueue._transitionBlocked?.(transition)) done = false;
+  // Attribution hook: this verdict is the fork between settling (held writes
+  // commit next — `_pendingNodes` still lists them) and parking (the flush
+  // runs the lane effects, then stashes; `holdEnd` fires from stashQueues).
+  // Fired here rather than at flush()'s call site because that site is inside
+  // a `try` (see the rule in attribution-hooks.ts).
+  if (attrHooks !== null)
+    done ? attrHooks.transitionSettled(transition) : attrHooks.holdStart(transition);
   done && (transition._done = true);
   return done;
 }
@@ -2413,19 +3595,13 @@ function queueFor(n) {
   return n._flags & REACTIVE_ZOMBIE ? zombieQueue : dirtyQueue;
 }
 /**
- * Schedule one subscriber to re-run on the next flush: tracked effects bypass
- * the heap and go directly to their effect queue; everything else is inserted
- * into its own (zombie-flag-routed) heap with the `_min` cursor pulled down.
+ * Schedule one subscriber to re-run on the next flush: inserted into its own
+ * (zombie-flag-routed) heap with the `_min` cursor pulled down. Tracked
+ * effects ride the heap too — the heap visit is their (empty) compute phase,
+ * which hands the callback to the user queue once the pass has committed
+ * (see GlobalQueue._update, #3291).
  */
 function enqueueSub(node) {
-  if (node._type === EFFECT_TRACKED) {
-    const tracked = node;
-    if (!tracked._modified) {
-      tracked._modified = true;
-      tracked._queue.enqueue(EFFECT_USER, tracked._run);
-    }
-    return;
-  }
   const queue = queueFor(node);
   if (queue._min > node._height) queue._min = node._height;
   insertIntoHeap(node, queue);
@@ -2876,7 +4052,10 @@ function unlinkSubs(link) {
   else {
     dep._subs = nextSub;
     if (nextSub === null) {
-      dep._x?._unobserved?.();
+      // Slot nodes (store leaves) dispatch to the ONE shared hook — no
+      // per-node unobserved closure, no NodeExtension to hold it.
+      if (dep._config & CONFIG_SLOT_NODE) slotUnobservedHook(dep);
+      else dep._x?._unobserved?.();
       // No more subscribers; only tear down if CONFIG_AUTO_DISPOSE is set.
       // A pending node is exempt: its in-flight async work (or the
       // transition holding it) is an observer — tearing down would orphan
@@ -3397,7 +4576,12 @@ function handleAsync(el, result, setter) {
     // change (and only then classify it as an async landing).
     if (attrHooks !== null) attrHooks.asyncStart(el);
     if (setter) {
-      setter(value);
+      try {
+        setter(value);
+      } catch (error) {
+        handleError(error);
+        return;
+      }
       if (wasUninitialized) clearStatus(el, true);
     } else if (el._x?._overrideValue !== undefined) {
       // Optimistic node — resting OR covered by an active override — holds
@@ -3818,7 +5002,21 @@ function notifyStatus(el, status, error, blockStatus, lane) {
   });
 }
 
-GlobalQueue._update = recompute;
+// The heap's per-node step. A tracked effect's heap visit is its compute
+// phase — empty, like a user effect whose compute reads nothing — and hands
+// the callback to the user queue. Routing the wake through the heap, rather
+// than straight into the queue at notify time, is what orders the run after
+// the commit regardless of which phase the write came from: a write in a
+// render-effect callback stages its value for the next pass, but a wake pushed
+// directly into the user queue ran in the SAME pass, read the old value, and
+// nothing re-notified it when the value landed (#3291).
+GlobalQueue._update = el => {
+  if (el._type === EFFECT_TRACKED) {
+    deleteFromHeap(el, queueFor(el));
+    el._modified = true;
+    el._queue.enqueue(EFFECT_USER, el._run);
+  } else recompute(el);
+};
 GlobalQueue._dispose = disposeChildren;
 const PRIMITIVE_IN_FORBIDDEN_SCOPE_MESSAGE =
   "[PRIMITIVE_IN_FORBIDDEN_SCOPE] Cannot create reactive primitives inside createTrackedEffect or owner-backed onSettled";
@@ -4183,11 +5381,11 @@ function recompute(el, create = false) {
       if (el._pendingValue === NOT_PENDING) queuePendingNode(el);
       el._pendingValue = value;
       if (wasLoading) el._loading = true; // see the held branch above (#2990)
-      // A authoritative-view reader (until()) observed this node past its
-      // override — and "authoritative arrival equal to the override" is
-      // exactly the acknowledgment it waits for. Wake those readers only;
-      // A17 silence holds for every ordinary subscriber. (Hook installed by
-      // until(), the only setter of the gating bit.)
+      // An authoritative-view reader (until()'s predicate, refresh()'s waiter)
+      // observed this node past its override — and "authoritative arrival
+      // equal to the override" is exactly the acknowledgment it waits for.
+      // Wake those readers only; A17 silence holds for every ordinary
+      // subscriber. (Hook installed by both setters of the gating bit, #3303.)
       if (el._config & CONFIG_AUTHORITATIVE_OBSERVED) GlobalQueue._notifyAuthoritativeObservers(el);
     } else if (el._height != oldHeight) {
       for (let s = el._subs; s !== null; s = s._nextSub) {
@@ -4517,6 +5715,61 @@ function signal(v, options, firewall = null) {
   }
   return s;
 }
+// ---------------------------------------------------------------------------
+// SLOT SIGNALS (store leaves) — the create-floor diet. Store mounts
+// materialize one signal per touched leaf (~13 × rows on dbmon), so per-node
+// allocations are mount bytes: the generic path costs an options object, an
+// equals closure, an unobserved closure, a NodeExtension to hold it, and
+// three post-construction expandos (acc/px/pxv → hidden-class transitions).
+// slotSignal bakes everything into ONE literal: `_host`/`_key` backrefs
+// replace the closures (equals is a method call — `this` is the node; the
+// unobserved sweep dispatches CONFIG_SLOT_NODE to one shared hook), and the
+// store's wrap-cache fields are pre-shaped.
+/** The shared slot-node unobserved handler — a live binding read directly by
+ * the sweep sites (no wrapper frame, no null check: a CONFIG_SLOT_NODE node
+ * existing implies the store module loaded and registered the hook). */
+let slotUnobservedHook;
+/** Install the shared slot-node unobserved handler (store module, once). */
+function setSlotUnobserved(fn) {
+  slotUnobservedHook = fn;
+}
+function slotSignal(v, equals, host, key, acc, firewall = null) {
+  const s = {
+    _equals: equals,
+    _config: CONFIG_OWNED_WRITE | CONFIG_SLOT_NODE,
+    _value: v,
+    _subs: null,
+    _subsTail: null,
+    _time: clock,
+    _firewall: firewall,
+    _nextChild: firewall?._x?._child || null,
+    _pendingValue: NOT_PENDING,
+    _transition: null,
+    _notifiedAt: -1,
+    _x: null,
+    // Slot backrefs: what the equals/unobserved closures used to capture.
+    _host: host,
+    _key: key,
+    // Store read-path caches, pre-shaped (were post-construction expandos).
+    acc,
+    px: undefined,
+    pxv: undefined
+  };
+  {
+    s._name = "signal";
+    s._internal = !!firewall;
+  }
+  if (firewall) {
+    ext(firewall)._child = s;
+    firewall._config |= CONFIG_FW_CHILDREN;
+  }
+  if (snapshotCaptureActive && !((firewall?._statusFlags ?? 0) & STATUS_PENDING)) {
+    ext(s)._snapshotValue = v === undefined ? NO_SNAPSHOT : v;
+    s._config |= CONFIG_HAS_SNAPSHOT;
+    snapshotSources.add(s);
+  }
+  return s;
+}
 function optimisticSignal(v, options) {
   const s = signal(v, options);
   ext(s)._overrideValue = NOT_PENDING;
@@ -4636,9 +5889,11 @@ function notifyAuthoritativeObservers(el) {
   }
   schedule();
 }
-/** Installs the until() machinery hook. Idempotent; called by until() before
- * any authoritative-view read happens (same late-binding contract as the
- * optimistic engine). */
+/** Installs the authoritative-reader wakeup hook. Idempotent; called by every
+ * creator of a CONFIG_AUTHORITATIVE_READ computation — until() and refresh() —
+ * before its first read (same late-binding contract as the optimistic engine;
+ * the gating bit is only ever set by such a read, so the `!` call sites are
+ * safe once every setter installs, #3303). */
 function installAuthoritativeRead() {
   if (GlobalQueue._notifyAuthoritativeObservers === null)
     GlobalQueue._notifyAuthoritativeObservers = notifyAuthoritativeObservers;
@@ -4742,20 +5997,26 @@ function read(el) {
         const message =
           "[PENDING_ASYNC_FORBIDDEN_SCOPE] Reading a pending async value inside createTrackedEffect or onSettled will throw. " +
           "Use createEffect instead which supports async-aware reactivity.";
-        emitDiagnostic({
-          code: "PENDING_ASYNC_FORBIDDEN_SCOPE",
-          kind: "async",
-          severity: "warn",
-          message,
-          ownerId: c.id,
-          ownerName: c._name,
-          nodeName: owner?._name
-        });
-        console.warn(message);
+        reportDiagnostic(
+          emitDiagnostic(
+            {
+              code: "PENDING_ASYNC_FORBIDDEN_SCOPE",
+              kind: "async",
+              severity: "warn",
+              message,
+              ownerId: c.id,
+              ownerName: c._name,
+              nodeName: owner?._name
+            },
+            c
+          )
+        );
       }
       // Per-lane suspension lives with the engine (a non-null lane implies it
       // is installed): under a lane, only same-lane pending async without an
-      // active override throws.
+      // active override throws — plus uninitialized sources regardless of
+      // lane (#3276); that check rides laneSuspends so floor bundles don't
+      // pay for it.
       if (currentOptimisticLane === null || GlobalQueue._laneSuspends(owner)) {
         if (!tracking && el !== c) link(el, c);
         throw owner._x?._error;
@@ -5025,15 +6286,19 @@ function runWithOwner(owner, fn) {
   if (owner && owner._flags & REACTIVE_DISPOSED) {
     const message =
       "[RUN_WITH_DISPOSED_OWNER] runWithOwner called with a disposed owner. Children created inside will never be disposed.";
-    emitDiagnostic({
-      code: "RUN_WITH_DISPOSED_OWNER",
-      kind: "owner",
-      severity: "warn",
-      message,
-      ownerId: owner.id,
-      ownerName: owner._name
-    });
-    console.warn(message);
+    reportDiagnostic(
+      emitDiagnostic(
+        {
+          code: "RUN_WITH_DISPOSED_OWNER",
+          kind: "owner",
+          severity: "warn",
+          message,
+          ownerId: owner.id,
+          ownerName: owner._name
+        },
+        owner
+      )
+    );
   }
   const oldContext = context;
   const prevTracking = tracking;
@@ -5090,8 +6355,14 @@ function markRefresh(node) {
       // for the rest of the transaction (#3026).
       if (node._manualWriteTime === clock) return;
       node._flags &= ~REACTIVE_MANUAL_WRITE;
-      // No REASK below: the batch carries a manual value change, so the
-      // recompute is not a quiet re-ask of an unchanged question.
+      // The lift falls through to the re-ask classification below. The held
+      // write's value change already rides the transaction; the refetch it
+      // asks for is the same question with unchanged inputs. Skipping the
+      // mark here classified that refetch as a NEW question, which pends
+      // every leaf (3.1) — an action doing setStore + yield + refresh(store)
+      // lit up every sibling row, and affects() could not narrow it (a mark
+      // only turns pending on). Same-question motion stays silent (3.4);
+      // the written slot and any declared mark carry the pending instead.
     }
     // A refresh with no value-change dirt already queued is a re-ask of the
     // same question: mark it so the recompute classifies any resulting
@@ -5100,7 +6371,7 @@ function markRefresh(node) {
     // REACTIVE_IN_HEAP counts as dirt: insertSubs schedules subscribers by
     // heap insertion alone (no DIRTY/CHECK flag), so a same-batch value
     // change followed by refresh() must not be laundered into a quiet re-ask.
-    else if (!(node._flags & (REACTIVE_DIRTY | REACTIVE_CHECK | REACTIVE_IN_HEAP))) {
+    if (!(node._flags & (REACTIVE_DIRTY | REACTIVE_CHECK | REACTIVE_IN_HEAP))) {
       node._flags |= REACTIVE_REASK;
       armReaskClear();
     }
@@ -5219,8 +6490,10 @@ function getContext(context, owner = getOwner()) {
   if (!owner) {
     throw new NoOwnerError();
   }
-  const value = hasContext(context, owner) ? owner._context[context.id] : context.defaultValue;
-  if (isUndefined(value)) {
+  // `undefined` alone means unset — a provided `null` is a value (no `??`).
+  let value = owner._context[context.id];
+  if (value === undefined) value = context.defaultValue;
+  if (value === undefined) {
     throw new ContextNotFoundError();
   }
   return value;
@@ -5242,15 +6515,9 @@ function setContext(context, value, owner = getOwner()) {
   // we don't do this, everything will be a singleton and all hell will break lose.
   owner._context = {
     ...owner._context,
-    [context.id]: isUndefined(value) ? context.defaultValue : value
+    [context.id]: value === undefined ? context.defaultValue : value
   };
 }
-function hasContext(context, owner) {
-  return !isUndefined(owner?._context[context.id]);
-}
-function isUndefined(value) {
-  return typeof value === "undefined";
-}
 
 /**
  * The optimistic write engine, moved out of core.ts/scheduler.ts. Everything
@@ -5370,11 +6637,12 @@ function runQueue(queue, type) {
   for (let i = 0; i < queue.length; i++) queue[i](type);
 }
 /**
- * Run effects from all lanes that are ready (no pending async).
+ * Run effects from all lanes that are ready (no OBSERVED pending async — see
+ * laneHeld).
  */
 function runLaneEffects(type) {
   for (const lane of activeLanes) {
-    if (lane._mergedInto || lane._pendingAsync.size > 0) continue;
+    if (lane._mergedInto || laneHeld(lane)) continue;
     const effects = lane._effectQueues[type - 1];
     if (effects.length) {
       lane._effectQueues[type - 1] = [];
@@ -5406,6 +6674,14 @@ function cleanupCompletedLanes(completingTransition) {
 }
 /** read()'s per-lane suspension test (pending-throw path, lane context). */
 function laneSuspends(owner) {
+  // An UNINITIALIZED async source suspends regardless of lane (#3276): a
+  // lane mismatch preserves an already-committed stale value, but a source
+  // with no committed truth has nothing to serve — the cross-lane read
+  // surfaced a fabricated `undefined` where latest() itself suspends
+  // (latestRead rethrows NotReady for tracked uninitialized reads). Lives
+  // here rather than read()'s throw path so the floor bundles don't pay:
+  // this is only reachable under a lane, which implies the engine.
+  if (owner._statusFlags & STATUS_UNINITIALIZED) return true;
   // Per-lane suspension: only throw if in same lane as pending async
   // AND the node doesn't have an active override (overrides are the visible value,
   // downstream in the lane should read the override, not throw)
@@ -5513,14 +6789,16 @@ function recomputeLane(el, own) {
   }
   return null;
 }
-/** recompute()'s catch path: track pending async in the current lane. */
+/** recompute()'s catch path: record the pending async as the current lane's
+ * (ownership — laneHeld decides the hold). The lane source's isPending
+ * companion is NOT refreshed here: its verdict never read _pendingAsync, and
+ * the source's own write/commit/settlement paths keep it current. */
 function laneAsyncPending(el) {
   const lane = findLane(currentOptimisticLane);
   if (lane._source !== el) {
     lane._pendingAsync.add(el);
     ext(el)._optimisticLane = lane;
     el._config |= CONFIG_HAS_LANE;
-    GlobalQueue._updatePendingSignal !== null && GlobalQueue._updatePendingSignal(lane._source);
   }
 }
 /** recompute()'s success path: the node's async settled, clear it from its lane. */
@@ -5528,8 +6806,6 @@ function laneAsyncSettled(el) {
   const resolvedLane = resolveLane(el);
   if (resolvedLane) {
     resolvedLane._pendingAsync.delete(el);
-    GlobalQueue._updatePendingSignal !== null &&
-      GlobalQueue._updatePendingSignal(resolvedLane._source);
   }
 }
 function trackOptimisticStore(store) {
@@ -5658,10 +6934,6 @@ function markWalk(el, seen) {
   }
   return false;
 }
-/** Gated entry: apps with no live mark pay one integer compare. */
-function markCovered(el) {
-  return activeAffectsMarks !== 0 && markWalk(el, new Set());
-}
 function quietPending(el) {
   if (el._x?._pendingSources) {
     for (const source of el._x._pendingSources) if (!source._x?._reask) return false;
@@ -5689,7 +6961,8 @@ function computePendingState(el) {
   // Mark coverage is transitive by dep-graph reachability: a latest() shadow
   // reaches its owner (and a store leaf its firewall) through its own deps,
   // so the one walk covers direct marks, derivation, and companion chains.
-  if (markCovered(el)) return true;
+  // Gated: apps with no live mark pay one integer compare.
+  if (activeAffectsMarks !== 0 && markWalk(el, new Set())) return true;
   const firewall = el._firewall;
   if (el._x?._parentSource) {
     const parentNode = el._x?._parentSource;
@@ -5907,7 +7180,7 @@ function latestRead(el) {
   if (stale && currentOptimisticLane && pendingComputed._x?._optimisticLane) {
     const pcLane = findLane(pendingComputed._x?._optimisticLane);
     const curLane = findLane(currentOptimisticLane);
-    if (pcLane !== curLane && pcLane._pendingAsync.size > 0) {
+    if (pcLane !== curLane && laneHeld(pcLane)) {
       return visibleValue;
     }
   }
@@ -6131,16 +7404,20 @@ function effect(compute, effect, error, options) {
   if (!node._parent) {
     const message =
       "[NO_OWNER_EFFECT] Effects created outside a reactive context will never be disposed";
-    emitDiagnostic({
-      code: "NO_OWNER_EFFECT",
-      kind: "lifecycle",
-      severity: "warn",
-      message,
-      ownerId: node.id,
-      ownerName: node._name,
-      data: { effectType: "effect" }
-    });
-    console.warn(message);
+    reportDiagnostic(
+      emitDiagnostic(
+        {
+          code: "NO_OWNER_EFFECT",
+          kind: "lifecycle",
+          severity: "warn",
+          message,
+          ownerId: node.id,
+          ownerName: node._name,
+          data: { effectType: "effect" }
+        },
+        node
+      )
+    );
   }
 }
 function notifyEffectStatus(status, error) {
@@ -6171,24 +7448,29 @@ function notifyEffectStatus(status, error) {
     }
   } else if (this._type === EFFECT_RENDER) {
     this._queue.notify(this, STATUS_PENDING | STATUS_ERROR, actualStatus, actualError);
-    if (_hitUnhandledAsync) {
+    if (_hitUnhandledAsync && resetUnhandledAsync()) {
       // Async without a `Loading` ancestor is legal (the mount defers), so this
       // is a consistent FYI — an `Errored` above must not swallow it. The old
       // STATUS_ERROR re-notify here dated from when enforcement routed the
       // pending to the error boundary; that both suppressed the warning and
-      // showed the error fallback in dev only (#2822).
-      resetUnhandledAsync();
+      // showed the error fallback in dev only (#2822). Reported once per
+      // mount (resetUnhandledAsync gates), located at the first pending
+      // effect's owner path.
       const message =
         "[ASYNC_OUTSIDE_LOADING_BOUNDARY] An async value was read outside a Loading boundary. The root mount will be deferred until all pending async settles.";
-      emitDiagnostic({
-        code: "ASYNC_OUTSIDE_LOADING_BOUNDARY",
-        kind: "async",
-        severity: "warn",
-        message,
-        ownerId: this.id,
-        ownerName: this._name
-      });
-      console.warn(message);
+      reportDiagnostic(
+        emitDiagnostic(
+          {
+            code: "ASYNC_OUTSIDE_LOADING_BOUNDARY",
+            kind: "async",
+            severity: "warn",
+            message,
+            ownerId: this.id,
+            ownerName: this._name
+          },
+          this
+        )
+      );
     }
   }
 }
@@ -6228,6 +7510,7 @@ function runEffect(node) {
   {
     prevStrictRead = setStrictRead("an effect callback");
     setEffectCallback(true);
+    if (attrHooks !== null) attrHooks.effectRunStart(node);
   }
   const prevCleanup = node._cleanup;
   node._cleanup = undefined;
@@ -6256,6 +7539,9 @@ function runEffect(node) {
     node._prevValue = node._value;
     node._modified = false;
   }
+  // Outside the try (see the rule in attribution-hooks.ts). Reached whether or
+  // not the callback threw — a throw that escapes the catch above halts.
+  if (attrHooks !== null) attrHooks.effectRunEnd(node);
 }
 GlobalQueue._runEffect = runEffect;
 /**
@@ -6265,6 +7551,9 @@ GlobalQueue._runEffect = runEffect;
  */
 function trackedEffect(fn, options) {
   const run = () => {
+    // `_modified` is NOT redundant with the heap: the heap dedups within a
+    // pass, but a held transition's passes each enqueue `_run` into the same
+    // user queue, and this gate is what collapses them into one run at commit.
     if (!node._modified || node._flags & REACTIVE_DISPOSED) return;
     setTrackedQueueCallback(true);
     try {
@@ -6297,20 +7586,28 @@ function trackedEffect(fn, options) {
   // _type): its error arm is behavior-identical to the closure that used to
   // live here, without the per-node NodeExtension allocation.
   node._run = run;
-  node._queue.enqueue(EFFECT_USER, run);
+  // The first run rides the heap like every wake (GlobalQueue._update), so a
+  // tracked effect created inside a render-effect callback runs after that
+  // pass's staged writes commit, not before.
+  enqueueSub(node);
+  schedule();
   if (!node._parent) {
     const message =
       "[NO_OWNER_EFFECT] Effects created outside a reactive context will never be disposed";
-    emitDiagnostic({
-      code: "NO_OWNER_EFFECT",
-      kind: "lifecycle",
-      severity: "warn",
-      message,
-      ownerId: node.id,
-      ownerName: node._name,
-      data: { effectType: "trackedEffect" }
-    });
-    console.warn(message);
+    reportDiagnostic(
+      emitDiagnostic(
+        {
+          code: "NO_OWNER_EFFECT",
+          kind: "lifecycle",
+          severity: "warn",
+          message,
+          ownerId: node.id,
+          ownerName: node._name,
+          data: { effectType: "trackedEffect" }
+        },
+        node
+      )
+    );
   }
 }
 // Install the shared effect status notifier (statusNotifierOf serves it to
@@ -6434,11 +7731,17 @@ function action(genFn) {
       };
       const step = (v, err) => {
         let r;
+        // Attribution hooks bracket the synchronous slice of generator body
+        // this step runs (up to the next yield): writes inside are the
+        // action's. Both sites sit outside the try (attribution-hooks.ts).
+        if (attrHooks !== null) attrHooks.actionStepStart(it, genFn.name || undefined);
         try {
           r = err ? it.throw(v) : it.next(v);
         } catch (e) {
+          if (attrHooks !== null) attrHooks.actionStepEnd(it);
           return done(undefined, e, true);
         }
+        if (attrHooks !== null) attrHooks.actionStepEnd(it);
         // A rejected iterator result (async generators) means the error already
         // escaped the generator body — it is completed, and throwing back in
         // would just reject again forever. Settle instead.
@@ -6526,13 +7829,14 @@ function onCleanup(fn) {
     if (!owner) {
       const message =
         "[NO_OWNER_CLEANUP] onCleanup called outside a reactive context will never be run";
-      emitDiagnostic({
-        code: "NO_OWNER_CLEANUP",
-        kind: "lifecycle",
-        severity: "warn",
-        message
-      });
-      console.warn(message);
+      reportDiagnostic(
+        emitDiagnostic({
+          code: "NO_OWNER_CLEANUP",
+          kind: "lifecycle",
+          severity: "warn",
+          message
+        })
+      );
     } else if (owner._config & CONFIG_CHILDREN_FORBIDDEN) {
       const message =
         "[CLEANUP_IN_FORBIDDEN_SCOPE] Cannot use onCleanup inside createTrackedEffect or onSettled; return a cleanup function instead";
@@ -6691,6 +7995,16 @@ function createRenderEffect(compute, effectFn, options) {
  * Creates a tracked reactive effect where dependency tracking and side effects happen
  * in the same scope.
  *
+ * @deprecated Do not use in new code. For a side effect that follows reactive
+ * state, use `createEffect(compute, effect)` — it separates tracking from the
+ * side effect, knows its dependencies before it runs, and participates in
+ * async and transitions. For one-time DOM work after render (measuring,
+ * attaching third-party widgets to a ref), use `onSettled`. Tracking from
+ * inside the effect phase — the only thing this primitive adds — is retained
+ * solely to ease 1.x migration: it runs beside user-effect callbacks after
+ * values commit, never holds a transition, and cannot observe a write staged
+ * earlier in the same flush by a signal it has not read yet.
+ *
  * WARNING: Because tracking and effects happen in the same scope, this primitive
  * may run multiple times for a single change or show tearing (reading inconsistent
  * state). Use only when dynamic subscription patterns require same-scope tracking.
@@ -6936,6 +8250,13 @@ function refresh(target) {
   // own eager compute is untouched: created after a refresh it still settles
   // stale-while-revalidate (#2930) — its contract is "first settled value",
   // not "next quiescent state".
+  //
+  // An authoritative reader is woken through a late-bound hook when the truth
+  // lands EQUAL to a standing override (the A17-silent path). Every setter of
+  // that reader bit must install it — until() does, and this waiter is the
+  // other one (#3303: refresh of an optimistic in an app that never called
+  // until() dereferenced the null hook).
+  installAuthoritativeRead();
   markRefresh(node);
   const promise = new Promise((res, rej) => {
     queueMicrotask(() => {
@@ -7217,7 +8538,7 @@ function createOptimistic(first, second) {
 function onSettled(callback) {
   const owner = getOwner();
   owner && !(owner._config & CONFIG_CHILDREN_FORBIDDEN)
-    ? createTrackedEffect(() => untrack(callback), { name: "onSettled" })
+    ? trackedEffect(() => untrack(callback), { name: "onSettled" })
     : globalQueue.enqueue(EFFECT_USER, () => {
         // Unowned, out-of-band fire (no owner, or a children-forbidden one this
         // one-shot must not bind to): a returned cleanup has no lifecycle to
@@ -7720,15 +9041,6 @@ function affects(target, key) {
   }
 }
 
-let patchHooks = null;
-let rowHooks = null;
-function installPatchHooks(hooks) {
-  patchHooks = hooks;
-}
-function installRowHooks(hooks) {
-  rowHooks = hooks;
-}
-
 /**
  * Store rewrite — increment 2: plain deep stores with pending-backing writes.
  * Contract: INTERNALS-STORE-STATE.md.
@@ -7761,9 +9073,9 @@ function installRowHooks(hooks) {
  *
  * ARRAY SHAPE RULE: arrays normalize their named properties to dictionary
  * mode as the count grows (V8 13.x: counts ≡ 0 mod 3 from 18 up), so the
- * target's named field count is capped at 20 — write-side patch-channel
- * state lives inside the single `pc` extension (see target.ts), never as
- * new named fields here. */
+ * target's named field count is capped at 20 — any future write-side state
+ * beyond `wk` must ride an extension object (see target.ts), never new
+ * named fields here. */
 function TargetShape() {
   this.v = undefined;
   this.ch = undefined;
@@ -7779,20 +9091,16 @@ function TargetShape() {
   this.a = undefined;
   this.sc = undefined;
   this.nc = undefined;
-  this.adopted = undefined;
+  this.ab = undefined;
   this.fam = undefined;
   this.s = undefined;
   this.ovl = undefined;
   this.del = undefined;
-  this.pc = undefined;
+  this.wk = undefined;
   this.hv = undefined;
   this.ht = undefined;
 }
 TargetShape.prototype = Object.prototype;
-/** Lazily allocate the patch-channel extension (one literal shape). */
-function pcOf(t) {
-  return t.pc ?? (t.pc = { sp: null, p: null, ro: null, wk: null, qa: null, qe: null });
-}
 function createTarget(value, parent, parentKey, fam = parent?.fam ?? null) {
   // The proxy target carries the array exotic class when the value is an
   // array, so Array.isArray(proxy) is true; the fields live on it directly.
@@ -7809,7 +9117,7 @@ function createTarget(value, parent, parentKey, fam = parent?.fam ?? null) {
   t.h = null;
   t.k = null;
   t.dk = null;
-  t.pc = null;
+  t.wk = null;
   t.u = parent;
   t.pk = parentKey;
   t.px = null;
@@ -7817,7 +9125,7 @@ function createTarget(value, parent, parentKey, fam = parent?.fam ?? null) {
   t.a = false;
   t.sc = false;
   t.nc = 0;
-  t.adopted = false;
+  t.ab = null;
   t.fam = fam;
   t.s = false;
   t.ovl = false;
@@ -7861,50 +9169,68 @@ function unwrapValue(v) {
 }
 // ---------------------------------------------------------------------------
 // nodes: pure subscription points (values used only for equality gating)
-function getNode(target, key, current) {
+// Shared slot-node equality (create-floor diet): ONE function for every
+// store node — `this` is the node (method-call convention at every _equals
+// site), `_host` is the baked-in target backref. Logical-slot equality:
+// values resolving to the same child target are the same slot
+// (privatization/adoption swap raw identity without changing the logical
+// value — only changed leaves notify, R9).
+const slotNodeEquals = function (a, b) {
+  return isEqual(a, b) || sameLogicalSlot(this._host, a, b);
+};
+// Shared slot-node unobserved handler (create-floor diet): registered once;
+// the core sweep dispatches CONFIG_SLOT_NODE nodes here instead of holding a
+// per-node closure in a per-node NodeExtension.
+setSlotUnobserved(node => {
+  // A live affects() mark keeps the node addressable (sweep parity).
+  if (node._x?._affectsCount) return;
+  const t = node._host;
+  const key = node._key;
+  if (t.n && t.n[key] === node) {
+    delete t.n[key];
+    t.nc--;
+  }
+});
+function getNode(
+  target,
+  key,
+  current,
+  // First-read dedupe (create-floor slice 2): the get trap probes
+  // accessor-ness right before creating the node — pass the verdict through
+  // so creation skips the second descriptor scan. -1 = unknown (other
+  // callers), 0/1 = probed.
+  accKnown = -1
+) {
   const nodes = (target.n ??= Object.create(null));
   let node = nodes[key];
   if (node === undefined) {
-    const created = (node = signal(
+    // Create-floor diet: slotSignal bakes the whole node into one literal —
+    // no options object, no equals/unobserved closures, no NodeExtension,
+    // no post-construction expandos (acc + the wrap cache px/pxv are
+    // pre-shaped fields: the proxy last served for this key and the raw it
+    // wrapped — one pointer compare replaces the per-read WeakMap lookup in
+    // wrapNext). ownedWrite rides the literal's config: the setter carries
+    // the owned-scope write guard; node-level setSignals are internal
+    // notification machinery. Projection nodes carry the projection
+    // computed as their firewall: reads through them link the derive's
+    // status/lifecycle (§7b).
+    const created = (node = slotSignal(
       current,
-      {
-        // Attribution-only: name store property nodes by path segment so
-        // attribution chains and wide-scope warnings read "store.todos", not
-        // "signal". Gated on the engine being installed — node creation is
-        // the hottest store path, and the disabled cost must stay one null
-        // check (nodes created before enable() stay generically named).
-        name: attrHooks !== null ? "store." + String(key) : undefined,
-        // Logical-slot equality: values resolving to the same child target
-        // are the same slot (privatization/adoption swap raw identity without
-        // changing the logical value — only changed leaves notify, R9).
-        equals: (a, b) => isEqual(a, b) || sameLogicalSlot(target, a, b),
-        unobserved() {
-          // A live affects() mark keeps the node addressable (sweep parity).
-          if (created._x?._affectsCount) return;
-          if (target.n && target.n[key] === created) {
-            delete target.n[key];
-            target.nc--;
-          }
-        }
-      },
-      // Projection nodes carry the projection computed as their firewall:
-      // reads through them link the derive's status/lifecycle (§7b).
+      slotNodeEquals,
+      target,
+      key,
+      // Accessor-ness resolved ONCE per node (no per-object descriptor
+      // scan on reads): accessor keys serve through Reflect.get with the
+      // proxy receiver.
+      accKnown === -1 ? isOwnAccessor(target.pb ?? target.v, key) : accKnown === 1,
       target.fam?.node ?? undefined
     ));
-    // Store nodes are ownedWrite: the setter carries the owned-scope write
-    // guard; node-level setSignals are internal notification machinery.
-    created._config |= CONFIG_OWNED_WRITE;
-    // Accessor-ness resolved ONCE per node (no per-object descriptor scan):
-    // accessor keys serve through Reflect.get with the proxy receiver.
-    created.acc = isOwnAccessor(target.pb ?? target.v, key);
-    // Wrap cache: the proxy last served for this key and the raw it wrapped.
-    // Raw-as-truth stores raw in nodes, so every object read needs a wrapper;
-    // one pointer compare (pxv === value) replaces the per-read WeakMap
-    // lookup in wrapNext — the dominant read-path cost vs legacy, whose
-    // nodes stored pre-wrapped values. A replaced child fails the compare
-    // and re-wraps; at most one stale proxy is pinned until the next read.
-    created.px = undefined;
-    created.pxv = undefined;
+    // Attribution-only: name store property nodes by path segment so
+    // attribution chains and wide-scope warnings read "store.todos", not
+    // "signal". Gated on the engine being installed — node creation is
+    // the hottest store path, and the disabled cost must stay one null
+    // check (nodes created before enable() stay generically named).
+    if (attrHooks !== null) created._name = "store." + String(key);
     // Optimistic families: arm the override slot — setSignal routes armed
     // nodes through the core engine (lanes, ownership, reverts all native).
     if (target.fam?.opt) {
@@ -8028,11 +9354,15 @@ function cloneRaw(source, t) {
     ? Object.defineProperties([], descs)
     : Object.create(Object.getPrototypeOf(source), descs);
 }
-/** Scanned plainness for patch admission (patchableRaw): runs the one-time
- * accessor scan if it hasn't happened yet — the sticky `a` flag alone is not
- * trustworthy before a scan (it starts false and is discovered lazily). */
-function targetIsPlain(target) {
-  return target.sc ? !target.a : scanAccessorsOnce(target);
+/** Copy own `key` from `from` onto `to`. A plain data slot (enumerable,
+ * writable, configurable, no accessor) is a bare assignment — the common case
+ * and the cheap one; anything else goes through defineProperty so accessors
+ * and attribute flags survive the copy. */
+function copyOwn(to, from, key) {
+  const d = Object.getOwnPropertyDescriptor(from, key);
+  if (d.get || d.set || !d.enumerable || !d.writable || !d.configurable)
+    Object.defineProperty(to, key, d);
+  else to[key] = d.value;
 }
 /** One-time own-accessor scan (Annex-B probes, no descriptor allocation);
  * returns true when the container is plain data (overlay-safe). */
@@ -8057,12 +9387,7 @@ function materializePB(target) {
   if (!target.ovl) return;
   const proto = target.pb;
   const clone = cloneRaw(target.v, target);
-  for (const key of Reflect.ownKeys(proto)) {
-    const d = Object.getOwnPropertyDescriptor(proto, key);
-    if (d.get || d.set || !d.enumerable || !d.writable || !d.configurable)
-      Object.defineProperty(clone, key, d);
-    else clone[key] = d.value;
-  }
+  for (const key of Reflect.ownKeys(proto)) copyOwn(clone, proto, key);
   if (target.del !== null) {
     for (const key of target.del) delete clone[key];
     target.del = null;
@@ -8174,7 +9499,18 @@ function adoptPB(target, incoming, eager = false) {
   // fold diff; ~half of dbmon tick time was this duplication).
   if (!eager) {
     queueFold(target); // records the pre-batch old before we swap
-    target.adopted = true;
+    // Diff base = the view the nodes were last told (#3296). A draft's
+    // setter-exit notifications already moved them to its pending backing,
+    // so a later adoption diffs against THAT — against committed, a key the
+    // draft changed and the adoption restores would never re-notify. An
+    // adoption with no draft leaves nodes where they were: keep an existing
+    // base, else the pre-batch committed (foldOlds' entry itself stays the
+    // committed identity for the path-copy CAS). Eager callers read t.pb
+    // directly; this hand-off exists because pb is gone by drain time.
+    if (target.pb !== null) {
+      if (target.ovl) materializePB(target);
+      target.ab = target.pb;
+    } else target.ab ??= foldOlds.get(target);
     // #3074/#3075: a projection recompute deriving from uncommitted inputs
     // swaps the backing SPECULATIVELY — committed-visibility readers must
     // keep the pre-hold view until the hold resolves (a source held by a
@@ -8202,7 +9538,7 @@ function adoptPB(target, incoming, eager = false) {
   target.del = null;
   target.sc = false;
   target.a = false;
-  if (target.pc !== null) target.pc.wk = null; // adoption supersedes staged trap writes
+  target.wk = null; // adoption supersedes staged trap writes
   target.v = incoming;
   target.ch = incoming[$TARGET] !== undefined;
   (target.fam?.map ?? storeNextLookup).set(incoming, target);
@@ -8248,19 +9584,55 @@ const stagedTruthPB = new WeakMap();
  * transition is ambient). Entries die with their draft — tentative backings
  * are consumed at setter exit. */
 const tentativePBs = new WeakSet();
+/** A draft read composes the live optimistic view until the draft has opened
+ * its OWN view-seeded backing (ensurePB seeds that clone from the view and
+ * registers it in tentativePBs; from then on reads must see the draft's
+ * writes, not the overrides they superseded). A pending backing that exists
+ * for any other reason is not that clone — a truth landing staged into a
+ * retaining transaction (#3164 fold) is authoritative truth WITHOUT the
+ * live overrides. ensurePB parks such a backing on the draft's first WRITE
+ * and reseeds from the view, but the reads that precede that write went to
+ * the staged truth: `votes++` read base, wrote base+1, and the override it
+ * emitted landed on the value already displayed — a second in-flight
+ * increment made after a sibling's landing was invisible (#2951's compose
+ * half, one landing later). */
+function draftSeesOverrides(target) {
+  return target.pb === null || !tentativePBs.has(target.pb);
+}
 /** Committed-time privatization for parent-chain slot updates (path copying). */
 function privatizeCommitted(target) {
   if (ownedRaw.has(target.v)) return;
-  const clone = cloneRaw(target.v, target);
+  const before = target.v;
+  const clone = cloneRaw(before, target);
   ownedRaw.add(clone);
-  storeNextLookup.set(clone, target);
+  // Register in the target's OWN registration map (#3284): family targets
+  // (derived stores, projections, optimistic) resolve children through
+  // fam.map — a clone parked only in the global lookup makes the next parent
+  // read miss, wrap a fresh target, and orphan every node (subscribers) on
+  // this one.
+  (target.fam?.map ?? storeNextLookup).set(clone, target);
   target.v = clone;
   target.ch = false;
   if (target.u) {
     privatizeCommitted(target.u);
     devAssertNeverUserMutation(target.u.v);
-    target.u.v[target.pk] = target.v;
-  }
+    target.u.v[parentSlotKey(target, before)] = target.v;
+  }
+}
+/** Resolve the slot this child currently occupies in its parent's committed
+ * backing (#3282). `pk` is stamped at wrap time and arrays MOVE: a reverse/
+ * unshift/splice relocates the raw, and a fold that re-points the wrap-time
+ * slot writes the clone over whichever row lives there now. Objects never
+ * move keys, so the stamp is authoritative; for arrays, verify and re-locate
+ * by identity when stale (fold-time only — never on a read path). */
+function parentSlotKey(target, expected) {
+  const pk = target.pk;
+  const pv = target.u.v;
+  if (pv[pk] === expected || !Array.isArray(pv)) return pk;
+  const at = pv.indexOf(expected);
+  if (at === -1) return pk;
+  target.pk = at;
+  return at;
 }
 function drainFolds() {
   if (foldOlds.size === 0) return;
@@ -8271,11 +9643,6 @@ function drainFolds() {
     // is committing the batch the pull ran ahead of. Transition holds stay —
     // they clear when their transition is done (heldMaskView).
     if (t.ht === PLAIN_HOLD) t.ht = t.hv = null;
-    // Eager (write-override) family folds swap pb -> v at notifyWrites'
-    // tail: by the time this drain runs they carry no pb, and their
-    // structural ops must emit at the fold-commit site below (the clone
-    // branch never sees them). Re-audit blocker 4.
-    const foldedEager = t.pb === null;
     if (t.pb !== null) {
       // #3089: a fold written under a still-running transition defers to
       // that transition's settle (the write-time stamp covers unobserved
@@ -8299,7 +9666,7 @@ function drainFolds() {
         // Only written keys can hold (their nodes took the setSignal); the
         // wk bound keeps this O(written) — see notifyWrites. Same fallback
         // rules as the notify (WK_ALL / accessors / non-plain prototypes).
-        const wkh = t.pc !== null ? t.pc.wk : null;
+        const wkh = t.wk;
         const keys =
           wkh === null ||
           wkh === WK_ALL ||
@@ -8331,12 +9698,7 @@ function drainFolds() {
         // — the never-mutate-user-data contract holds.
         privatizeCommitted(t);
         const v = t.v;
-        for (const key of Reflect.ownKeys(pb)) {
-          const d = Object.getOwnPropertyDescriptor(pb, key);
-          if (d.get || d.set || !d.enumerable || !d.writable || !d.configurable)
-            Object.defineProperty(v, key, d);
-          else v[key] = d.value;
-        }
+        for (const key of Reflect.ownKeys(pb)) copyOwn(v, pb, key);
         if (t.del !== null) {
           for (const key of t.del) delete v[key];
           t.del = null;
@@ -8344,82 +9706,141 @@ function drainFolds() {
         (t.fam?.map ?? storeNextLookup).delete(pb);
         t.pb = null;
         t.ovl = false;
-        if (t.pc !== null) t.pc.wk = null; // written-keys window closes with the fold commit
+        t.wk = null; // written-keys window closes with the fold commit
+      } else if (t.v !== old) {
+        // Privatized mid-batch (#3271): an earlier fold in this drain
+        // path-copied THROUGH this target — privatizeCommitted cloned the
+        // committed backing, re-pointed the parent slot at the clone, and
+        // stitched the descendant's fold into it. The draft's pb predates
+        // that: swapping it in would clobber the descendant's fold, and the
+        // parent CAS below (still comparing against `old`) would fail and
+        // orphan this fold entirely — a projection draft writing descendant-
+        // then-ancestor silently lost the ancestor write. Merge the batch's
+        // writes onto the current container instead (the parent slot already
+        // points at it). privatize first: an adopt-then-write batch can land
+        // here with an unowned adoptee as t.v.
+        privatizeCommitted(t);
+        const v = t.v;
+        const wk = t.wk;
+        if (wk !== null && wk !== WK_ALL) {
+          // The trap records every write/delete key — apply exactly those.
+          for (const key of wk) {
+            if (hasOwn.call(pb, key)) copyOwn(v, pb, key);
+            else delete v[key];
+          }
+        } else {
+          // Array length write poisoned the bound (WK_ALL) — value-diff
+          // against the pre-batch old. Slots the draft never touched hold
+          // the same raw reference in both, so descendant folds stay put.
+          // Not copyOwn: the plain-value write is GATED on "the draft changed
+          // this slot" — an untouched slot in pb holds the pre-batch reference,
+          // and writing it back would clobber a descendant fold stitched into v.
+          for (const key of Reflect.ownKeys(pb)) {
+            const d = Object.getOwnPropertyDescriptor(pb, key);
+            if (d.get || d.set || !d.enumerable || !d.writable || !d.configurable)
+              Object.defineProperty(v, key, d);
+            else if (d.value !== old[key] || !hasOwn.call(old, key)) v[key] = d.value;
+          }
+          for (const key of Reflect.ownKeys(old)) {
+            if (!hasOwn.call(pb, key)) delete v[key];
+          }
+        }
+        (t.fam?.map ?? storeNextLookup).delete(pb);
+        t.pb = null;
+        t.wk = null; // written-keys window closes with the fold commit
       } else {
-        // Setter-channel structural ops: a fold that changes an array's shape
-        // (push/splice/permutation through the setter — the reconcile walk
-        // never queues here) is a structural visibility transition for any
-        // registered list driver. Identity-keyed; aligned folds emit nothing.
-        // Family targets defer to their own adoption emission (fam reconcile).
-        // Arrays always fold on this clone branch (overlay is non-array only).
-        // Family setter drafts (writable projection push/splice through the
-        // masked setter) fold on this branch too and the fold IS their
-        // visibility moment — emit unless the structure already rode another
-        // channel: adoption folds (reconcile walk emitted ops) and
-        // optimistic families (lane-timed override channel). Re-audit
-        // blocker 4.
-        if (
-          t.pc !== null &&
-          t.pc.ro !== null &&
-          !t.adopted &&
-          t.fam?.opt !== true &&
-          Array.isArray(pb) &&
-          Array.isArray(t.v)
-        )
-          rowHooks.emitSetterRowOps(t, t.v, pb);
         t.v = pb;
         t.ch = false; // pb is always a plain clone
         t.pb = null;
-        if (t.pc !== null) t.pc.wk = null; // written-keys window closes with the fold commit
+        t.wk = null; // written-keys window closes with the fold commit
+      }
+    }
+    const base = t.ab;
+    t.ab = null;
+    if (t.v !== old) {
+      // Path copying (CAS: see the eager-fold twin above). Slot resolved by
+      // identity (#3282): an array move relocated the raw, so the wrap-time
+      // pk may point at a sibling — a raw-slot CAS there both failed to
+      // re-point AND (via privatizeCommitted's unguarded write) clobbered
+      // the sibling.
+      if (t.u) {
+        const slot = parentSlotKey(t, old);
+        if (t.u.v[slot] === old) {
+          privatizeCommitted(t.u);
+          devAssertNeverUserMutation(t.u.v);
+          t.u.v[slot] = t.v;
+        }
       }
     }
-    if (t.v === old) {
-      // A no-op adoption (A -> B -> A before flush) still consumed its walk:
-      // clear the flag or every later setter row-op gate (!t.adopted) stays
-      // failed and a driven family list freezes (re-audit 5, P1-1).
-      t.adopted = false;
+    // Adoption notify against the base the nodes were last told (#3296). A
+    // no-op adoption (A -> B -> A before flush, no draft) has base === v and
+    // nothing to say; a draft superseded by an adoption back to the SAME raw
+    // still has (base = pending backing) !== v and must notify.
+    if (base !== null && base !== t.v) notifyFold(t, base, t.v);
+  }
+}
+/** Dev: dotted path of a target from its store root (`store.user.address`). */
+function storePath$1(t) {
+  let path = "";
+  for (let cur = t; cur !== null; cur = cur.u)
+    path = cur.pk === null ? "store" + path : "." + String(cur.pk) + path;
+  return path;
+}
+/**
+ * Dev (attribution engine installed): announce written keys whose old and new
+ * values are both containers but different logical slots — the raw material
+ * for the spread-copy diagnostic. The engine owns the verdict.
+ */
+function reportReplacedContainers(t, old, pb, writtenKeys) {
+  const keys = writtenKeys ?? Reflect.ownKeys(pb);
+  const isArray = Array.isArray(pb);
+  for (const key of keys) {
+    if (isArray && key === "length") continue;
+    if (t.del !== null && t.del.has(key)) continue;
+    const ov = unwrapValue(old[key]);
+    const nv = unwrapValue(pb[key]);
+    if (
+      ov === null ||
+      nv === null ||
+      typeof ov !== "object" ||
+      typeof nv !== "object" ||
+      ov === nv ||
+      targetsEqual(ov, nv)
+    )
       continue;
-    }
-    // Patch channel (fold-commit site): family targets emit HERE — the fold
-    // IS their visibility moment (held folds re-queued above emit when they
-    // actually commit) — and so do PLAIN fold-adopted targets (setter-
-    // returned root replacements, chained-store swaps: adoptions WITHOUT a
-    // reconcile walk, so no walk-site emission ever happened — re-audit 2,
-    // P1-2). Plain eager targets emitted at their walk/setter sites already.
-    if (t.pc !== null && (t.fam !== null || t.adopted)) {
-      // Structural ops for folds whose structure rode no other channel:
-      // eager-folded family SETTER drafts (write-override swaps pb -> v at
-      // notifyWrites' tail — the clone branch never sees them; adoption
-      // folds re-emitting would double the walk's ops) and PLAIN fold
-      // adoptions (no walk at all). Optimistic families ride the override
-      // channel (lane-timed ops + revert RESYNC) — never re-emit here.
-      if (
-        t.pc.ro !== null &&
-        t.fam?.opt !== true &&
-        (t.fam !== null ? foldedEager && !t.adopted : t.adopted) &&
-        Array.isArray(t.v) &&
-        Array.isArray(old)
-      )
-        rowHooks.emitSetterRowOps(t, old, t.v);
-      if (t.pc.p !== null) {
-        // Accessor demotion at the fold-commit seam is DEV-ONLY (see the
-        // reconcile seam note: prod never pays per-adoption scans).
-        if (!targetIsPlain(t)) patchHooks.demoteToEffects(t);
-        else patchHooks.emitPatchLocal(t, t.v, old);
-      }
-    }
-    // Path copying (CAS: see the eager-fold twin above).
-    if (t.u && t.u.v[t.pk] === old) {
-      privatizeCommitted(t.u);
-      devAssertNeverUserMutation(t.u.v);
-      t.u.v[t.pk] = t.v;
-    }
-    if (t.adopted) {
-      t.adopted = false;
-      notifyFold(t, old, t.v);
-    }
+    // Leaf census on the store side: leaves read through a draft are proxies
+    // of the committed raws, so identity must be judged on unwrapped values.
+    const isArr = Array.isArray(nv);
+    if (isArr !== Array.isArray(ov)) continue;
+    let total;
+    let unchanged = 0;
+    if (isArr) {
+      total = nv.length;
+      if (total > REPLACED_CENSUS_MAX) continue;
+      const oldItems = new Set();
+      for (const item of ov) oldItems.add(unwrapValue(item));
+      for (const item of nv) if (oldItems.has(unwrapValue(item))) unchanged++;
+    } else {
+      const nkeys = Object.keys(nv);
+      total = nkeys.length;
+      if (total > REPLACED_CENSUS_MAX) continue;
+      for (const k of nkeys) if (sameLeaf(ov[k], nv[k])) unchanged++;
+    }
+    attrHooks.storeReplaced(
+      storePath$1(t) + "." + String(key),
+      isArr,
+      total,
+      unchanged,
+      isArr ? ov.length : Object.keys(ov).length
+    );
   }
 }
+const REPLACED_CENSUS_MAX = 64;
+function sameLeaf(a, b) {
+  if (a === b) return true;
+  if (a === null || b === null || typeof a !== "object" || typeof b !== "object") return false;
+  return unwrapValue(a) === unwrapValue(b) || targetsEqual(a, b);
+}
 /**
  * Setter-exit notification (write channel): diff the draft's pending backing
  * against committed and setSignal every changed OBSERVED key — write-time
@@ -8484,7 +9905,7 @@ function notifyWrites(t) {
   // implicit index deletes), accessors on the record (t.a — a getter node's
   // value can change when ANY key is written), or a non-plain prototype
   // (class instances: prototype getters derive from arbitrary fields).
-  const wk0 = t.pc !== null ? t.pc.wk : null;
+  const wk0 = t.wk;
   // Overlay pbs chain to the COMMITTED object (#3044): a prototype-overlay
   // draft is plain data on its own layer, but its getPrototypeOf is the
   // committed container — judge plainness by the COMMITTED prototype or the
@@ -8492,6 +9913,7 @@ function notifyWrites(t) {
   // would full-scan: the exact selection-map workload wk exists for; jf
   // `select` regressed 2x on this).
   const writtenKeys = wk0 === WK_ALL || t.a === true || !plainProto(t.ovl ? t.v : pb) ? null : wk0;
+  if (attrHooks !== null) reportReplacedContainers(t, old, pb, writtenKeys);
   if (nodes !== null) {
     const keys = writtenKeys ?? Reflect.ownKeys(nodes);
     for (const key of keys) {
@@ -8564,13 +9986,6 @@ function notifyWrites(t) {
     }
     if (changed) setSignal(t.k, v => v + 1);
   }
-  // Patch channel (setter site): a committed write transitions this record —
-  // queue its patches and bubble to ancestors (targeted nested writes must
-  // reach the row patch, §4b). One number compare when no patches exist.
-  // Family targets skip this site: their visibility moment is the FOLD
-  // commit (drainFolds emits), not the recompute/draft write.
-  if (t.fam === null && patchHooks !== null && patchHooks.hasPatches())
-    patchHooks.emitPatch(t, pb, old);
   // Projection backing folds split by channel (two pinned contracts):
   // - sync-derive drafts (recompute body): NEVER eager — a downstream async
   //   hold can form LATER in the same flush and the leaf must stay at stale
@@ -8595,10 +10010,14 @@ function notifyWrites(t) {
     t.pb = null;
     t.v = pb;
     t.ch = false;
-    if (t.u && t.u.v[t.pk] === oldBacking) {
-      privatizeCommitted(t.u);
-      devAssertNeverUserMutation(t.u.v);
-      t.u.v[t.pk] = pb;
+    if (t.u) {
+      // Identity-resolved slot (#3282) — see drainFolds' path-copy twin.
+      const slot = parentSlotKey(t, oldBacking);
+      if (t.u.v[slot] === oldBacking) {
+        privatizeCommitted(t.u);
+        devAssertNeverUserMutation(t.u.v);
+        t.u.v[slot] = pb;
+      }
     }
   }
 }
@@ -8977,7 +10396,7 @@ function nodeValue(node, backing) {
  * backing IS another store's proxy) serve the read-through value — the outer
  * node is linked only for adoption-swap notification, its value never
  * shadows the live chain. */
-function serveDataKey(target, key, backingValue, src, node) {
+function serveDataKey(target, key, backingValue, src, node, accKnown = -1) {
   const chained = target.ch && src === target.v;
   let v = backingValue;
   // §6: on optimistic arrays LENGTH IS A VIEW, not a node value — one home
@@ -9005,7 +10424,7 @@ function serveDataKey(target, key, backingValue, src, node) {
     // #2951). Once ensurePB runs, the seeded clone carries the view.
     // AUTHORITATIVE drafts (projection derive) never overlay — ensurePB's
     // seeding rule, applied to the read side (#3108).
-    if (target.fam?.opt && target.pb === null && !authoritativeServe()) {
+    if (target.fam?.opt && draftSeesOverrides(target) && !authoritativeServe()) {
       const node = target.n?.[key];
       if (node !== undefined && hasActiveOverride(node))
         v = unwrapOverride(node._x?._overrideValue);
@@ -9025,7 +10444,9 @@ function serveDataKey(target, key, backingValue, src, node) {
         v = nodeValue(node, backingValue);
       }
     } else if (getObserver() !== null) {
-      read(getNode(target, key, backingValue));
+      // First tracked read: create + link, and let the wrap-cache branch
+      // below populate px/pxv so read #2 skips wrapNext (slice 2).
+      read((node = getNode(target, key, backingValue, accKnown)));
     }
   }
   // Shallow stores serve data raw; store-proxy slots get boundary wrappers.
@@ -9127,8 +10548,11 @@ const traps = {
     // tracked read of a present data key — the dbmon/uibench effect re-read
     // shape. Skips serveDataKey's frame, the FORCE compare (only accessor
     // keys ever hold the sentinel), and isWrappable for primitives.
+    // ONE node-map lookup serves this block and the accessor probe below
+    // (nothing between them creates nodes).
+    const node0 = target.n?.[key];
     if (target.ch === false && writeScopes === null) {
-      const nodeH = target.n?.[key];
+      const nodeH = node0;
       if (nodeH !== undefined && nodeH.acc !== true && getObserver() !== null) {
         let nv = readNodeFast(nodeH);
         if (nv === READ_SLOW) nv = read(nodeH);
@@ -9146,7 +10570,19 @@ const traps = {
     }
     // Dev strictRead: untracked store reads in labeled scopes (component
     // bodies, effect callbacks) warn — the value can never update the reader.
-    if (strictRead && !inDraft(target) && typeof key === "string" && getObserver() === null) {
+    // `then` is exempt: resolving a promise with a store proxy (refresh()'s
+    // waiter delivers the store, `Promise.resolve(store)`, `return store`
+    // from an async function) makes the engine probe `.then` for
+    // thenable-ness synchronously in the caller's scope. That is not a read
+    // the user wrote, and it must neither warn nor escalate to the pending
+    // throw — a throw out of promise resolution rejects the promise.
+    if (
+      strictRead &&
+      !inDraft(target) &&
+      typeof key === "string" &&
+      key !== "then" &&
+      getObserver() === null
+    ) {
       // Safeguard parity with core read() (#2897): a component-body read of
       // a REFETCHING derived store escalates — the untracked reader can never
       // observe the in-flight update (strict-read matrix, opt R30–R34).
@@ -9169,15 +10605,21 @@ const traps = {
     // absent-key/accessor subscriptions for every store read during any
     // derive, leaving nested projections permanently dependency-less when
     // their sources hadn't materialized yet (#3037).
-    const node0 = target.n?.[key];
+    // First-read dedupe (create-floor slice 2): remember the probe verdict —
+    // node creation downstream reuses it instead of re-scanning the
+    // descriptor, but only when the probed object IS the one getNode would
+    // scan (pb ?? v).
+    let accProbe = -1;
     {
-      const acc =
-        node0 !== undefined
-          ? node0.acc === true
-          : !inDraft(target) && getObserver() !== null && isOwnAccessor(src, key);
+      let acc;
+      if (node0 !== undefined) acc = node0.acc === true;
+      else if (!inDraft(target) && getObserver() !== null) {
+        acc = isOwnAccessor(src, key);
+        if (src === (target.pb ?? target.v)) accProbe = acc ? 1 : 0;
+      } else acc = false;
       if (acc) {
         if (!inDraft(target) && getObserver() !== null)
-          read(node0 ?? getNode(target, key, undefined));
+          read(node0 ?? getNode(target, key, undefined, accProbe));
         const v = Reflect.get(src, key, receiver);
         if (target.s) return serveShallow(target, key, v);
         return isWrappable(v) ? draftServe(target, wrapNext(v, target, key)) : v;
@@ -9207,7 +10649,7 @@ const traps = {
       // Reading a currently-absent own key subscribes to it (R12) — for any
       // target OUTSIDE its own draft scope, even mid-setter (#3037, above).
       if (v === undefined && !inDraft(target)) {
-        if (getObserver() !== null) read(getNode(target, key, undefined));
+        if (getObserver() !== null) read(getNode(target, key, undefined, accProbe));
         const node = target.n?.[key];
         if (node) {
           const nv = nodeValue(node, undefined);
@@ -9218,7 +10660,7 @@ const traps = {
         v === undefined &&
         inDraft(target) &&
         target.fam?.opt &&
-        target.pb === null &&
+        draftSeesOverrides(target) &&
         // AUTHORITATIVE drafts (landing folds) never seed from overrides —
         // the caller's optimism is not truth (has-trap twin below).
         !authoritativeServe()
@@ -9236,7 +10678,7 @@ const traps = {
       !(viewOvl && hasOwn.call(target.v, key))
     )
       return v; // proto method
-    return serveDataKey(target, key, v, src, node0);
+    return serveDataKey(target, key, v, src, node0, accProbe);
   },
   has(target, key) {
     if (key === $TARGET || key === $PROXY || key === $TRACK) return true;
@@ -9258,7 +10700,7 @@ const traps = {
         if (node !== undefined && hasActiveOverride(node))
           present = !!unwrapOverride(node._x?._overrideValue);
       }
-    } else if (target.fam?.opt && target.pb === null && !authoritativeServe()) {
+    } else if (target.fam?.opt && draftSeesOverrides(target) && !authoritativeServe()) {
       const node = target.h?.[key];
       if (node !== undefined && hasActiveOverride(node))
         present = !!unwrapOverride(node._x?._overrideValue);
@@ -9290,7 +10732,7 @@ const traps = {
       !authoritativeServe() &&
       target.fam?.opt &&
       target.h !== null &&
-      (!inDraft(target) || target.pb === null)
+      (!inDraft(target) || draftSeesOverrides(target))
     ) {
       let set = null;
       for (const key of Reflect.ownKeys(target.h)) {
@@ -9355,15 +10797,14 @@ const traps = {
     // Array length writes implicitly delete indices — the written-keys bound
     // can't see them, so poison to the full scan for this batch. Index
     // writes implicitly GROW length, so arrays always record it alongside.
-    const pcs = pcOf(target);
     if (Array.isArray(pb)) {
-      if (key === "length") pcs.wk = WK_ALL;
-      else if (pcs.wk !== WK_ALL) {
-        const wk = (pcs.wk ??= new Set());
+      if (key === "length") target.wk = WK_ALL;
+      else if (target.wk !== WK_ALL) {
+        const wk = (target.wk ??= new Set());
         wk.add(key);
         wk.add("length");
       }
-    } else if (pcs.wk !== WK_ALL) (pcs.wk ??= new Set()).add(key);
+    } else if (target.wk !== WK_ALL) (target.wk ??= new Set()).add(key);
     // Own data keys literally named "prototype"/"constructor" land as data —
     // defineProperty sidesteps a proto-chain setter named the same.
     if (UNSAFE_KEYS.has(key)) {
@@ -9401,20 +10842,12 @@ const traps = {
     const override = !draft && getWriteOverride();
     if (!draft && !override) return true;
     if (key === "__proto__") return true;
-    if (desc.get || desc.set) {
-      target.a = true;
-      // Accessor demotion (re-audit blocker 3): a record that acquires an
-      // accessor after patch registration stops being patchable — pull its
-      // patches and re-drive them as tracked effect fallbacks. Hooks are
-      // installed whenever pc.p exists (registration installs them).
-      if (target.pc !== null && target.pc.p !== null) patchHooks.demoteToEffects(target);
-    }
+    if (desc.get || desc.set) target.a = true;
     // Unwrap before ensurePB (see the set trap: self-reference materializes).
     if ("value" in desc) desc = { ...desc, value: unwrapValue(desc.value) };
     const pb = ensurePB(target);
     pendingNotify.add(target);
-    const pcd = pcOf(target);
-    if (pcd.wk !== WK_ALL) (pcd.wk ??= new Set()).add(key);
+    if (target.wk !== WK_ALL) (target.wk ??= new Set()).add(key);
     Object.defineProperty(pb, key, desc);
     if (target.del !== null) target.del.delete(key);
     if (override) notifyWrites(target);
@@ -9426,8 +10859,7 @@ const traps = {
     if (!draft && !override) return true;
     const pb = ensurePB(target);
     pendingNotify.add(target);
-    const pcx = pcOf(target);
-    if (pcx.wk !== WK_ALL) (pcx.wk ??= new Set()).add(key);
+    if (target.wk !== WK_ALL) (target.wk ??= new Set()).add(key);
     delete pb[key];
     // A prototype overlay cannot shadow a delete of a committed key —
     // record it aside (#3044); reads/has/ownKeys/commit consult the set.
@@ -9482,24 +10914,29 @@ function storeSetterNext(proxy, fn, guard = true) {
 setNextAffectsNodeResolver((t, key) =>
   key === $AFFECTS ? getNode(t, $AFFECTS, undefined) : getNode(t, key, (t.pb ?? t.v)[key])
 );
-function createStoreNext(init, shallow = false) {
+function createStoreNext(initialValue, shallow = false) {
   if (shallow && true) {
     // Never both deep-wrapped and raw (R41/R44): a value already tracked as
     // a DEEP store cannot be ingested shallow.
-    const existing = storeNextLookup.get(init);
+    const existing = storeNextLookup.get(initialValue);
     if (existing !== undefined && !existing.s)
       throw new Error("createStore({ shallow }): value is already tracked as a deep store");
-    if (init[$TARGET]) throw new Error("createStore({ shallow }): value is already a store proxy");
+    if (initialValue[$TARGET])
+      throw new Error("createStore({ shallow }): value is already a store proxy");
   }
-  const proxy = wrapNext(init);
+  const proxy = wrapNext(initialValue);
   if (shallow) {
     proxy[$TARGET].s = true;
-    markRawIngest(init);
+    markRawIngest(initialValue);
   }
   registerGraph(proxy, getOwner());
   const setter = fn => storeSetterNext(proxy, fn);
   return [proxy, setter];
 }
+// ---------------------------------------------------------------------------
+// snapshot (next targets): the backing IS the plain raw graph — zero copy.
+// Sees pending (R27) by reading pb. Chained/owned-copy caching lands with the
+// utilities increment; this covers the createStore-suite contract.
 /** True when `proxy` is a SHALLOW store (children served verbatim, slots
  * replaced by reference — #2932). The list driver uses this to choose the
  * slot-patch channel (collected row bodies) over per-record registration. */
@@ -9550,8 +10987,26 @@ function deepNext(value) {
     read(getKeySetNode(t));
     read(getDeepNode(t));
     const map = t.fam?.map ?? storeNextLookup;
-    for (const key of Reflect.ownKeys(src)) {
-      const desc = Object.getOwnPropertyDescriptor(src, key);
+    // Overlay pending backings chain to the committed object (#3044): their
+    // OWN keys are only this batch's writes. A bare ownKeys walk mid-flush
+    // (effects recompute before the fold commits) missed every untouched
+    // child, so the re-subscribing effect dropped those records from its
+    // dependency set — later child edits never notified it (#3283). Merge
+    // committed keys, minus deletes, exactly as the ownKeys trap does.
+    let keys = Reflect.ownKeys(src);
+    if (t.ovl && src === t.pb) {
+      const merged = Reflect.ownKeys(t.v);
+      const del = t.del;
+      const filtered =
+        del !== null && del.size !== 0 ? merged.filter(key => !del.has(key)) : merged;
+      for (const key of keys) {
+        if (!hasOwn.call(t.v, key)) filtered.push(key);
+      }
+      keys = filtered;
+    }
+    for (const key of keys) {
+      const desc =
+        Object.getOwnPropertyDescriptor(src, key) ?? Object.getOwnPropertyDescriptor(t.v, key);
       if (desc === undefined) continue;
       if (desc.get || desc.set) {
         t.a = true;
@@ -9776,35 +11231,13 @@ function applyAdopt(t, incoming, keyFn, proj = false) {
   // folds (downstream holds can form later in the flush).
   const eager = fam === null;
   const shallow = t.s === true;
-  const old = t.v;
+  // Node-notify base is the view the nodes were last told (#3296): a draft
+  // preceding this reconcile already moved them to its pending backing at
+  // setter exit (prev, materialized above), so diffing incoming against the
+  // committed backing would skip a key the draft changed and the reconcile
+  // restores — the node would commit the superseded draft value.
+  const old = prev;
   adoptPB(t, incoming, eager);
-  // Patch channel (adoption site): this record transitioned — queue its
-  // patches with the pre-adopt prev. No bubbling walk: the adoption walk
-  // visits parents before children, so ancestors emitted already. EAGER
-  // only — family targets' visibility moment is their fold commit
-  // (drainFolds emits there; emitting here too would double-fire).
-  if (patchHooks !== null && eager && t.pc !== null && t.pc.p !== null) {
-    // Accessor demotion at the ADOPTION seam is DEV-ONLY (prod principle:
-    // explicitly-odd input must not cost correct-input prod — the
-    // per-adoption scan was ~12% of dbmon's tick since adoptPB resets the
-    // verdict every adoption). Dev demotes AND warns; prod emits directly,
-    // so a getter adoptee's OUTSIDE deps (signals) won't re-apply in prod —
-    // caught loudly during development instead. Registration-time admission
-    // (patchableRaw) keeps its full one-time scan in both modes.
-    if (!targetIsPlain(t)) {
-      console.warn(
-        "A reconcile adopted an object with own getters into a record that " +
-          "carries compiled patches. Patches read raw values and will not " +
-          "track the getters' reactive dependencies — this record's patches " +
-          "are demoted to effects in development, but production will NOT " +
-          "demote. Avoid getters on patched records, or key them out of " +
-          "patch-eligible templates."
-      );
-      patchHooks.demoteToEffects(t);
-    } else {
-      patchHooks.emitPatchLocal(t, incoming, old);
-    }
-  }
   // Shallow adoption: records are slot values — sticky raw-mark the incoming
   // set (R41) and never descend; slot notification is the positional diff.
   if (shallow) markRawIngest(incoming);
@@ -9928,62 +11361,12 @@ function applyAdopt(t, incoming, keyFn, proj = false) {
           }
         }
       }
-      // Row ops (PR-B): emit structural ops ONLY when structure changed —
-      // aligned value ticks pay nothing. Built after the walk so retained
-      // rows' value patches queue first (adds bind at op-apply).
-      if (
-        rowHooks !== null &&
-        t.pc !== null &&
-        t.pc.ro !== null &&
-        (structStart < nlen || plen !== nlen)
-      )
-        buildAndEmitRowOps(t, prevRows, nextRows, structStart, keyFn);
     } else {
       const dlen = Math.min(prevRows.length, nextRows.length);
       const nlen = nextRows.length;
       let dkBumpedP = false;
-      const sp = rowHooks !== null && t.pc !== null ? t.pc.sp : null;
-      // Row ops for shallow/positional lists: track the key-aligned prefix
-      // (keyed) so aligned value ticks emit nothing; keyless lists emit only
-      // on length change (append/truncate). Slot-patch consumers need the
-      // alignment tracking too (aligned = value tick, misaligned = ops).
-      const ro = rowHooks !== null && t.pc !== null ? t.pc.ro : null;
-      let keyAligned = keyFn !== null && (ro !== null || sp !== null);
-      let keyPrefix = 0;
       for (let i = 0; i < nlen; i++) {
         const nvP = nextRows[i];
-        if (keyAligned && i < dlen) {
-          const pvK = prevRows[i];
-          if (
-            pvK !== null &&
-            typeof pvK === "object" &&
-            nvP !== null &&
-            typeof nvP === "object" &&
-            // SameValueZero (self-sweep): strict === here broke slot
-            // alignment on NaN keys while buildRowOps retained the row —
-            // retained DOM with suppressed value ticks (the round-1 NaN
-            // staleness, in the shallow branch).
-            sameKey(keyFn(pvK), keyFn(nvP))
-          )
-            keyPrefix++;
-          else keyAligned = false;
-        }
-        // Slot-patch dispatch (shallow): a KEY-ALIGNED slot whose value was
-        // replaced by reference is a value tick — emit through the queue.
-        // Misaligned/appended slots are STRUCTURE (row ops rebuild or move
-        // them; new rows initial-apply at bind), so they emit nothing here.
-        // Keyless positional lists treat same-index replacement as the value
-        // tick for indices below the common length.
-        // `i < dlen` is load-bearing for BOTH modes: an appended position
-        // past a fully-aligned prefix (vacuously aligned when prev is empty)
-        // has no previous slot — emitting a slot tick for it races the row
-        // ops that CREATE the row (the slot queue applies first, indexing a
-        // row that does not exist yet). Equivalence-matrix finding:
-        // clear-then-refill and pure appends crashed the driver.
-        if (sp !== null && i < dlen && (keyFn === null || keyAligned)) {
-          const pvS = prevRows[i];
-          if (pvS !== nvP) rowHooks.emitSlotPatch(t, i, nvP, pvS);
-        }
         if (!shallow && i < dlen && nvP !== null && typeof nvP === "object")
           descend(unwrapValue(prevRows[i]), nvP, keyFn, fam, proj);
         if (
@@ -10004,15 +11387,6 @@ function applyAdopt(t, incoming, keyFn, proj = false) {
           }
         }
       }
-      if (ro !== null) {
-        const plen = prevRows.length;
-        if (keyFn !== null) {
-          if (keyPrefix < nlen || plen !== nlen)
-            buildAndEmitRowOps(t, prevRows, nextRows, keyPrefix, keyFn);
-        } else if (plen !== nlen) {
-          buildAndEmitRowOps(t, prevRows, nextRows, dlen, null);
-        }
-      }
     }
     if (eager) {
       if (nodes !== null && nodesHit < t.nc) {
@@ -10033,22 +11407,6 @@ function applyAdopt(t, incoming, keyFn, proj = false) {
     // slots must not notify, R9). This replaces the notifyFold re-walk that
     // doubled dbmon's diff cost. for-in covers own enumerable string keys
     // with no key-array allocation; symbols get a pass only when present.
-    // PROTOTYPE compiled-patch fast path: a pure-patch record (no nodes,
-    // no presence/key-set/deep subscribers, no family) adopts and hands the
-    // (next, prev) pair to its compiled patch — no per-key walk at all.
-    if (
-      t.pc !== null &&
-      t.pc.p !== null &&
-      eager &&
-      t.n === null &&
-      t.h === null &&
-      t.k === null &&
-      t.dk === null &&
-      fam === null
-    ) {
-      // Adoption already ran at applyAdopt entry; emission was queued there.
-      return;
-    }
     const nodes = eager ? t.n : null;
     let nodesHit = 0;
     let dkBumped = false;
@@ -10116,91 +11474,13 @@ function applyAdopt(t, incoming, keyFn, proj = false) {
 const hasOwnP = Object.prototype.hasOwnProperty;
 /** Setter-channel row ops (the fold site calls this for array targets with
  * ops consumers): structural mutation through the setter — push/splice/index
- * assignment/permutation — is a visibility transition for the list container
- * just like a reconcile walk, and drivers consuming registerRowOps must see
- * it. Setter mutations move the SAME row objects around, so RAW IDENTITY is
- * the key. Aligned arrays (value-only folds) emit nothing. */
-const identityKey = r => unwrapValue(r);
 /** Key equality for EVERY key comparison in this module (re-audit 2, P1-5):
- * SameValueZero, matching the Map-based matchers (buildRowOps, the adoption
- * window) — NaN keys are equal to themselves, so aligned NaN rows stay
- * aligned in the prefix walk instead of forever misaligning. Adoption and
- * row ops MUST agree on key equality or retained DOM rows go stale. */
+ * SameValueZero, matching the adoption window's Map-based matcher — NaN keys
+ * are equal to themselves, so aligned NaN rows stay aligned in the prefix
+ * walk instead of forever misaligning. */
 function sameKey(a, b) {
   return a === b || (a !== a && b !== b);
 }
-function emitSetterRowOps(t, prevRows, nextRows) {
-  const ops = buildIdentityRowOps(prevRows, nextRows);
-  if (ops !== null) rowHooks.emitRowOps(t, nextRows, ops);
-}
-/** Identity-keyed structural diff, returned rather than emitted: shared by
- * the setter channel (regular queue) and the OPTIMISTIC write channel (lane
- * queue) — same retention semantics, different dispatch timing. Returns
- * null when the lists are identity-aligned (no structure changed). */
-function buildIdentityRowOps(prevRows, nextRows) {
-  let p = 0;
-  const min = prevRows.length < nextRows.length ? prevRows.length : nextRows.length;
-  while (p < min && unwrapValue(prevRows[p]) === unwrapValue(nextRows[p])) p++;
-  if (p === prevRows.length && p === nextRows.length) return null;
-  return buildRowOps(prevRows, nextRows, p, identityKey);
-}
-/** Shared row-ops builder (keyed deep branch + shallow/positional branch):
- * key-matches the misaligned window into { prefix, sources, removed }.
- * `keyFn === null` degrades to positional ops (append/truncate only). */
-function buildAndEmitRowOps(t, prevRows, nextRows, structStart, keyFn) {
-  rowHooks.emitRowOps(t, nextRows, buildRowOps(prevRows, nextRows, structStart, keyFn));
-}
-function buildRowOps(prevRows, nextRows, structStart, keyFn) {
-  const plen = prevRows.length;
-  const nlen = nextRows.length;
-  const sources = new Array(nlen - structStart);
-  // Occurrence-aware matching (re-audit): duplicate keys queue their old
-  // indices and each is consumed ONCE — first-wins reuse would hand the same
-  // source (and its one DOM row) to multiple next positions. The no-dup fast
-  // shape stays a bare number; collisions upgrade to a queue.
-  let oldIndexByKey = null;
-  if (keyFn !== null && structStart < plen) {
-    oldIndexByKey = new Map();
-    for (let j = structStart; j < plen; j++) {
-      const p = unwrapValue(prevRows[j]);
-      if (p !== null && typeof p === "object") {
-        const pk = keyFn(p);
-        if (pk === undefined) continue;
-        const existing = oldIndexByKey.get(pk);
-        if (existing === undefined) oldIndexByKey.set(pk, j);
-        else if (Array.isArray(existing)) existing.push(j);
-        else oldIndexByKey.set(pk, [existing, j]);
-      }
-    }
-  }
-  const consumed = oldIndexByKey !== null ? new Set() : null;
-  for (let k = structStart; k < nlen; k++) {
-    const nv = nextRows[k];
-    let oldIdx = -1;
-    if (nv !== null && typeof nv === "object" && oldIndexByKey !== null) {
-      const nk = keyFn(nv);
-      if (nk !== undefined) {
-        const m = oldIndexByKey.get(nk);
-        if (m !== undefined) {
-          if (Array.isArray(m)) {
-            oldIdx = m.shift();
-            if (m.length === 1) oldIndexByKey.set(nk, m[0]);
-          } else {
-            oldIdx = m;
-            oldIndexByKey.delete(nk);
-          }
-          consumed.add(oldIdx);
-        }
-      }
-    }
-    sources[k - structStart] = oldIdx;
-  }
-  const removed = [];
-  for (let j = structStart; j < plen; j++) {
-    if (consumed === null || !consumed.has(j)) removed.push(unwrapValue(prevRows[j]));
-  }
-  return { prefix: structStart, sources, removed };
-}
 function descend(pv, nv, keyFn, fam, proj = false) {
   if (pv === null || typeof pv !== "object" || nv === null || typeof nv !== "object") return;
   // Lookup FIRST: a hit implies pv was wrappable and never raw-marked (only
@@ -10470,558 +11750,6 @@ function runProjectionComputedNext(wrappedStore, fn, key, wrapCommit, aroundDraf
   return owner;
 }
 
-/**
- * PR-A: the patch channel (DESIGN-PATCH-CHANNEL.md).
- *
- * Compiled patch functions — per-record compare-and-write consumers —
- * dispatched by the store's visibility transitions instead of render
- * effects. This module owns registration, the per-flush apply queue
- * (effect-phase timing, §2b), the owned-prev rule (§2c), and dispatch
- * bubbling (§4b). Emission calls live at the four visibility-transition
- * sites (adoption walk, setter notify, fold commit, override lifecycle)
- * and are gated on registration, so unpatched stores pay a null check.
- *
- * Bubbling contract: a targeted nested write reaches ancestor patches as a
- * FORCED re-apply — the third `force` argument makes every compiled compare
- * pass, so the ancestor rewrites its bound fields from its current backing
- * (idempotent, and prev-free: an ancestor's pre-state is not reconstructible
- * after in-place folds). Compiled bodies therefore have the signature
- * `(next, prev, force?)`.
- *
- * Tree-shaking: core never imports this module; stores without patches
- * never schedule the queue.
- */
-let queue = null;
-let scheduled = false;
-function drainApplyQueue() {
-  // Settle-time fallback for optimistic emissions (a reverting flush may
-  // have no active lanes left to run the lane-slot drain).
-  drainOptimistic();
-  const q = queue;
-  queue = null;
-  scheduled = false;
-  if (q === null) return;
-  // Per-entry isolation: one throwing patch must not abort its siblings
-  // (effect parity — each effect isolates its failure). A throwing patch
-  // routes through its REGISTERING OWNER's queue chain exactly like a
-  // render-effect error (§2b): an Errored boundary above the row collects
-  // it (source = the owner, error read via owner._x?._error). Unhandled errors
-  // rethrow after the drain so they still surface.
-  let firstError = UNSET;
-  for (let i = 0; i < q.length; i++) {
-    clearStamp(q[i]);
-    const { list, prev, force, t } = q[i];
-    const next = t !== null ? (t.pb ?? t.v) : q[i].next;
-    firstError = applyEntries(list, next, prev, force, firstError);
-  }
-  if (firstError !== UNSET) {
-    // Unhandled patch errors HALT like unhandled effect errors (re-audit 2,
-    // P1-4): app state is undefined past an unboundaried throw.
-    haltReactivity(firstError);
-    throw firstError;
-  }
-}
-const UNSET = Symbol();
-/** ONE callback/error primitive for every drain (normal, transition-held,
- * optimistic): per-entry isolation — a throwing patch must not abort its
- * siblings (effect parity) — and failures route through the REGISTERING
- * OWNER's queue chain exactly like a render-effect error (§2b): an Errored
- * boundary above the row collects it. Unhandled errors are aggregated by the
- * caller (first one rethrows after its drain completes). */
-function applyEntries(list, next, prev, force, firstError) {
-  // SNAPSHOT multi-consumer lists (re-audit 5, P1-3): a callback can dispose
-  // a sibling's owner, whose unbind SPLICES this same array mid-iteration —
-  // index-walking the live array skips the shifted consumer. The dominant
-  // single-consumer case pays nothing; unbound entries are marked so a
-  // snapshot never applies a consumer severed by an earlier callback.
-  const snap = list.length > 1 ? list.slice() : list;
-  for (let j = 0; j < snap.length; j++) {
-    const entry = snap[j];
-    if (entry.u === true) continue;
-    // Disposed owners drop their patches (the row unmounted mid-flush).
-    if (entry.owner !== null && isDisposed(entry.owner)) continue;
-    try {
-      entry.fn(next, prev, force);
-    } catch (err) {
-      let handled = false;
-      const owner = entry.owner;
-      if (owner !== null) {
-        // Route through the nearest COMPUTED ancestor (re-audit 2, P1-4):
-        // <Errored>.reset() recomputes its sources, and a plain owner (the
-        // list driver's listOwner) is not recomputable — the component/memo
-        // scope above it is, and recomputing it rebuilds the rows, exactly
-        // what reset means for a throwing render effect.
-        let source = owner;
-        while (source !== null && source._fn === undefined) source = source._parent;
-        source ??= owner;
-        const statusErr = new StatusError(source, err);
-        ext(source)._error = statusErr;
-        source._statusFlags = (source._statusFlags ?? 0) | STATUS_ERROR;
-        handled = owner._queue.notify(source, STATUS_ERROR, STATUS_ERROR, statusErr);
-      }
-      if (!handled && firstError === UNSET) firstError = err;
-    }
-  }
-  return firstError;
-}
-// Transition-stamped emissions (§2b, "the walk is not the visibility moment
-// inside a transition"): entries stash DIRECTLY on their transition
-// (`_heldPatches`) and release into the live queue when THAT batch commits
-// (patchCommitHook). Reverted transitions never commit — their stash drops
-// with the transition object, no revert bookkeeping. The field (rather than
-// a WeakMap) keeps the every-flush commit-hook check to one property read;
-// the ambient batch never stashes.
-let commitHookInstalled = false;
-function releaseBatch(batch) {
-  const held = batch._heldPatches;
-  if (held === undefined) return;
-  batch._heldPatches = undefined;
-  for (let i = 0; i < held.length; i++) pushLive(held[i]);
-}
-function pushLive(item) {
-  if (queue === null) queue = [];
-  queue.push(item);
-  if (!scheduled) {
-    scheduled = true;
-    globalQueue.enqueue(EFFECT_RENDER, drainApplyQueue);
-  }
-}
-function push(item) {
-  const tx = activeTransition;
-  if (tx !== null) {
-    let held = tx._heldPatches;
-    if (held === undefined) tx._heldPatches = held = [];
-    held.push(item);
-    return;
-  }
-  pushLive(item);
-}
-/** Self-entry push with SAME-BATCH COALESCING (re-audit 2/3): a record's
- * later non-forced emission into the same container UPDATES the queued
- * entry in place — `next` takes the newest capture (adoption swaps the
- * backing object per emission; dropping the later one applied STALE state),
- * `prev` keeps the batch's earliest (effect semantics: one application per
- * batch spanning the whole window). The entry's consumer list is the live
- * pc.p array, so mid-batch registrants ride the single application. Forced
- * entries and row/slot ops never coalesce; the drain clears the stamps so a
- * quiet record retains nothing from its last batch. */
-function pushSelf(pc, item) {
-  const tx = activeTransition;
-  let arr;
-  if (tx !== null) {
-    let held = tx._heldPatches;
-    if (held === undefined) tx._heldPatches = held = [];
-    arr = held;
-  } else {
-    if (queue === null) queue = [];
-    arr = queue;
-  }
-  if (pc.qa === arr && pc.qe !== null) {
-    const qe = pc.qe;
-    qe.next = item.next;
-    qe.list = item.list; // pc.p can be re-created if emptied mid-batch
-    return;
-  }
-  pc.qa = arr;
-  pc.qe = item;
-  item.pc = pc;
-  arr.push(item);
-  if (arr === queue && !scheduled) {
-    scheduled = true;
-    globalQueue.enqueue(EFFECT_RENDER, drainApplyQueue);
-  }
-}
-/** Drain-side stamp clear (re-audit 3, P2-6): without it a quiet long-lived
- * record's channel retains its last batch's container array, entry, and both
- * captured backings for the record's lifetime. */
-function clearStamp(item) {
-  const pc = item.pc;
-  if (pc !== undefined && pc.qe === item) {
-    pc.qa = null;
-    pc.qe = null;
-  }
-}
-/** Shallow clone for the owned-prev rule (§2c): owned backings fold values
- * INTO the same raw at commit, so a queued prev must be snapshotted. */
-function clonePrev(prev) {
-  return Array.isArray(prev) ? prev.slice() : { ...prev };
-}
-/**
- * Emit a record's visibility transition. Callers gate on `hasPatches()` and
- * `t.d` cheaply; this function re-checks and walks ancestors (§4b).
- */
-function emitPatch(t, next, prev) {
-  const p = t.pc !== null ? t.pc.p : null;
-  if (p !== null)
-    pushSelf(t.pc, {
-      list: p,
-      next,
-      prev: ownedRaw.has(prev) ? clonePrev(prev) : prev,
-      force: false,
-      t: null
-    });
-  // Bubbling: ancestors force-re-apply from their LIVE backing, resolved at
-  // drain (privatization may clone it between now and then).
-  let u = t.u;
-  while (u !== null) {
-    const up = u.pc !== null ? u.pc.p : null;
-    if (up !== null) push({ list: up, next: null, prev: null, force: true, t: u });
-    u = u.u;
-  }
-}
-/** Emission for sites that already stand at the record with both sides in
- * hand and have already handled ancestors (the adoption walk descends —
- * parents were visited first), so no bubbling walk. */
-function emitPatchLocal(t, next, prev) {
-  const p = t.pc !== null ? t.pc.p : null;
-  if (p !== null)
-    pushSelf(t.pc, {
-      list: p,
-      next,
-      prev: ownedRaw.has(prev) ? clonePrev(prev) : prev,
-      force: false,
-      t: null
-    });
-}
-/** Optimistic-channel emission: overrides are visible THIS flush while the
- * transaction is in flight — that is what optimism means. These ride a
- * dedicated queue drained at LANE-EFFECT timing (the regular effect queues
- * are stashed by an in-flight action), with the regular drain as the
- * settle-time fallback. `next === null` = forced re-apply from the live
- * target (the revert shape: committed truth back onto the DOM). */
-let optQueue = null;
-function drainOptimistic() {
-  const q = optQueue;
-  optQueue = null;
-  if (q === null) return;
-  // Same isolation/routing primitive as the normal drain (re-audit blocker
-  // 5): one throwing optimistic patch must not abort its siblings, and it
-  // must reach the registering owner's Errored boundary.
-  let firstError = UNSET;
-  for (let i = 0; i < q.length; i++) {
-    clearStamp(q[i]);
-    const { list, prev, force, t } = q[i];
-    const next = t !== null ? (t.pb ?? t.v) : q[i].next;
-    firstError = applyEntries(list, next, prev, force, firstError);
-  }
-  if (firstError !== UNSET) {
-    haltReactivity(firstError);
-    throw firstError;
-  }
-}
-function emitPatchOptimistic(t, next, prev) {
-  const p = t.pc !== null ? t.pc.p : null;
-  if (p === null) return;
-  if (optQueue === null) optQueue = [];
-  if (next === null) optQueue.push({ list: p, next: null, prev: null, force: true, t });
-  else {
-    // Same-batch coalescing, optimistic container (re-audit 3): later
-    // non-forced emission updates the queued entry's next in place.
-    const pc = t.pc;
-    if (pc.qa === optQueue && pc.qe !== null) {
-      const qe = pc.qe;
-      qe.next = next;
-      qe.list = p;
-    } else {
-      const item = { list: p, next, prev, force: false, t: null };
-      pc.qa = optQueue;
-      pc.qe = item;
-      item.pc = pc;
-      optQueue.push(item);
-    }
-  }
-  // Backup scheduling: the lane-slot drain covers in-flight application; a
-  // stashed regular drain guarantees settle-time application when no lane
-  // survives to the final flush (pure reverts).
-  if (!scheduled) {
-    scheduled = true;
-    globalQueue.enqueue(EFFECT_RENDER, drainApplyQueue);
-  }
-}
-/** Row-ops emission at OPTIMISTIC (lane) timing: user drafts on an
- * optimistic family must show structure IN FLIGHT — bypassing the
- * transition stash exactly like emitPatchOptimistic. Two forms:
- * - `ops` given (write site): `nextRows` is the draft's intended visible
- *   list, ops the identity diff against the pre-write optimistic view.
- * - `ops === null` (revert site): RESYNC — the consumer rebuilds retention
- *   by row identity against the live post-revert view, resolved from the
- *   target at drain time (overrides are gone by then, so `pb ?? v` IS the
- *   committed truth). */
-function emitRowOpsOptimistic(t, nextRows, ops) {
-  const list = t.pc !== null ? t.pc.ro : null;
-  if (list === null) return;
-  if (optQueue === null) optQueue = [];
-  optQueue.push({
-    list: list.map(e => ({
-      owner: e.owner,
-      fn: (n, _p) => e.fn(n, ops)
-    })),
-    next: nextRows,
-    prev: null,
-    force: false,
-    t: nextRows === null ? t : null
-  });
-  if (!scheduled) {
-    scheduled = true;
-    globalQueue.enqueue(EFFECT_RENDER, drainApplyQueue);
-  }
-}
-/**
- * Register a compiled patch on a store record. Multi-consumer (two lists
- * can render one record); owner-scoped for disposal. Returns unbind.
- */
-// Global registration count: the cheap gate emission sites check before any
-// per-record work (unpatched apps pay one number compare per transition).
-let patchCount = 0;
-function hasPatches() {
-  return patchCount > 0;
-}
-function registerPatch(record, fn) {
-  let t = record?.[$TARGET];
-  if (t === undefined) throw new Error("registerPatch: not a store record");
-  // Chained backings (§7b): register on the ULTIMATE owner — that is where
-  // value transitions fold and dispatch; the wrapper's identity is stable
-  // and would never fire (see ultimateTarget).
-  t = ultimateTarget(t) ?? t;
-  if (!commitHookInstalled) {
-    commitHookInstalled = true;
-    armPatchHooks();
-    setPatchCommitHook(releaseBatch);
-    GlobalQueue._drainPatchOptimistic = drainOptimistic;
-  }
-  const entry = { fn, owner: getOwner() };
-  const pc = pcOf(t);
-  const list = (pc.p ??= []);
-  list.push(entry);
-  patchCount++;
-  // Bindings are subscriptions for reachability (§6d pruning must descend
-  // into bound records).
-  markDescendants(t);
-  let unbound = false;
-  return () => {
-    if (unbound) return;
-    unbound = true;
-    entry.u = true; // dispatch snapshots skip severed consumers
-    // Decrement ONLY on actual removal: a demotion (demoteToEffects) may
-    // have already pulled this entry and repaired the count — the splice
-    // miss is how this closure learns that.
-    const idx = list.indexOf(entry);
-    if (idx >= 0) {
-      list.splice(idx, 1);
-      patchCount--;
-    }
-    if (list.length === 0 && pc.p === list) pc.p = null;
-  };
-}
-/** Resolve a target through CHAINED backings (§7b) to the ultimate owner.
- * A projection family wrapper's backing IS another store's proxy: value
- * transitions fold on the ULTIMATE target (the wrapper's identity never
- * changes), so patch registration and raw resolution must land there or
- * registered patches never fire (equivalence-matrix finding: projection
- * value ticks froze driver rows while classic effects tracked through). */
-function ultimateTarget(t) {
-  while (t.ch) {
-    const u = (t.pb ?? t.v)?.[$TARGET];
-    if (u === undefined) return undefined;
-    t = u;
-  }
-  return t;
-}
-/** Dual-driver bind probe (compiler runtime contract): when `record` is a
- * patchable store record, returns its CURRENT raw backing (the driver's
- * initial force-apply reads it directly — no proxy traffic, no tracking);
- * returns undefined otherwise (driver falls back to the effect path).
- * Not patchable: non-records, non-proxies, accessor-bearing records
- * (patches read raw — getters need tracked evaluation), broken chains. */
-function patchableRaw(record) {
-  let t = record?.[$TARGET];
-  if (t === undefined || t.px !== record || t.a === true) return undefined;
-  t = ultimateTarget(t);
-  // SCAN before trusting (re-audit blocker 3): `a` starts false and is only
-  // discovered lazily (first draft, deep walks) — admission must run the
-  // one-time own-accessor scan itself, or a getter-bearing record takes the
-  // patch path and its getter's OUTSIDE dependencies (signals, other
-  // records) never re-apply. Sticky `sc` makes this one probe pass per
-  // record lifetime.
-  if (t === undefined || !targetIsPlain(t)) return undefined;
-  return t.pb ?? t.v;
-}
-/** Accessor demotion (design §5): a record that acquires an accessor after
- * registration stops being patchable — reads must go through tracked
- * evaluation. Clears patches and repairs the global count; callers re-drive
- * the pulled bodies (demoteToEffects). */
-function demotePatches(t) {
-  if (t.pc === null) return null;
-  const p = t.pc.p;
-  t.pc.p = null;
-  if (p === null) return null;
-  patchCount -= p.length;
-  // Drain IN PLACE: unbind closures captured this array — a late unbind must
-  // miss its indexOf and not double-decrement the repaired count.
-  return p.splice(0, p.length);
-}
-/** The demotion re-drive (re-audit blocker 3): each pulled body becomes the
- * SAME dual-driver effect fallback the web runtime would have chosen had the
- * record carried the accessor at bind — a tracked compute pass (next === prev
- * short-circuits every compare into a pure read THROUGH THE PROXY, so getter
- * dependencies track) plus an untracked force-apply at effect timing.
- *
- * Creation is DEFERRED to the effect phase: the trap that discovers the
- * accessor runs mid-draft, and an effect's initial pass must not read
- * through the proxy inside the write window. The record's own transition
- * for that draft is covered by the new effect's initial force-apply.
- *
- * Known edge (documented): a demoted LIST-ROW body re-drives under its
- * registering owner (the list owner), so per-row severing on removal is
- * lost for demoted rows — the effect lives until the LIST disposes. Rows
- * only demote when user code defines an accessor on a row record at
- * runtime. */
-function demoteToEffects(t) {
-  const entries = demotePatches(t);
-  if (entries === null || entries.length === 0) return;
-  const proxy = t.px;
-  globalQueue.enqueue(EFFECT_RENDER, () => {
-    for (let i = 0; i < entries.length; i++) {
-      const entry = entries[i];
-      if (entry.owner !== null && isDisposed(entry.owner)) continue;
-      const fn = entry.fn;
-      runWithOwner(entry.owner, () =>
-        createRenderEffect(
-          () => {
-            fn(proxy, proxy, false);
-          },
-          () => {
-            // Block body: a compiled patch body's return value must not be
-            // mistaken for an effect cleanup.
-            untrack(() => fn(proxy, undefined, true));
-          }
-        )
-      );
-    }
-  });
-}
-/** Register a structural-ops consumer on a keyed store array (the list
- * container's channel — what `For` consumes through the seam). */
-function registerRowOps(array, fn) {
-  let t = array?.[$TARGET];
-  if (t === undefined) throw new Error("registerRowOps: not a store array");
-  // Chained backings resolve to the ULTIMATE owner, same as registerPatch
-  // (§7b) — the walk/fold emits there (re-audit blocker 4).
-  t = ultimateTarget(t) ?? t;
-  armRowHooks();
-  if (!commitHookInstalled) {
-    commitHookInstalled = true;
-    armPatchHooks();
-    setPatchCommitHook(releaseBatch);
-    GlobalQueue._drainPatchOptimistic = drainOptimistic;
-  }
-  const entry = { fn, owner: getOwner() };
-  const pc = pcOf(t);
-  const list = (pc.ro ??= []);
-  list.push(entry);
-  patchCount++;
-  markDescendants(t);
-  let unbound = false;
-  return () => {
-    if (unbound) return;
-    unbound = true;
-    patchCount--;
-    const idx = list.indexOf(entry);
-    if (idx >= 0) list.splice(idx, 1);
-    if (list.length === 0 && pc.ro === list) pc.ro = null;
-  };
-}
-/** Slot patches (shallow arrays) ride the same apply queue: the walk emits
- * per aligned value-replaced slot; application happens at effect phase under
- * the registration owner's lifetime. */
-function emitSlotPatch(t, index, next, prev) {
-  const sp = t.pc !== null ? t.pc.sp : null;
-  if (sp === null) return;
-  push({
-    list: sp.map(e => ({ owner: e.owner, fn: () => e.fn(index, next, prev) })),
-    next,
-    prev,
-    force: false,
-    t: null
-  });
-}
-/** Slot patch for shallow arrays: the reconcile walk emits (index, next,
- * prev) for KEY-ALIGNED value-replaced slots (structure rides row ops), and
- * the emission queues through the patch apply queue — effect-phase timing,
- * transition stamping, disposed-owner drop — like every other channel. */
-function registerSlotPatchNext(arr, fn) {
-  let t = arr?.[$TARGET];
-  if (t === undefined) throw new Error("registerSlotPatchNext: not a store array");
-  // Chained backings resolve to the ULTIMATE owner, same as registerPatch
-  // (§7b) — the walk emits slot ticks there (re-audit blocker 4).
-  t = ultimateTarget(t) ?? t;
-  armRowHooks();
-  if (!commitHookInstalled) {
-    commitHookInstalled = true;
-    armPatchHooks();
-    setPatchCommitHook(releaseBatch);
-    GlobalQueue._drainPatchOptimistic = drainOptimistic;
-  }
-  // Multi-consumer (external audit): one shallow array can drive several
-  // lists — registrations are a list, unbinds splice their own entry.
-  const pc = pcOf(t);
-  const entry = { fn, owner: getOwner() };
-  (pc.sp ??= []).push(entry);
-  markDescendants(t);
-  let unbound = false;
-  return () => {
-    if (unbound || pc.sp === null) return;
-    unbound = true;
-    const idx = pc.sp.indexOf(entry);
-    if (idx >= 0) pc.sp.splice(idx, 1);
-    if (pc.sp.length === 0) pc.sp = null;
-  };
-}
-/** Row-ops ride the SAME apply queue/timing as record patches: transition-
- * stamped, applied at effect phase, in emission order (structure before the
- * new rows' own patches can exist; retained rows' value patches commute). */
-function emitRowOps(t, next, ops) {
-  const list = t.pc !== null ? t.pc.ro : null;
-  if (list === null) return;
-  push({
-    list: list.map(e => ({
-      owner: e.owner,
-      fn: (n, _p) => e.fn(n, ops)
-    })),
-    next,
-    prev: null,
-    force: false,
-    t: null
-  });
-}
-// Pay-for-use seams: the write paths (store/reconcile/optimistic) emit
-// through installed hooks instead of importing this module. Installation is
-// LAZY (first registration) rather than a module-scope call — the dist is a
-// flat bundle, and a top-level side effect would retain the whole channel in
-// every consumer. TWO TIERS so a value-only registration (registerPatch —
-// present in ~every bundle under patch-mode default) does not retain the
-// list machinery (row-ops emitters + reconcile's diff builders): row hooks
-// arm only from the list driver's registrations. Sound because every
-// emission site is guarded by the matching pc channel, which only the
-// corresponding registration creates. See patch-hooks.ts.
-function armPatchHooks() {
-  installPatchHooks({
-    emitPatch,
-    emitPatchLocal,
-    emitPatchOptimistic,
-    hasPatches,
-    demoteToEffects
-  });
-}
-function armRowHooks() {
-  installRowHooks({
-    emitRowOps,
-    emitSlotPatch,
-    emitSetterRowOps,
-    emitRowOpsOptimistic
-  });
-}
-
 /**
  * Store rewrite — optimistic stores (§3/§7, RUL-3): no store-side layer, no
  * backup snapshots. Nodes in an optimistic family are ARMED core signals
@@ -11075,20 +11803,11 @@ function installNextBlockedHalf() {
   // so the hook only empties the batch set.
   if (!GlobalQueue._clearOptimisticStores) {
     GlobalQueue._clearOptimisticStores = stores => {
-      // Patch channel (revert site): engine-native reverts flip node values
-      // back to committed; patched records need a forced DOM re-apply from
-      // the post-revert view. Emission only — next keeps no layer to clear.
       for (const px of stores) {
         const t = px?.[$TARGET];
         const overlaid = t?.fam?.overlaid;
         if (overlaid !== undefined) {
           for (const ot of overlaid) {
-            if (ot.pc !== null && ot.pc.p !== null) patchHooks.emitPatchOptimistic(ot, null, null);
-            // Row-ops resync (family increment 2): reverts flip node values
-            // back engine-natively; a driven list must rebuild retention by
-            // row identity against the post-revert view (resolved from the
-            // target at drain — overrides are gone by then).
-            if (ot.pc !== null && ot.pc.ro !== null) rowHooks.emitRowOpsOptimistic(ot, null, null);
             // Keyset resync (classic channel twin): the keyset node's own
             // revert can compare EQUAL (a landing's bump matched the
             // tentative bump) while the arrangement underneath changed —
@@ -11147,13 +11866,13 @@ function familyHasLiveOverrides(fam) {
   overlaid.clear(); // nothing live — drop the bookkeeping
   return false;
 }
-function createOptimisticStoreNext(first, second, options) {
+function createOptimisticStoreNext(first, second, third) {
   // Engine first (armed nodes need optimisticWrite installed before any
   // node exists), then the next-shape hooks.
   installOptimisticEngine();
   installNextBlockedHalf();
   const derived = typeof first === "function";
-  if (!derived && options === undefined) options = second;
+  const options = derived ? third : second;
   const initialValue = derived ? second : first;
   const fam = {
     map: new WeakMap(),
@@ -11242,7 +11961,16 @@ function createOptimisticStoreNext(first, second, options) {
         if (!self._loading) fam.ft = null;
         return;
       }
-      if (self._loading) return;
+      // First flight (#3146 carve-out): nothing has ever committed, so there
+      // is no truth to keep on screen and no optimistic state to protect. An
+      // uninitialized ask suspends its readers into their Loading boundary
+      // exactly like a plain derived store's first flight — declaring a
+      // transaction here instead held the ROOT MOUNT (render()'s scheduled
+      // insert rides transitions) until the fetch landed, so the boundary's
+      // fallback never showed and the whole page stayed blank. The loading
+      // window (#2933) already declares nothing for the same reason; once
+      // the first truth lands, every refetch flight declares as before.
+      if (self._loading || self._statusFlags & STATUS_UNINITIALIZED) return;
       let txn = activeTransition;
       if (txn === null) globalQueue.initTransition((txn = createTransition()));
       fam.ft = txn;
@@ -11482,22 +12210,6 @@ function notifyOptimisticWrites(t, pb) {
     if (ft !== null) globalQueue.initTransition(ft);
   }
   const old = t.v;
-  // Patch channel (override-application site): the draft IS the intended
-  // visible state; prev is the view before these overrides apply. Bypasses
-  // the transition stash — optimism is visible in flight.
-  if (t.pc !== null && t.pc.p !== null)
-    patchHooks.emitPatchOptimistic(t, pb, optimisticView(t, old));
-  // Row-ops channel (family increment 2): optimistic STRUCTURE on an array
-  // rides node overrides — it never enters the reconcile walk — so a driven
-  // list must get its structural ops here, lane-timed. Identity diff of the
-  // pre-write optimistic view against the draft; aligned writes emit nothing.
-  if (t.pc !== null && t.pc.ro !== null && Array.isArray(pb)) {
-    const prevView = optimisticView(t, old);
-    if (Array.isArray(prevView)) {
-      const ops = buildIdentityRowOps(prevView, pb);
-      if (ops !== null) rowHooks.emitRowOpsOptimistic(t, pb, ops);
-    }
-  }
   const visible = (key, fallback) => {
     const node = t.n?.[key];
     return node !== undefined && hasActiveOverride(node)
@@ -11595,7 +12307,12 @@ function applyTentative(t, incoming, keyFn) {
   const isArr = Array.isArray(incoming);
   if (Array.isArray(view) !== isArr) return; // kind change at root: flat overrides below
   const pairs = [];
-  const pbLike = isArr ? [...incoming] : shallowWithSymbols(incoming);
+  let pbLike;
+  if (isArr) pbLike = [...incoming];
+  else {
+    pbLike = {};
+    for (const k of Reflect.ownKeys(incoming)) pbLike[k] = incoming[k];
+  }
   const match = (pv, nv) => {
     if (!isWrappable(pv) || !isWrappable(nv)) return null;
     if (rawValuesUsed && (isRawValue(pv) || isRawValue(nv))) return null;
@@ -11674,11 +12391,6 @@ function applyTentative(t, incoming, keyFn) {
   for (let i = 0; i < pairs.length; i++)
     applyTentative(pairs[i][0], unwrapValue(pairs[i][1]), keyFn);
 }
-function shallowWithSymbols(src) {
-  const out = {};
-  for (const k of Reflect.ownKeys(src)) out[k] = src[k];
-  return out;
-}
 
 const DELETE = Symbol("STORE_PATH_DELETE");
 function isPrototypePollutionKey(part) {
@@ -12018,7 +12730,10 @@ function mapArray(list, map, options) {
     _byIndex: options?.keyed === false,
     _fallback: options?.fallback
   };
-  const node = computed(updateKeyedMap.bind(data));
+  const node = computed(
+    updateKeyedMap.bind(data),
+    options?.name ? { name: options.name } : undefined
+  );
   // Untracked reads inside the internal owner resolve via _parentComputed; routing
   // them through node lets store-proxy lookups see pending writes (not stale _value).
   data._owner._parentComputed = node;
@@ -12106,7 +12821,19 @@ function updateKeyedMap() {
       this._items = newItems.slice(0);
       this._len = newLen;
     } else {
-      let start, end, newEnd, item, key, newIndices, newIndicesNext, removed, created;
+      let start,
+        end,
+        newEnd,
+        item,
+        key,
+        newIndices,
+        newIndicesNext,
+        removed,
+        created,
+        // Dev (attribution engine installed): the items behind the exited and
+        // entered rows, for the list-identity census.
+        removedItems,
+        createdItems;
       // skip common prefix
       for (
         start = 0, end = Math.min(this._len, newLen);
@@ -12164,13 +12891,17 @@ function updateKeyedMap() {
           indexes && (indexes[j] = this._indexes[i]);
           j = newIndicesNext[j];
           newIndices.set(key, j);
-        } else (removed ??= []).push(this._nodes[i]);
+        } else {
+          (removed ??= []).push(this._nodes[i]);
+          if (true && attrHooks !== null) (removedItems ??= []).push(item);
+        }
       }
       // 2) create new rows into the temp arrays; an abort disposes only these
       try {
         for (j = start; j <= newEnd; j++) {
           if (tempNodes[j] !== undefined) continue;
           (created ??= []).push((tempNodes[j] = createOwner()));
+          if (true && attrHooks !== null) (createdItems ??= []).push(newItems[j]);
           temp[j] = runWithOwner(tempNodes[j], mapper);
         }
       } catch (err) {
@@ -12210,6 +12941,14 @@ function updateKeyedMap() {
       // save a copy of the mapped items for the next update
       this._items = newItems.slice(0);
       if (removed) for (i = 0; i < removed.length; i++) removed[i].dispose();
+      if (true && attrHooks !== null && removedItems !== undefined && createdItems !== undefined)
+        attrHooks.listChurn(
+          this._owner._parentComputed,
+          removedItems,
+          createdItems,
+          newLen,
+          this._key !== undefined
+        );
     }
   });
   return this._mappings;
@@ -12588,7 +13327,11 @@ class CollectionQueue extends Queue {
       if (source) {
         const wasEmpty = this._sources.size === 0;
         this._sources.add(source);
-        if (wasEmpty) setSignal(this._disabled, true);
+        if (wasEmpty) {
+          setSignal(this._disabled, true);
+          if (attrHooks !== null && this._collectionType & STATUS_PENDING)
+            attrHooks.boundaryFallback(this, this._tree, true);
+        }
         if (this._collectionType & STATUS_ERROR) {
           setSignal(this._error, unwrapStatusError(source._x?._error));
         }
@@ -12624,6 +13367,8 @@ class CollectionQueue extends Queue {
       }
       if (!this._pending) {
         setSignal(this._disabled, false);
+        if (attrHooks !== null && this._collectionType & STATUS_PENDING)
+          attrHooks.boundaryFallback(this, this._tree, false);
         if (this._onFn) {
           try {
             this._prevOn = untrack(() => this._onFn());
@@ -12640,14 +13385,15 @@ function createCollectionBoundary(type, fn, fallback, onFn) {
   if (!getOwner()) {
     const message =
       "[NO_OWNER_BOUNDARY] Boundaries created outside a reactive context will never be disposed.";
-    emitDiagnostic({
-      code: "NO_OWNER_BOUNDARY",
-      kind: "lifecycle",
-      severity: "warn",
-      message,
-      data: { boundaryType: type === STATUS_PENDING ? "loading" : "error" }
-    });
-    console.warn(message);
+    reportDiagnostic(
+      emitDiagnostic({
+        code: "NO_OWNER_BOUNDARY",
+        kind: "lifecycle",
+        severity: "warn",
+        message,
+        data: { boundaryType: type === STATUS_PENDING ? "loading" : "error" }
+      })
+    );
   }
   const owner = createOwner();
   if (_revealUsed) setContext(RevealControllerContext, null, owner);
@@ -12958,13 +13704,9 @@ export {
   omit,
   onCleanup,
   onSettled,
-  patchableRaw,
   peekNextChildId,
   reconcile,
   refresh,
-  registerPatch,
-  registerRowOps,
-  registerSlotPatchNext as registerSlotPatch,
   releaseSnapshotScope,
   repeat,
   resetErrorHalt,