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

package/dist/dev.js

@@ -75,6 +75,15 @@ const REACTIVE_MANUAL_WRITE = 1 << 10;
  * pending window does not read as pending (question-scoped pending model).
  */
 const REACTIVE_REASK = 1 << 11;
+/**
+ * A dependency write landed while this subscriber was mid-recompute — a
+ * nested pull committed beneath one of its reads (#3037). The heap refuses
+ * RECOMPUTING nodes, so recompute's tail consumes this latch and reschedules:
+ * values the pass read before the nested commit are stale. Only set for
+ * links validated this pass (gen-current): a write to an untouched link is
+ * either re-read later in the pass (fresh) or trimmed with it (not a dep).
+ */
+const REACTIVE_MISSED_WAKE = 1 << 12;
 // Static configuration bits packed into Owner/Computed/Signal _config.
 const CONFIG_OWNED_WRITE = 1 << 0;
 const CONFIG_NO_SNAPSHOT = 1 << 1;
@@ -83,6 +92,31 @@ const CONFIG_IN_SNAPSHOT_SCOPE = 1 << 3;
 const CONFIG_CHILDREN_FORBIDDEN = 1 << 4;
 const CONFIG_AUTO_DISPOSE = 1 << 5;
 const CONFIG_SYNC = 1 << 6;
+// Presence bits (stage-3 hot-path monomorphism, DESIGN-PATCH-CHANNEL §11b):
+// optional per-node slots (_overrideValue, _pendingSignal/_latestValueComputed,
+// _snapshotValue, _optimisticLane) are NOT part of every node's hidden class —
+// reading a missing property defeats V8's inline caches on the hottest write/
+// notify loops. These bits live on the always-present `_config` so hot paths
+// pay one monomorphic masked read and only touch the optional field when its
+// installer flagged it. Bits are STICKY ("may be set") — the guarded field
+// read remains authoritative.
+const CONFIG_OPTIMISTIC = 1 << 7;
+const CONFIG_HAS_COMPANIONS = 1 << 8;
+const CONFIG_HAS_SNAPSHOT = 1 << 9;
+const CONFIG_HAS_LANE = 1 << 10;
+/** Set on a FIREWALL computed when any of its child signals creates an
+ * isPending()/latest() companion. Gates the post-recompute child-companion
+ * walk (#3038): a store computed's `_child` chain holds one node per
+ * materialized leaf, so walking it unconditionally makes every update cost
+ * O(all leaves ever read). Sticky — set at companion creation, never
+ * cleared; sync-only apps never set it and never pay the walk. */
+const CONFIG_CHILD_COMPANIONS = 1 << 11;
+/** Set on a computed when its first firewall child signal is installed
+ * (projection machinery). Gates markNode's firewall-children walk with one
+ * masked read of the always-present _config — the walk's old `_child` read
+ * moved into the cold extension (§12), and an unconditional `_x` deref per
+ * marked node measurably taxed the propagation hot path (diamond -22%). */
+const CONFIG_FW_CHILDREN = 1 << 12;
 const STATUS_PENDING = 1 << 0;
 const STATUS_ERROR = 1 << 1;
 const STATUS_UNINITIALIZED = 1 << 2;
@@ -117,6 +151,559 @@ const defaultContext = {};
  */
 const $REFRESH = Symbol("refresh");
 
+let attrHooks = null;
+function setAttributionHooks(hooks) {
+  attrHooks = hooks;
+}
+
+let changeSeq = 0;
+let runSeq = 0;
+const defaultOptions = {
+  log: true,
+  stacks: false,
+  historyLimit: 200,
+  hotRuns: { count: 120, windowMs: 1000 },
+  wideDeps: 30,
+  hotTime: { budgetMs: 8, windowMs: 1000 },
+  unstableMemos: 4,
+  wideWrites: 250
+};
+let options = { ...defaultOptions };
+const listeners = new Set();
+let history = [];
+const now = typeof performance !== "undefined" ? () => performance.now() : () => Date.now();
+const frames = [];
+const scopeCosts = new Map();
+const writeCosts = new Map();
+function rootsOf(causes, out) {
+  for (const c of causes) {
+    if (c.kind === "derived" && c.causes && c.causes.length > 0) rootsOf(c.causes, out);
+    else out.add(c.name);
+  }
+}
+function recordCosts(event) {
+  let scope = scopeCosts.get(event.node);
+  if (scope === undefined) {
+    scope = {
+      name: event.nodeName,
+      kind: event.nodeKind,
+      runs: 0,
+      selfMs: 0,
+      wastedMs: 0,
+      overlayMs: 0
+    };
+    scopeCosts.set(event.node, scope);
+  }
+  scope.runs++;
+  scope.selfMs += event.selfMs;
+  if (event.phase !== "plain") scope.overlayMs += event.selfMs;
+  else if (!event.changed && !event.held) scope.wastedMs += event.selfMs;
+  const roots = new Set();
+  rootsOf(event.causes, roots);
+  for (const name of roots) {
+    let write = writeCosts.get(name);
+    if (write === undefined) writeCosts.set(name, (write = { name, runs: 0, downstreamMs: 0 }));
+    write.runs++;
+    write.downstreamMs += event.selfMs;
+  }
+}
+function nodeName(node) {
+  return node._name ?? "anonymous";
+}
+function preview(v) {
+  if (v === null) return "null";
+  switch (typeof v) {
+    case "undefined":
+      return "undefined";
+    case "string":
+      return JSON.stringify(v.length > 40 ? v.slice(0, 40) + "…" : v);
+    case "number":
+    case "boolean":
+    case "bigint":
+      return String(v);
+    case "function":
+      return "[function]";
+    case "symbol":
+      return v.toString();
+    default:
+      return Array.isArray(v) ? `Array(${v.length})` : `[${v.constructor?.name ?? "object"}]`;
+  }
+}
+function captureStack() {
+  if (!options.stacks) return undefined;
+  const raw = new Error().stack?.split("\n") ?? [];
+  // Drop the message line and every frame inside the reactive core; the first
+  // remaining frames are the user code that performed the write.
+  return raw
+    .slice(1)
+    .filter(line => !/(?:^|[/\\])(?:packages[/\\])?signals[/\\](src|dist)[/\\]/.test(line))
+    .slice(0, 3)
+    .map(line => line.trim());
+}
+/** Sentinel for "no value transition to record" (refresh() stamps). */
+const NO_VALUES = Symbol("no-values");
+/** Record a root change (setSignal / refresh / async landing) on the node. */
+/**
+ * Written-fan-out warning — the write-time complement of the always-on
+ * HUGE_FAN_OUT link-time warning (see dev.ts). Static fan-out that never
+ * writes is harmless; a committed root invalidation reaching hundreds of
+ * subscribers re-runs all of them this flush. Uses the dev-maintained
+ * `_subCount` from the graph-size diagnostics — no core sites touched.
+ * Once per node; re-warns only when the subscriber count has doubled since
+ * the last warning, so it cannot spam alongside HUGE_FAN_OUT's own
+ * 2000-and-up milestones.
+ */
+function checkWideWrite(node, kind) {
+  const limit = options.wideWrites;
+  if (typeof limit !== "number") return;
+  const subs = node._subCount ?? 0;
+  const attributed = node;
+  if (subs < limit || subs < (attributed._devWideWriteWarnedAt ?? 0) * 2) return;
+  attributed._devWideWriteWarnedAt = subs;
+  const verb =
+    kind === "refresh" ? "refresh of" : kind === "async" ? "async landing on" : "write to";
+  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);
+}
+function stampWrite(node, kind, prev = NO_VALUES, value = NO_VALUES) {
+  const record = { seq: ++changeSeq, kind, name: nodeName(node) };
+  if (value !== NO_VALUES) {
+    record.prev = prev === NO_VALUES ? undefined : preview(prev);
+    record.value = preview(value);
+  }
+  record.stack = captureStack();
+  node._devChange = record;
+  // stampWrite is the single funnel for committed root invalidations (sync
+  // writes, refresh(), async landings), which makes it the one place the
+  // written-fan-out check needs to live.
+  checkWideWrite(node, kind);
+}
+/** Record a derived change (memo produced a new value) with its causes. */
+function stampDerived(node, causes) {
+  node._devChange = {
+    seq: ++changeSeq,
+    kind: "derived",
+    name: nodeName(node),
+    causes
+  };
+}
+/**
+ * Collect the deps whose committed change is newer than this node's previous
+ * run. Called at recompute entry, while `_deps` still holds the previous
+ * run's links. A refresh() stamp on the node itself also counts — that is a
+ * self-invalidation, not a dep change.
+ */
+function collectCauses(el) {
+  const seen = el._devSeenSeq ?? 0;
+  const causes = [];
+  const self = el._devChange;
+  if (self !== undefined && self.seq > seen && self.kind === "refresh") causes.push(self);
+  for (let l = el._deps; l !== null; l = l._nextDep) {
+    const change = l._dep._devChange;
+    if (change !== undefined && change.seq > seen) causes.push(change);
+  }
+  return causes;
+}
+/** Advance the node's seen-cursor to the present. Call after every run. */
+function markSeen(el) {
+  el._devSeenSeq = changeSeq;
+}
+/** Snapshot the node's current dep identities (call before a run replaces them). */
+function captureDeps(el) {
+  const deps = [];
+  for (let l = el._deps; l !== null; l = l._nextDep) deps.push(l._dep);
+  return deps;
+}
+/**
+ * Wide-scope warning — the coarse-read / helper-leak signature: one scope
+ * subscribed to dozens of sources re-runs when ANY of them change. Fired from
+ * recordRerun for re-runs and directly from recompute for creation runs (a
+ * memo can be born too wide). Re-warns only on 50% further growth.
+ */
+function checkDepWidth(el) {
+  const limit = options.wideDeps;
+  if (limit === false) return;
+  let count = 0;
+  const names = [];
+  for (let l = el._deps; l !== null; l = l._nextDep) {
+    count++;
+    if (names.length < 12) names.push(nodeName(l._dep));
+  }
+  const node = el;
+  if (count < limit || count < (node._devWideWarnedAt ?? 0) * 1.5) return;
+  node._devWideWarnedAt = count;
+  const kind = el._type ? "effect" : "memo";
+  const message =
+    `[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);
+}
+/**
+ * Hot-scope warning — flags a scope that re-ran more than `count` times
+ * inside one `windowMs` window. Warned once per window, with the most recent
+ * cause chain named so the leaking signal is identified in the message.
+ */
+function checkHotRuns(el, event) {
+  const cfg = options.hotRuns;
+  if (cfg === false) return;
+  const node = el;
+  const now = Date.now();
+  if (node._devWinStart === undefined || now - node._devWinStart > cfg.windowMs) {
+    node._devWinStart = now;
+    node._devWinCount = 0;
+    node._devHotWarned = false;
+  }
+  node._devWinCount = (node._devWinCount ?? 0) + 1;
+  if (node._devHotWarned || node._devWinCount < cfg.count) return;
+  node._devHotWarned = true;
+  const rootCause = event.causes.map(c => `"${c.name}" (${c.kind})`).join(", ");
+  const message =
+    `[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);
+}
+/**
+ * Time-budget warning — the counterpart of checkHotRuns for the
+ * few-but-expensive scope: warns when one scope's summed self-time within a
+ * window exceeds the budget. Warned once per window.
+ */
+function checkHotTime(el, event) {
+  const cfg = options.hotTime;
+  if (cfg === false) return;
+  const node = el;
+  const at = now();
+  if (node._devTimeWinStart === undefined || at - node._devTimeWinStart > cfg.windowMs) {
+    node._devTimeWinStart = at;
+    node._devTimeWinMs = 0;
+    node._devTimeWarned = false;
+  }
+  node._devTimeWinMs = (node._devTimeWinMs ?? 0) + event.selfMs;
+  if (node._devTimeWarned || node._devTimeWinMs < cfg.budgetMs) return;
+  node._devTimeWarned = true;
+  const rootCause = event.causes.map(c => `"${c.name}" (${c.kind})`).join(", ");
+  const message =
+    `[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);
+}
+function recordRerun(el, causes, prevDeps, timing, changed, phase, held) {
+  const node = el;
+  // Subscription diff: `prevDeps` was captured at run entry; `_deps` now
+  // holds the fresh set. A changed set is the "helper edit changed distant
+  // call sites" signal — surfaced per-event and in the console format.
+  const newDeps = captureDeps(el);
+  const prevSet = new Set(prevDeps);
+  const newSet = new Set(newDeps);
+  const depsAdded = [];
+  const depsRemoved = [];
+  for (const d of newDeps) if (!prevSet.has(d)) depsAdded.push(nodeName(d));
+  for (const d of prevDeps) if (!newSet.has(d)) depsRemoved.push(nodeName(d));
+  const event = {
+    run: ++runSeq,
+    nodeRuns: (node._devRunCount = (node._devRunCount ?? 0) + 1),
+    nodeKind: el._type ? "effect" : "memo",
+    nodeName: nodeName(el),
+    node: el,
+    causes,
+    depCount: newDeps.length,
+    depsAdded,
+    depsRemoved,
+    selfMs: timing.selfMs,
+    totalMs: timing.totalMs,
+    changed,
+    phase,
+    held
+  };
+  history.push(event);
+  if (history.length > options.historyLimit) history.shift();
+  recordCosts(event);
+  checkHotRuns(el, event);
+  checkHotTime(el, event);
+  checkDepWidth(el);
+  for (const listener of listeners) listener(event);
+  if (options.log) console.log(formatRerun(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}`;
+  out.push(line);
+  if (cause.stack) for (const frame of cause.stack) out.push(`${pad}    ${frame}`);
+  if (cause.causes && depth < 10) {
+    for (const upstream of cause.causes) formatCause(upstream, depth + 1, out);
+  }
+}
+function formatRerun(event) {
+  const out = [
+    `[why-run] ${event.nodeKind} "${event.nodeName}" ran (run ${event.nodeRuns}, ` +
+      `${event.selfMs.toFixed(2)}ms${event.changed ? "" : ", unchanged"}` +
+      `${event.phase === "plain" ? "" : `, ${event.phase}`}${event.held ? ", held" : ""})` +
+      (event.causes.length === 0 ? " — no tracked cause (pull or retry)" : "")
+  ];
+  for (const cause of event.causes) formatCause(cause, 0, out);
+  if (event.depsAdded.length > 0 || event.depsRemoved.length > 0) {
+    const delta = [
+      ...event.depsAdded.map(n => `+"${n}"`),
+      ...event.depsRemoved.map(n => `-"${n}"`)
+    ].join(" ");
+    out.push(`  deps changed: ${delta} (${event.depCount} total)`);
+  }
+  return out.join("\n");
+}
+/**
+ * Values eligible for the unstable-output check: plain objects and arrays
+ * only. Promises, iterators, Dates, Maps, class instances etc. all have no
+ * (or unrepresentative) own enumerable keys, so a shallow compare would
+ * false-positive on them — a fresh Promise is a genuinely new value.
+ */
+function isPlainShape(v) {
+  if (v === null || typeof v !== "object") return false;
+  if (Array.isArray(v)) return true;
+  const proto = Object.getPrototypeOf(v);
+  return proto === Object.prototype || proto === null;
+}
+/** Shallow structural equivalence, capped so hot paths stay cheap. */
+const UNSTABLE_KEY_CAP = 64;
+function shallowEquivalent(a, b) {
+  const aArr = Array.isArray(a);
+  if (aArr !== Array.isArray(b)) return false;
+  if (aArr) {
+    const arrA = a;
+    const arrB = b;
+    if (arrA.length !== arrB.length || arrA.length > UNSTABLE_KEY_CAP) return false;
+    for (let i = 0; i < arrA.length; i++) if (arrA[i] !== arrB[i]) return false;
+    return true;
+  }
+  const keys = Object.keys(a);
+  if (keys.length > UNSTABLE_KEY_CAP || keys.length !== Object.keys(b).length) return false;
+  for (const key of keys) {
+    if (!(key in b) || a[key] !== b[key]) return false;
+  }
+  return true;
+}
+/**
+ * Unstable-output warning — the fan-out amplifier signature: a memo whose
+ * committed value is referentially new but structurally identical run after
+ * run has an equality gate that never closes, so ALL its subscribers re-run
+ * on EVERY upstream change. Checked only on plain (non-overlay) changed runs;
+ * a genuinely different value (or a non-plain shape) resets the streak.
+ */
+function checkUnstableOutput(el, prevValue, newValue) {
+  const limit = options.unstableMemos;
+  // typeof guard: an explicit `unstableMemos: undefined` in enable() options
+  // clobbers the default through the spread — treat any non-number as off.
+  if (typeof limit !== "number") return;
+  const node = el;
+  if (
+    prevValue === newValue || // paranoia: changed runs should never hit this
+    !isPlainShape(prevValue) ||
+    !isPlainShape(newValue) ||
+    !shallowEquivalent(prevValue, newValue)
+  ) {
+    node._devUnstableRuns = 0;
+    node._devUnstableWarned = false;
+    return;
+  }
+  node._devUnstableRuns = (node._devUnstableRuns ?? 0) + 1;
+  if (node._devUnstableWarned || node._devUnstableRuns < limit) return;
+  node._devUnstableWarned = true;
+  const shape = Array.isArray(newValue) ? "array" : "object";
+  const message =
+    `[UNSTABLE_MEMO_OUTPUT] memo "${nodeName(el)}" produced a new-but-equivalent ${shape} on ` +
+    `${node._devUnstableRuns} consecutive runs — its equality gate never closes, so every ` +
+    `subscriber re-runs on every upstream change. Return stable references or pass an ` +
+    `\`equals\` option.`;
+  emitDiagnostic({
+    code: "UNSTABLE_MEMO_OUTPUT",
+    kind: "perf",
+    severity: "warn",
+    message,
+    nodeName: nodeName(el),
+    data: { runs: node._devUnstableRuns, shape }
+  });
+  console.warn(message);
+}
+// The engine's implementation of the core's dev hook points. Installed by
+// enable(), uninstalled by disable() — while uninstalled the core pays one
+// null check per site and nothing else.
+let asyncStartSeq = 0;
+let asyncStartTime = 0;
+let asyncStartValue;
+const engineHooks = {
+  recomputeStart(el, create) {
+    frames.push({
+      start: now(),
+      childMs: 0,
+      causes: create ? null : collectCauses(el),
+      prevDeps: create ? null : captureDeps(el),
+      // Mirror recompute's own prev-value resolution: an earlier run in the
+      // same flush may still be holding in _pendingValue.
+      prevValue: el._pendingValue !== NOT_PENDING ? el._pendingValue : el._value
+    });
+  },
+  derivedChanged(el) {
+    const frame = frames[frames.length - 1];
+    stampDerived(el, frame !== undefined && frame.causes !== null ? frame.causes : []);
+  },
+  recomputeEnd(el, _create, changed, optimistic, transition, held) {
+    const frame = frames.pop();
+    // enable() can land mid-recompute: no opening frame, nothing to report.
+    if (frame === undefined) return;
+    const totalMs = now() - frame.start;
+    if (frames.length > 0) frames[frames.length - 1].childMs += totalMs;
+    const selfMs = Math.max(0, totalMs - frame.childMs);
+    // Unstable-output check: memos only, non-create, plain runs with a
+    // committed change. The fresh value sits in `_pendingValue` for held
+    // plain-flush memo commits and in `_value` for direct ones. Overlay runs
+    // are excluded — an optimistic re-derive legitimately produces fresh
+    // equivalents while the lane settles.
+    if (frame.causes !== null && changed && !optimistic && !transition && !el._type)
+      checkUnstableOutput(
+        el,
+        frame.prevValue,
+        el._pendingValue !== NOT_PENDING ? el._pendingValue : el._value
+      );
+    if (frame.causes !== null)
+      recordRerun(
+        el,
+        frame.causes,
+        frame.prevDeps,
+        { selfMs, totalMs },
+        changed,
+        optimistic ? "optimistic" : transition ? "transition" : "plain",
+        held
+      );
+    // Creation runs still get the wide-scope check: a memo can be born with
+    // its coarse-read problem already in place.
+    else checkDepWidth(el);
+    markSeen(el);
+  },
+  write(el, prev, value) {
+    stampWrite(el, "write", prev, value);
+  },
+  refreshed(el) {
+    stampWrite(el, "refresh");
+  },
+  asyncStart(el) {
+    asyncStartSeq = el._devChange?.seq ?? 0;
+    asyncStartTime = el._time;
+    asyncStartValue = el._value;
+  },
+  asyncEnd(el, prev, value, direct) {
+    if (direct) {
+      // Core calls this unconditionally (hook calls cannot live inside its
+      // try blocks — see attribution-hooks.ts), so committed-ness is detected
+      // here against the asyncStart snapshot: a direct commit moves `_value`
+      // (or `_time`, for a same-reference commit under `equals: false`), and
+      // a transition hold parks the value in `_pendingValue`. A landing the
+      // equality gate swallowed moves none of them and must leave no stamp.
+      const committed =
+        el._value !== asyncStartValue || el._time !== asyncStartTime || el._pendingValue === value;
+      if (committed) stampWrite(el, "async", prev === undefined ? NO_VALUES : prev, value);
+      return;
+    }
+    // Landed through setSignal: reclassify its "write" stamp as an async
+    // landing — but only if it actually stamped (the value changed) since
+    // asyncStart; a no-change landing must leave no fresh stamp behind.
+    const change = el._devChange;
+    if (change !== undefined && change.seq > asyncStartSeq && change.kind === "write")
+      stampWrite(el, "async", NO_VALUES, value);
+  }
+};
+const attribution = {
+  enable(opts) {
+    options = { ...defaultOptions, ...opts };
+    frames.length = 0;
+    scopeCosts.clear();
+    writeCosts.clear();
+    setAttributionHooks(engineHooks);
+  },
+  disable() {
+    listeners.clear();
+    history = [];
+    frames.length = 0;
+    scopeCosts.clear();
+    writeCosts.clear();
+    setAttributionHooks(null);
+  },
+  subscribe(listener) {
+    listeners.add(listener);
+    return () => listeners.delete(listener);
+  },
+  history() {
+    return history;
+  },
+  why(target) {
+    const node = target?.[$REFRESH] ?? target;
+    return history.filter(event => event.node === node);
+  },
+  subscriptions(target) {
+    const node = target?.[$REFRESH] ?? target;
+    const names = [];
+    for (let l = node?._deps ?? null; l !== null; l = l._nextDep) names.push(nodeName(l._dep));
+    return names;
+  },
+  costs() {
+    return {
+      scopes: [...scopeCosts.values()].sort((a, b) => b.selfMs - a.selfMs),
+      writes: [...writeCosts.values()].sort((a, b) => b.downstreamMs - a.downstreamMs)
+    };
+  },
+  format: formatRerun
+};
+
+/** First warning when a node's live edge count reaches this size. */
+const GRAPH_SIZE_WARN_AT = 2000;
+/** Repeat the warning at this interval after the first. */
+const GRAPH_SIZE_WARN_EVERY = 500;
 const hooks = {};
 const diagnosticListeners = new Set();
 const diagnosticCaptures = new Set();
@@ -146,6 +733,12 @@ const diagnostics = {
 const DEV$1 = {
   hooks,
   diagnostics,
+  // Getter: attribution.ts imports emitDiagnostic back from this module,
+  // so when attribution.ts evaluates first the `attribution` binding is
+  // still uninitialized here — defer the read to access time.
+  get attribution() {
+    return attribution;
+  },
   getChildren,
   getSignals,
   getParent,
@@ -239,6 +832,64 @@ function getObservers(node) {
   }
   return observers;
 }
+function shouldWarnGraphSize(count) {
+  return count >= GRAPH_SIZE_WARN_AT && (count - GRAPH_SIZE_WARN_AT) % GRAPH_SIZE_WARN_EVERY === 0;
+}
+/**
+ * DEV-only: bump live edge counts after a new graph link and warn when a
+ * node grows an unusually large fan-out (many subscribers on one source) or
+ * fan-in (many sources on one computation). Repeat-reads that `link()`
+ * dedupes never reach here. Always-on in dev — unlike the opt-in attribution
+ * engine, a graph-size pathology should surface without asking.
+ */
+function noteGraphLink(dep, sub) {
+  const fanOut = (dep._subCount = (dep._subCount || 0) + 1);
+  const fanIn = (sub._depCount = (sub._depCount || 0) + 1);
+  if (shouldWarnGraphSize(fanOut)) {
+    const name = dep._name;
+    const message =
+      `[HUGE_FAN_OUT] ${name ? `Signal "${name}"` : "A signal"} has ${fanOut} subscribers. ` +
+      `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);
+  }
+  if (shouldWarnGraphSize(fanIn)) {
+    const name = sub._name;
+    const message =
+      `[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);
+  }
+}
+/** DEV-only: drop live edge counts when a link is removed. */
+function unnoteGraphLink(link) {
+  const dep = link._dep;
+  const sub = link._sub;
+  if (dep._subCount) dep._subCount--;
+  if (sub._depCount) sub._depCount--;
+}
 
 function createAsyncReporters() {
   return new Map();
@@ -298,8 +949,9 @@ function getOrCreateLane(signal) {
   }
   // Detect parent lane: _parentSource chains from pendingSignal → pendingValueComputed → original.
   // The child lane should not merge with the parent lane.
-  const parentSource = signal._parentSource;
-  const parentLane = parentSource?._optimisticLane ? findLane(parentSource._optimisticLane) : null;
+  const parentSource = signal._x?._parentSource;
+  const parentOptLane = parentSource?._x?._optimisticLane;
+  const parentLane = parentOptLane ? findLane(parentOptLane) : null;
   lane = {
     _source: signal,
     _pendingAsync: new Set(),
@@ -316,8 +968,8 @@ function getOrCreateLane(signal) {
   // parent-child is a property of the nodes, not of write order — otherwise
   // the owner's write merges the companion's subscribers into this lane and
   // their effects wait on its async instead of flushing immediately.
-  adoptCompanionLane(signal._pendingSignal, lane);
-  adoptCompanionLane(signal._latestValueComputed, lane);
+  adoptCompanionLane(signal._x?._pendingSignal, lane);
+  adoptCompanionLane(signal._x?._latestValueComputed, lane);
   return lane;
 }
 function adoptCompanionLane(companion, parent) {
@@ -359,11 +1011,11 @@ function mergeLanes(lane1, lane2) {
  * Resolve a node's lane: follow union-find chain, verify active, clear if stale.
  */
 function resolveLane(el) {
-  const lane = el._optimisticLane;
+  const lane = el._x?._optimisticLane;
   if (!lane) return undefined;
   const root = findLane(lane);
   if (activeLanes.has(root)) return root;
-  el._optimisticLane = undefined;
+  if (el._x !== null) el._x._optimisticLane = undefined;
   return undefined;
 }
 function resolveTransition(el) {
@@ -372,10 +1024,10 @@ function resolveTransition(el) {
   // transactions (#2912) — the merged root's _transition would hand this
   // node's override to whichever action wrote last through the shared
   // reader. Chase merge chains; a dead owner settled through another path.
-  if (hasActiveOverride$1(el) && el._overrideOwner) {
-    const owner = (el._overrideOwner = currentTransition(el._overrideOwner));
+  if (hasActiveOverride$1(el) && el._x?._overrideOwner) {
+    const owner = (ext(el)._overrideOwner = currentTransition(el._x?._overrideOwner));
     if (owner._done !== true) return owner;
-    el._overrideOwner = null;
+    if (el._x !== null) el._x._overrideOwner = null;
   }
   return resolveLane(el)?._transition ?? el._transition;
 }
@@ -383,7 +1035,8 @@ function resolveTransition(el) {
  * Check if a node has an active optimistic override.
  */
 function hasActiveOverride$1(el) {
-  return !!(el._overrideValue !== undefined && el._overrideValue !== NOT_PENDING);
+  const x = el._x;
+  return x !== null && x._overrideValue !== undefined && x._overrideValue !== NOT_PENDING;
 }
 /**
  * Assign or merge a lane onto a node. At convergence points (node already has
@@ -391,13 +1044,14 @@ function hasActiveOverride$1(el) {
  */
 function assignOrMergeLane(el, sourceLane) {
   const sourceRoot = findLane(sourceLane);
-  const existing = el._optimisticLane;
+  const existing = el._x?._optimisticLane;
   if (existing) {
     // If the subscriber's lane was merged into another lane, it's stale —
     // replace it with the new source lane instead of following the merge chain
     // (which would incorrectly merge the new lane into the old group)
     if (existing._mergedInto) {
-      el._optimisticLane = sourceLane;
+      ext(el)._optimisticLane = sourceLane;
+      el._config |= CONFIG_HAS_LANE;
       return;
     }
     const existingRoot = findLane(existing);
@@ -406,14 +1060,16 @@ function assignOrMergeLane(el, sourceLane) {
         // Parent-child lanes stay independent so isPending resolves without
         // waiting for the parent's async. The child keeps ownership.
         if (sourceRoot._parentLane && findLane(sourceRoot._parentLane) === existingRoot) {
-          el._optimisticLane = sourceLane;
+          ext(el)._optimisticLane = sourceLane;
+          el._config |= CONFIG_HAS_LANE;
         } else if (existingRoot._parentLane && findLane(existingRoot._parentLane) === sourceRoot);
         else mergeLanes(sourceRoot, existingRoot);
       }
       return;
     }
   }
-  el._optimisticLane = sourceLane;
+  ext(el)._optimisticLane = sourceLane;
+  el._config |= CONFIG_HAS_LANE;
 }
 
 const transitions = new Set();
@@ -474,13 +1130,13 @@ function sweepTransientStoreNodes() {
       continue;
     }
     if (node._pendingValue !== NOT_PENDING) continue;
-    if (node._overrideValue !== undefined && node._overrideValue !== NOT_PENDING) continue;
+    if (node._x?._overrideValue !== undefined && node._x?._overrideValue !== NOT_PENDING) continue;
     // A live affects() mark keeps the node addressable: sweeping it would
     // detach the refcount from the slot (a fresh probe would upsert a new,
     // unmarked node for the same property).
-    if (node._affectsCount) continue;
+    if (node._x?._affectsCount) continue;
     transientStoreNodes.delete(node);
-    node._unobserved?.();
+    node._x?._unobserved?.();
   }
 }
 function resetUnhandledAsync() {
@@ -732,6 +1388,9 @@ class GlobalQueue extends Queue {
   static _applyReask = null;
   static _repollVerdicts = null;
   static _witnessAffects = null;
+  // Re-asks probes whose verdict was provisionally suppressed by a fresh read
+  // of a held value, once the transaction gains an async blocker (#3028).
+  static _wakeSuppressedProbes = null;
   // Optimistic-engine hooks (wired by core/optimistic.ts via
   // installOptimisticEngine(), called from verdict.ts / createOptimistic /
   // createOptimisticStore — every module that can create optimistic state).
@@ -864,7 +1523,7 @@ 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._error;
+        const actualError = error !== undefined ? 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
@@ -876,7 +1535,10 @@ class GlobalQueue extends Queue {
           if (!reporters) activeTransition._asyncReporters.set(source, (reporters = new Set()));
           const prevSize = reporters.size;
           reporters.add(node);
-          if (reporters.size !== prevSize) schedule();
+          if (reporters.size !== prevSize) {
+            schedule();
+            GlobalQueue._wakeSuppressedProbes?.(activeTransition);
+          }
         }
         if (_enforceLoadingBoundary) _hitUnhandledAsync = true;
       }
@@ -939,32 +1601,60 @@ function queuePendingNode(node) {
 // REACTIVE_REASK) so the hot notification loop skips the per-subscriber flag
 // clear entirely in apps that never refresh.
 let reaskArmed = false;
+/** §12d: bumped by every recompute and every new subscriber edge. A node's
+ * staged-rewrite skip is sound only while NOTHING recomputed or linked since
+ * its last notify — a mid-batch pull can clean a marked subscriber, and a
+ * skipped re-write would leave it stale. */
+let notifyEpoch = 0;
+function bumpNotifyEpoch() {
+  notifyEpoch++;
+}
 function armReaskClear() {
   reaskArmed = true;
 }
 function insertSubs(node, optimistic = false) {
+  // §12d: stamp before walking — setSignal's staged-rewrite fast path skips
+  // the next walk for this node while the epoch holds (marking is idempotent).
+  node._notifiedAt = notifyEpoch;
   // Get source lane: prefer node's own lane over current context
   // This is important for isPending signals which need their own lane to flush immediately
-  const sourceLane = node._optimisticLane || currentOptimisticLane;
-  const hasSnapshot = node._snapshotValue !== undefined;
+  // Presence bits gate the optional-slot probes (see constants.ts): one
+  // masked read of the always-present _config instead of missing-property
+  // lookups in the hottest notify loop. Bits are sticky — the field read
+  // stays authoritative when a bit is set.
+  const cfg = node._config;
+  const sourceLane =
+    (cfg & CONFIG_HAS_LANE ? node._x?._optimisticLane : undefined) || currentOptimisticLane;
+  const hasSnapshot = (cfg & CONFIG_HAS_SNAPSHOT) !== 0 && node._x?._snapshotValue !== undefined;
   const clearReask = reaskArmed;
   for (let s = node._subs; s !== null; s = s._nextSub) {
+    const sub = s._sub;
     // A value-change notification is a new question for the subscriber: any
     // pending re-ask mark (refresh) it carried is superseded.
-    if (clearReask) s._sub._flags &= ~REACTIVE_REASK;
-    if (hasSnapshot && s._sub._config & CONFIG_IN_SNAPSHOT_SCOPE) {
-      s._sub._flags |= REACTIVE_SNAPSHOT_STALE;
+    if (clearReask) sub._flags &= ~REACTIVE_REASK;
+    // Missed-wake latch (#3037): this write is landing while the subscriber
+    // is mid-recompute (a nested pull committing beneath its reads), and the
+    // heap refuses RECOMPUTING nodes. A gen-current link means the pass
+    // already validated this dep — the value it read is now stale — so latch
+    // for recompute's tail to reschedule. Untouched links need no latch (the
+    // pass either re-reads them fresh or trims them), and neither does the
+    // tail link: it is the read IN FLIGHT — read() links before it pulls, so
+    // this very commit is what that read returns.
+    if (sub._flags & REACTIVE_RECOMPUTING_DEPS && s._gen === sub._depGen && s !== sub._depsTail)
+      sub._flags |= REACTIVE_MISSED_WAKE;
+    if (hasSnapshot && sub._config & CONFIG_IN_SNAPSHOT_SCOPE) {
+      sub._flags |= REACTIVE_SNAPSHOT_STALE;
       continue;
     }
     if (optimistic && sourceLane) {
-      s._sub._flags |= REACTIVE_OPTIMISTIC_DIRTY;
-      assignOrMergeLane(s._sub, sourceLane);
+      sub._flags |= REACTIVE_OPTIMISTIC_DIRTY;
+      assignOrMergeLane(sub, sourceLane);
     } else if (optimistic) {
-      s._sub._flags |= REACTIVE_OPTIMISTIC_DIRTY;
+      sub._flags |= REACTIVE_OPTIMISTIC_DIRTY;
       // No source lane means reversion - clear subscriber's lane so effects go to regular queue
-      s._sub._optimisticLane = undefined;
+      if (sub._x) sub._x._optimisticLane = undefined;
     }
-    enqueueSub(s._sub);
+    enqueueSub(sub);
   }
 }
 function commitPendingNode(n) {
@@ -974,7 +1664,7 @@ function commitPendingNode(n) {
       n._value = n._pendingValue;
       n._pendingValue = NOT_PENDING;
     }
-    if (n._pendingSignal || n._latestValueComputed) GlobalQueue._snapCompanions(n);
+    if (n._config & CONFIG_HAS_COMPANIONS) GlobalQueue._snapCompanions(n);
     return;
   }
   if (n._pendingValue !== NOT_PENDING) {
@@ -989,9 +1679,9 @@ function commitPendingNode(n) {
   c._loading = false;
   c._flags &= ~REACTIVE_MANUAL_WRITE;
   if (!(c._statusFlags & STATUS_PENDING)) c._statusFlags &= ~STATUS_UNINITIALIZED;
-  if (c._pendingFirstChild !== null || c._pendingDisposal !== null)
+  if (c._x != null && (c._x._pendingFirstChild !== null || c._x._pendingDisposal !== null))
     GlobalQueue._dispose(c, false, true);
-  if (n._pendingSignal || n._latestValueComputed) GlobalQueue._snapCompanions(n);
+  if (n._config & CONFIG_HAS_COMPANIONS) GlobalQueue._snapCompanions(n);
 }
 // Store commit hook (INTERNALS-STORE-STATE.md §3): installed by the store
 // module at init (same treeshakeable pattern as _resolveOptimistic /
@@ -1145,18 +1835,18 @@ function runQueue$1(queue, type) {
 }
 function reporterBlocksSource(reporter, source) {
   if (reporter._flags & (REACTIVE_ZOMBIE | REACTIVE_DISPOSED)) return false;
-  if (reporter._pendingSources?.has(source)) return true;
+  if (reporter._x?._pendingSources?.has(source)) return true;
   for (let dep = reporter._deps; dep; dep = dep._nextDep) {
     let current = dep._dep;
     while (current) {
       if (current === source || current._firewall === source) return true;
-      current = current._parentSource;
+      current = current._x?._parentSource;
     }
   }
   return !!(
     reporter._statusFlags & STATUS_PENDING &&
-    reporter._error instanceof NotReadyError &&
-    reporter._error.source === source
+    reporter._x?._error instanceof NotReadyError &&
+    reporter._x?._error.source === source
   );
 }
 function transitionComplete(transition) {
@@ -1173,7 +1863,7 @@ function transitionComplete(transition) {
       reporters.delete(reporter);
     }
     if (!hasLive) transition._asyncReporters.delete(source);
-    else if (source._statusFlags & STATUS_PENDING && source._error?.source === source) {
+    else if (source._statusFlags & STATUS_PENDING && source._x?._error?.source === source) {
       done = false;
       break;
     }
@@ -1238,6 +1928,9 @@ function actualInsertIntoHeap(n, heap) {
 }
 function insertIntoHeap(n, heap) {
   let flags = n._flags;
+  // RECOMPUTING refusals are not always losses: a genuinely missed wake (a
+  // write to a link this pass already validated) is latched link-side in
+  // insertSubs as REACTIVE_MISSED_WAKE for recompute's tail (#3037).
   if (flags & (REACTIVE_IN_HEAP | REACTIVE_RECOMPUTING_DEPS | REACTIVE_MANUAL_WRITE)) return;
   if (flags & REACTIVE_CHECK) {
     n._flags = (flags & -4) | REACTIVE_DIRTY | REACTIVE_IN_HEAP;
@@ -1295,8 +1988,11 @@ function markNode(el, newState = REACTIVE_DIRTY) {
   for (let link = el._subs; link !== null; link = link._nextSub) {
     markNode(link._sub, REACTIVE_CHECK);
   }
-  if (el._child !== null) {
-    for (let child = el._child; child !== null; child = child._nextChild) {
+  // Firewall children (projection machinery only): gate the cold-extension
+  // deref on the config bit — markNode runs per sub edge per write, and an
+  // unconditional _x chase here taxed every propagation (diamond -22%).
+  if (el._config & CONFIG_FW_CHILDREN) {
+    for (let child = el._x._child; child !== null; child = child._nextChild) {
       for (let link = child._subs; link !== null; link = link._nextSub) {
         markNode(link._sub, REACTIVE_CHECK);
       }
@@ -1357,17 +2053,14 @@ function markDisposal(el) {
   }
 }
 function dispose(node) {
-  // Leave every scheduler heap on disposal (mirrors `unobserved`): a node
-  // still queued here would be recomputed by the next flush, and recompute()
-  // rewriting `_flags` would clear REACTIVE_DISPOSED — resurrecting it (#2983).
-  deleteFromHeap(node, queueFor(node));
-  let toRemove = node._deps;
-  while (toRemove !== null) {
-    toRemove = unlinkSubs(toRemove);
-  }
-  node._deps = null;
-  node._depsTail = null;
-  disposeChildren(node, true);
+  // Direct disposal is death, not dormancy: strip the observation lifecycle
+  // so a later read freezes at the last committed value instead of
+  // reawakening the node (#3024). The teardown itself (heap removal — a node
+  // left queued would be recomputed and resurrected by the next flush (#2983)
+  // — dep unlinking, child disposal) is exactly unobserved()'s body; only
+  // this flag distinguishes death from dormancy.
+  node._config &= ~CONFIG_AUTO_DISPOSE;
+  unobserved(node);
 }
 function disposeChildren(node, self = false, zombie) {
   const flags = node._flags;
@@ -1380,33 +2073,36 @@ function disposeChildren(node, self = false, zombie) {
     // edge). Snap runs after the DISPOSED flag is set so the oracle reads
     // false, and notifies subscribers still watching the companion.
     const n = node;
-    if (n._pendingSignal || n._latestValueComputed) GlobalQueue._snapCompanions(n);
+    if (n._x?._pendingSignal || n._x?._latestValueComputed) GlobalQueue._snapCompanions(n);
   }
   if (self && true) clearSignals(node);
-  if (self && node._fn) node._inFlight = null;
-  let child = zombie ? node._pendingFirstChild : node._firstChild;
+  if (self && node._fn && node._x !== null) node._x._inFlight = null;
+  let child = zombie ? (node._x?._pendingFirstChild ?? null) : node._firstChild;
   while (child) {
     const nextChild = child._nextSibling;
     const n = child;
+    // Owner teardown is death regardless of the child's own lifecycle
+    // (#3024): strip AUTO_DISPOSE so a post-disposal read freezes at the
+    // last committed value instead of reawakening in a torn-down tree.
+    // Runs before the recursion so already-dormant children (whose
+    // disposeChildren call early-returns on REACTIVE_DISPOSED) die too.
+    // Only unobserved()'s own node keeps its dormancy — it is never in
+    // this loop; its children are rebuilt fresh on reawaken.
+    n._config &= ~CONFIG_AUTO_DISPOSE;
     // Heap removal must not be gated on `_deps`: a dependency-free
     // computation queued by refresh() has a null dep list but still sits in
     // the dirty heap, and left there the post-disposal flush recomputes it —
     // recompute() rewriting `_flags` clears REACTIVE_DISPOSED and the node
     // comes back to life (post-unmount runs, leaked cleanups, #2983).
-    if (n._flags & (REACTIVE_IN_HEAP | REACTIVE_IN_HEAP_HEIGHT)) deleteFromHeap(n, queueFor(n));
-    if (n._deps) {
-      let toRemove = n._deps;
-      do {
-        toRemove = unlinkSubs(toRemove);
-      } while (toRemove !== null);
-      n._deps = null;
-      n._depsTail = null;
-    }
+    // deleteFromHeap self-guards on the in-heap flags (and tolerates plain
+    // Owners, whose _flags is undefined), so no gate here.
+    deleteFromHeap(n, queueFor(n));
+    clearDeps(n);
     disposeChildren(child, true);
     child = nextChild;
   }
   if (zombie) {
-    node._pendingFirstChild = null;
+    if (node._x !== null) node._x._pendingFirstChild = null;
   } else {
     node._firstChild = null;
     node._childCount = 0;
@@ -1439,7 +2135,7 @@ function disposeChildren(node, self = false, zombie) {
   }
 }
 function runDisposal(node, zombie) {
-  let disposal = zombie ? node._pendingDisposal : node._disposal;
+  let disposal = zombie ? node._x?._pendingDisposal : node._disposal;
   if (!disposal) return;
   if (Array.isArray(disposal)) {
     for (let i = 0; i < disposal.length; i++) {
@@ -1449,7 +2145,9 @@ function runDisposal(node, zombie) {
   } else {
     disposal.call(disposal);
   }
-  zombie ? (node._pendingDisposal = null) : (node._disposal = null);
+  if (zombie) {
+    if (node._x !== null) node._x._pendingDisposal = null;
+  } else node._disposal = null;
 }
 function childId(owner, consume) {
   let counter = owner;
@@ -1589,8 +2287,7 @@ function createOwner(options) {
     _queue: parent?._queue ?? globalQueue,
     _context: parent?._context || defaultContext,
     _childCount: 0,
-    _pendingDisposal: null,
-    _pendingFirstChild: null,
+    _x: null,
     _parent: parent,
     dispose: disposeRootSelf
   };
@@ -1649,6 +2346,7 @@ function createRoot(init, options) {
 
 // https://github.com/stackblitz/alien-signals/blob/v2.0.3/src/system.ts#L100
 function unlinkSubs(link) {
+  unnoteGraphLink(link);
   const dep = link._dep;
   const nextDep = link._nextDep;
   const nextSub = link._nextSub;
@@ -1659,7 +2357,7 @@ function unlinkSubs(link) {
   else {
     dep._subs = nextSub;
     if (nextSub === null) {
-      dep._unobserved?.();
+      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
@@ -1687,14 +2385,22 @@ function trimStaleDeps(el) {
     else el._deps = null;
   }
 }
-function unobserved(el) {
-  deleteFromHeap(el, queueFor(el));
+// Shared by unobserved() and the disposeChildren child loop. The truthy guard
+// (not `!== null`) matters: plain Owners in a child chain have no _deps field,
+// and skipping early also avoids adding one (hidden-class churn) via the
+// null-out below.
+function clearDeps(el) {
   let dep = el._deps;
-  while (dep !== null) {
+  if (!dep) return;
+  do {
     dep = unlinkSubs(dep);
-  }
+  } while (dep !== null);
   el._deps = null;
   el._depsTail = null;
+}
+function unobserved(el) {
+  deleteFromHeap(el, queueFor(el));
+  clearDeps(el);
   disposeChildren(el, true);
 }
 // https://github.com/stackblitz/alien-signals/blob/v2.0.3/src/system.ts#L52
@@ -1754,6 +2460,9 @@ function link(dep, sub, pendingObserver = false) {
   else sub._deps = newLink;
   if (prevSub !== null) prevSub._nextSub = newLink;
   else dep._subs = newLink;
+  // New subscriber edge: staged-rewrite skips (§12d) must not miss it.
+  bumpNotifyEpoch();
+  noteGraphLink(dep, sub);
 }
 
 // The lazily-created Set is the ONE container for pending sources. Its
@@ -1762,18 +2471,18 @@ function link(dep, sub, pendingObserver = false) {
 // overlapping source landed beside the Set and removePendingSource refused
 // to clear it, stranding the Set members' pending forever (#2893).
 function addPendingSource(el, source) {
-  if (el._pendingSources?.has(source)) return false;
-  (el._pendingSources ??= new Set()).add(source);
+  if (el._x?._pendingSources?.has(source)) return false;
+  (ext(el)._pendingSources ??= new Set()).add(source);
   return true;
 }
 function removePendingSource(el, source) {
-  if (!el._pendingSources?.delete(source)) return false;
-  if (el._pendingSources.size === 0) el._pendingSources = undefined;
+  if (!el._x?._pendingSources?.delete(source)) return false;
+  if (el._x?._pendingSources.size === 0) if (el._x !== null) el._x._pendingSources = undefined;
   return true;
 }
 function clearPendingSources(el) {
-  el._pendingSources?.clear();
-  el._pendingSources = undefined;
+  el._x?._pendingSources?.clear();
+  if (el._x !== null) el._x._pendingSources = undefined;
 }
 // A rejection-pending only resolves through the settle sweep over the
 // SOURCE's subscribers, so it is retryable iff a tracked read created that
@@ -1783,7 +2492,7 @@ function clearPendingSources(el) {
 function retryReaches(el, source) {
   for (let d = el._deps; d; d = d._nextDep) {
     const dep = d._dep._firewall || d._dep;
-    if (dep === source || dep._pendingSources?.has(source)) return true;
+    if (dep === source || dep._x?._pendingSources?.has(source)) return true;
   }
   return false;
 }
@@ -1795,7 +2504,7 @@ function retryReaches(el, source) {
  * transition, no lane registration. Commit #0 keeps serving.
  */
 function parkLoadingWindow(el, e) {
-  el._blocked = true;
+  ext(el)._blocked = true;
   if (e.source) addPendingSource(el, e.source);
   // A settled error is the node's answer ("the error stays the answer until
   // this retry can actually run") — the park must not replace it: reads
@@ -1805,22 +2514,22 @@ function parkLoadingWindow(el, e) {
 }
 function setPendingError(el, source, error) {
   if (!source) {
-    el._error = null;
+    if (el._x !== null) el._x._error = null;
     return;
   }
   if (error instanceof NotReadyError && error.source === source) {
-    el._error = error;
+    ext(el)._error = error;
     return;
   }
-  const current = el._error;
+  const current = el._x?._error;
   if (!(current instanceof NotReadyError) || current.source !== source) {
-    el._error = new NotReadyError(source);
+    ext(el)._error = new NotReadyError(source);
   }
 }
 function forEachDependent(el, fn) {
   for (let s = el._subs; s !== null; s = s._nextSub) fn(s._sub, s);
   // `?? null`: affects() marks route plain signals (no `_child` slot) through here.
-  for (let child = el._child ?? null; child !== null; child = child._nextChild) {
+  for (let child = el._x?._child ?? null; child !== null; child = child._nextChild) {
     for (let s = child._subs; s !== null; s = s._nextSub) fn(s._sub, s);
   }
 }
@@ -1879,7 +2588,7 @@ function settleErroredDependents(el, error) {
   const visit = node => {
     if (visited.has(node)) return;
     visited.add(node);
-    if (node._error === error) {
+    if (node._x?._error === error) {
       enqueueSub(node);
       scheduled = true;
     }
@@ -1898,7 +2607,7 @@ function settlePendingSource(el) {
     if (visited.has(node) || !removePendingSource(node, el)) return;
     visited.add(node);
     node._time = clock;
-    const remaining = node._pendingSources?.values().next().value;
+    const remaining = node._x?._pendingSources?.values().next().value;
     // STATUS_ERROR + pending sources only coexist via an errored loading
     // window's park (notifyStatus(STATUS_ERROR) clears pending sources
     // otherwise): the settled error stays the answer through the settle —
@@ -1912,11 +2621,11 @@ function settlePendingSource(el) {
       node._statusFlags &= ~STATUS_PENDING;
       if (!errored) setPendingError(node);
       updateCompanions !== null && updateCompanions(node);
-      if (node._blocked) {
+      if (node._x?._blocked) {
         enqueueSub(node);
         scheduled = true;
       }
-      node._blocked = false;
+      if (node._x !== null) node._x._blocked = false;
       // Fully settled with nobody watching: release candidate (#2934). Checked
       // again at release time — deferred so unobserved() can't unlink subs
       // lists this walk is still iterating.
@@ -1944,7 +2653,7 @@ function handleAsync(el, result, setter) {
     });
   }
   if (!thenable && !iterator) {
-    el._inFlight = null;
+    if (el._x !== null) el._x._inFlight = null;
     // A sync landing is the first real answer for a loadingValue node.
     el._loading = false;
     return result;
@@ -1971,7 +2680,7 @@ function handleAsync(el, result, setter) {
     });
     throw new Error(message);
   }
-  el._inFlight = result;
+  ext(el)._inFlight = result;
   let syncValue;
   // Settle-time transition re-entry. The loading rail is invisible to
   // transactions (#2933): a boundary-caught first load never registers as an
@@ -1998,7 +2707,7 @@ function handleAsync(el, result, setter) {
     globalQueue.initTransition(transition);
   };
   const handleError = error => {
-    if (el._inFlight !== result) return;
+    if (el._x?._inFlight !== result) return;
     // NotReadyError from rejected promises should be treated as pending, not error
     let stillPending = error instanceof NotReadyError;
     // Dev-only authorship diagnostic (#2987): no edge means a post-`await`
@@ -2023,7 +2732,7 @@ function handleAsync(el, result, setter) {
       // serving commit #0 — same parking as recompute's catch for sync
       // dependency throws. The dead flight is released so the clock-gated
       // error-retry pull (updateIfNecessary) can also re-ask.
-      el._inFlight = null;
+      if (el._x !== null) el._x._inFlight = null;
       parkLoadingWindow(el, error);
       el._time = clock;
       return;
@@ -2037,7 +2746,7 @@ function handleAsync(el, result, setter) {
     if (!stillPending) releaseSettledDependents(el);
   };
   const asyncWrite = (value, then) => {
-    if (el._inFlight !== result) return;
+    if (el._x?._inFlight !== result) return;
     // If the node was dirtied by a newer write (optimistic override or regular),
     // skip this stale async result — the upcoming flush will recompute the node
     // with the new value, creating a fresh Promise that supersedes this one.
@@ -2048,10 +2757,14 @@ function handleAsync(el, result, setter) {
     clearStatus(el);
     const lane = resolveLane(el);
     if (lane) lane._pendingAsync.delete(el);
+    // Attribution hook: lets the engine snapshot state before the landing
+    // branches, so it can tell whether the plain path's setSignal committed a
+    // change (and only then classify it as an async landing).
+    if (attrHooks !== null) attrHooks.asyncStart(el);
     if (setter) {
       setter(value);
       if (wasUninitialized) clearStatus(el, true);
-    } else if (el._overrideValue !== undefined) {
+    } else if (el._x?._overrideValue !== undefined) {
       // Optimistic node — resting OR covered by an active override — holds
       // through the shared pending-node path, exactly like a plain async memo,
       // so the commit clears STATUS_UNINITIALIZED (#2806) and elevation to
@@ -2071,7 +2784,10 @@ function handleAsync(el, result, setter) {
       // override every reader sees the override (A17), so waking subs would
       // re-show an unchanged view — the revert is the notification point.
       GlobalQueue._syncCompanions !== null && GlobalQueue._syncCompanions(el, value);
-      if (!hasActiveOverride$1(el)) insertSubs(el);
+      if (!hasActiveOverride$1(el)) {
+        if (attrHooks !== null) attrHooks.asyncEnd(el, undefined, value, true);
+        insertSubs(el);
+      }
       el._time = clock;
     } else if (lane) {
       // Route through lane's effect queue for independent flushing
@@ -2095,6 +2811,13 @@ function handleAsync(el, result, setter) {
         // rejection (#2837).
         notifyStatus(el, STATUS_ERROR, e);
       }
+      // Attribution hook — unconditional, and OUTSIDE the try: rollup's
+      // tryCatchDeoptimization retains anything referenced inside a try even
+      // behind a folded true guard, so even a dev-only flag smuggled out of
+      // the commit branch leaves prod residue (#2883). The engine instead
+      // detects whether this landing committed by comparing the node against
+      // its asyncStart snapshot (see attribution.ts).
+      if (attrHooks !== null) attrHooks.asyncEnd(el, prevValue, value, true);
     } else {
       try {
         setSignal(el, () => value);
@@ -2103,6 +2826,11 @@ function handleAsync(el, result, setter) {
         // pre-commit failure here, and there is no user callsite to throw to.
         notifyStatus(el, STATUS_ERROR, e);
       }
+      // Attribution hook: this path landed through setSignal, whose write
+      // hook already saw any committed change — direct=false lets the engine
+      // reclassify that write as an async landing iff it actually committed.
+      // Outside the try (#2883 — see attribution-hooks.ts).
+      if (attrHooks !== null) attrHooks.asyncEnd(el, undefined, value, false);
     }
     // First real answer landing: the window closes when the answer becomes
     // OBSERVABLE. A direct commit is observable now; a transition-held write
@@ -2187,7 +2915,7 @@ function handleAsync(el, result, setter) {
             syncResult = r;
             resolved = true;
             if (r.done) completed = true;
-          } else if (el._inFlight !== result) {
+          } else if (el._x?._inFlight !== result) {
             return;
           } else if (!r.done) {
             hadValue = true;
@@ -2208,7 +2936,7 @@ function handleAsync(el, result, setter) {
           if (isSync && initialRead) {
             syncError = e;
             rejected = true;
-          } else if (el._inFlight === result) {
+          } else if (el._x?._inFlight === result) {
             completed = true;
             handleError(e);
             settleAutodispose();
@@ -2282,7 +3010,7 @@ function handleAsync(el, result, setter) {
           syncValue = v;
           resolved = true;
         } else if (
-          el._inFlight === result &&
+          el._x?._inFlight === result &&
           !(el._flags & REACTIVE_DISPOSED) &&
           flattenIfIterable(v, registerDeferredClose)
         );
@@ -2339,20 +3067,24 @@ function handleAsync(el, result, setter) {
   return syncValue;
 }
 function clearStatus(el, clearUninitialized = false) {
-  if (el._pendingSources) clearPendingSources(el);
-  if (el._blocked) el._blocked = false;
+  if (el._x?._pendingSources) clearPendingSources(el);
+  if (el._x?._blocked) if (el._x !== null) el._x._blocked = false;
   // The pending window is over; its quiet classification dies with it.
   // (Unconditional: _reask is baked into the node literals, so this is a
   // plain store to an existing slot — no shape change.)
-  el._reask = false;
+  if (el._x !== null) el._x._reask = false;
   el._statusFlags = clearUninitialized ? 0 : el._statusFlags & STATUS_UNINITIALIZED;
-  if (el._error) setPendingError(el);
+  if (el._x?._error) setPendingError(el);
   // Update pending signal for isPending() reactivity (companions only exist
   // once the verdict layer created them, which installs the hooks).
-  if (el._pendingSignal || el._latestValueComputed) GlobalQueue._updatePendingSignal(el);
-  if (el._child && GlobalQueue._updateChildCompanions !== null)
+  if (el._x?._pendingSignal || el._x?._latestValueComputed) GlobalQueue._updatePendingSignal(el);
+  if (
+    el._x?._child &&
+    el._config & CONFIG_CHILD_COMPANIONS &&
+    GlobalQueue._updateChildCompanions !== null
+  )
     GlobalQueue._updateChildCompanions(el);
-  if (el._notifyStatus) el._notifyStatus();
+  if (el._x?._notifyStatus) el._x._notifyStatus.call(el);
 }
 function notifyStatus(el, status, error, blockStatus, lane) {
   // Wrap regular errors to track source node
@@ -2366,7 +3098,7 @@ function notifyStatus(el, status, error, blockStatus, lane) {
     status === STATUS_PENDING && error instanceof NotReadyError ? error.source : undefined;
   const isSource = pendingSource === el;
   const isOptimisticBoundary =
-    status === STATUS_PENDING && el._overrideValue !== undefined && !isSource;
+    status === STATUS_PENDING && el._x?._overrideValue !== undefined && !isSource;
   const startsBlocking = isOptimisticBoundary && hasActiveOverride$1(el);
   if (!blockStatus) {
     if (status === STATUS_PENDING && pendingSource) {
@@ -2379,10 +3111,14 @@ function notifyStatus(el, status, error, blockStatus, lane) {
       clearPendingSources(el);
       el._statusFlags =
         status | (status !== STATUS_ERROR ? el._statusFlags & STATUS_UNINITIALIZED : 0);
-      el._error = error;
+      ext(el)._error = error;
     }
     GlobalQueue._updatePendingSignal !== null && GlobalQueue._updatePendingSignal(el);
-    if (el._child && GlobalQueue._updateChildCompanions !== null)
+    if (
+      el._x?._child &&
+      el._config & CONFIG_CHILD_COMPANIONS &&
+      GlobalQueue._updateChildCompanions !== null
+    )
       GlobalQueue._updateChildCompanions(el);
   }
   if (lane && !blockStatus) {
@@ -2390,22 +3126,24 @@ function notifyStatus(el, status, error, blockStatus, lane) {
   }
   const downstreamBlockStatus = blockStatus || startsBlocking;
   const downstreamLane = blockStatus || isOptimisticBoundary ? undefined : lane;
-  if (el._notifyStatus) {
+  if (el._x?._notifyStatus) {
     if (blockStatus && status === STATUS_PENDING) {
       return;
     }
     if (downstreamBlockStatus) {
-      el._notifyStatus(status, error);
+      el._x._notifyStatus.call(el, status, error);
     } else {
-      el._notifyStatus();
+      el._x._notifyStatus.call(el);
     }
     return;
   }
   forEachDependent(el, (sub, link) => {
     sub._time = clock;
     if (
-      (status === STATUS_PENDING && pendingSource && !sub._pendingSources?.has(pendingSource)) ||
-      (status !== STATUS_PENDING && (sub._error !== error || sub._pendingSources))
+      (status === STATUS_PENDING &&
+        pendingSource &&
+        !sub._x?._pendingSources?.has(pendingSource)) ||
+      (status !== STATUS_PENDING && (sub._x?._error !== error || sub._x?._pendingSources))
     ) {
       // A pending-observer link is the subscription an `isPending` read created.
       // It exists so the observer re-runs when the source settles, but it must
@@ -2496,7 +3234,7 @@ function releaseSubtree(owner) {
 function clearSnapshots() {
   if (snapshotSources) {
     for (const source of snapshotSources) {
-      delete source._snapshotValue;
+      delete source._x?._snapshotValue;
       // StoreNode targets share one pre-initialized hidden class (see
       // createStoreProxy) — assign undefined instead of deleting, and only
       // when present so signal-node sources don't grow the field.
@@ -2507,18 +3245,26 @@ function clearSnapshots() {
   snapshotCaptureActive = false;
 }
 function recompute(el, create = false) {
+  // §12d: any recompute can clean a marked subscriber — invalidate skips.
+  bumpNotifyEpoch();
   const isEffect = el._type;
+  // Attribution hook: fired before this run touches the dep list — `_deps`
+  // still holds the previous run's links (the subscriptions that could have
+  // triggered this run, and the baseline for the engine's subscription diff).
+  let devChanged = false;
+  if (attrHooks !== null) attrHooks.recomputeStart(el, create);
   if (!create) {
     if (el._transition && (!isEffect || activeTransition) && activeTransition !== el._transition)
       globalQueue.initTransition(el._transition);
     deleteFromHeap(el, queueFor(el));
-    el._inFlight = null;
+    if (el._x !== null) el._x._inFlight = null;
     // Tracked effects run after finalizePureQueue, so dispose immediately instead of deferring
     if (el._transition || isEffect === EFFECT_TRACKED) disposeChildren(el);
     else if (el._firstChild !== null || el._disposal !== null) {
       markDisposal(el);
-      el._pendingDisposal = el._disposal;
-      el._pendingFirstChild = el._firstChild;
+      const x = ext(el);
+      x._pendingDisposal = el._disposal;
+      x._pendingFirstChild = el._firstChild;
       el._disposal = null;
       el._firstChild = null;
       el._childCount = 0;
@@ -2526,12 +3272,15 @@ function recompute(el, create = false) {
     } else clearSignals(el);
   }
   let isOptimisticDirty = !!(el._flags & REACTIVE_OPTIMISTIC_DIRTY);
-  const hasOverride = el._overrideValue !== undefined && el._overrideValue !== NOT_PENDING;
+  const hasOverride =
+    (el._config & CONFIG_OPTIMISTIC) !== 0 &&
+    el._x?._overrideValue !== NOT_PENDING &&
+    el._x?._overrideValue !== undefined;
   const wasUninitialized = !!(el._statusFlags & STATUS_UNINITIALIZED);
   // Outgoing error, captured before the compute clears status: if this run
   // recovers to an unchanged value, dependents still holding this object must
   // be swept (settleErroredDependents, #2949).
-  const outgoingError = el._statusFlags & STATUS_ERROR ? el._error : undefined;
+  const outgoingError = el._statusFlags & STATUS_ERROR ? el._x?._error : undefined;
   // Re-ask classification lives in the verdict module; capture the flag before
   // the recompute wipes _flags below.
   const hadReask = (el._flags & REACTIVE_REASK) !== 0;
@@ -2548,6 +3297,7 @@ function recompute(el, create = false) {
   el._time = clock;
   let value = el._pendingValue === NOT_PENDING ? el._value : el._pendingValue;
   let oldHeight = el._height;
+  let missedWake = false;
   let prevTracking = tracking;
   let prevLane = currentOptimisticLane;
   let prevStrictRead = false;
@@ -2595,13 +3345,13 @@ function recompute(el, create = false) {
       // with a setter callback). In that case, the outer `handleAsync` call below would
       // clobber the fresh subscription, so we skip it and let the internally-registered
       // iteration drive updates.
-      const prevInFlight = el._inFlight;
+      const prevInFlight = el._x?._inFlight;
       const fnResult = el._fn(value);
       const isAsyncResult = typeof fnResult === "object" && fnResult !== null;
-      const inFlightChanged = el._inFlight !== prevInFlight;
+      const inFlightChanged = el._x?._inFlight !== prevInFlight;
       value = inFlightChanged || !isAsyncResult ? fnResult : handleAsync(el, fnResult);
       if (!inFlightChanged && !isAsyncResult) {
-        el._inFlight = null;
+        if (el._x !== null) el._x._inFlight = null;
         // A sync (non-object) return is the first real answer; async-shaped
         // results clear inside handleAsync at their own landing points, and a
         // self-registered flight (inFlightChanged — projections) clears when
@@ -2609,23 +3359,14 @@ function recompute(el, create = false) {
         el._loading = false;
       }
     }
-    // On a status-free node clearStatus is a guaranteed no-op: every branch
-    // in its body is gated on one of these fields, and with _statusFlags === 0
-    // the flags write (create or not) stores the 0 already there.
-    if (
-      el._statusFlags !== 0 ||
-      el._notifyStatus !== undefined ||
-      el._error ||
-      el._reask ||
-      el._blocked ||
-      el._pendingSources !== undefined ||
-      el._pendingSignal !== undefined ||
-      el._latestValueComputed !== undefined ||
-      el._child !== null
-    )
-      clearStatus(el, create);
-    // _optimisticLane is only ever assigned by engine paths.
-    if (el._optimisticLane) GlobalQueue._laneAsyncSettled(el);
+    // On a status-free node clearStatus is a guaranteed no-op: every field
+    // its body gates on is either _statusFlags or lives in the cold
+    // extension — no extension, no status to clear. (_x from an unrelated
+    // installer just makes clearStatus a cheap re-verified no-op.)
+    if (el._statusFlags !== 0 || el._x !== null) clearStatus(el, create);
+    // _optimisticLane is only ever assigned by engine paths (CONFIG_HAS_LANE
+    // is their sticky presence mark).
+    if (el._config & CONFIG_HAS_LANE && el._x?._optimisticLane) GlobalQueue._laneAsyncSettled(el);
   } catch (e) {
     const notReady = e instanceof NotReadyError;
     if (notReady && el._loading) {
@@ -2643,7 +3384,7 @@ function recompute(el, create = false) {
       if (notReady && currentOptimisticLane) GlobalQueue._laneAsyncPending(el);
       let reaskChanged = false;
       if (notReady) {
-        el._blocked = true;
+        ext(el)._blocked = true;
         if (GlobalQueue._applyReask !== null) reaskChanged = GlobalQueue._applyReask(el, hadReask);
       }
       notifyStatus(
@@ -2651,7 +3392,7 @@ function recompute(el, create = false) {
         notReady ? STATUS_PENDING : STATUS_ERROR,
         e,
         undefined,
-        notReady ? el._optimisticLane : undefined
+        notReady ? el._x?._optimisticLane : undefined
       );
       if (reaskChanged) GlobalQueue._repollVerdicts(el);
     }
@@ -2660,13 +3401,19 @@ function recompute(el, create = false) {
     latestReadActive = prevLatestRead;
     strictRead = prevStrictRead;
     if (isStaleEffect) stale = prevStale;
+    // Consume the missed-wake latch (#3037, set by insertSubs): a dep write
+    // landed beneath this pass on a link it had already validated. The wipe
+    // below must not key off DIRTY/CHECK — the read-time pull protocol
+    // (markNode(c) in read()) marks the running node as part of ordinary
+    // bookkeeping, and those marks are correctly discarded here.
+    missedWake = (el._flags & REACTIVE_MISSED_WAKE) !== 0;
     el._flags = REACTIVE_NONE | (create ? el._flags & REACTIVE_SNAPSHOT_STALE : 0);
     context = oldcontext;
   }
-  if (!el._error) {
+  if (!el._x?._error) {
     trimStaleDeps(el);
     const compareValue = hasOverride
-      ? unwrapOverride(el._overrideValue)
+      ? unwrapOverride(el._x?._overrideValue)
       : el._pendingValue === NOT_PENDING
         ? el._value
         : el._pendingValue;
@@ -2681,21 +3428,27 @@ function recompute(el, create = false) {
       // flush, bypassing every boundary and wedging the queue (#2837).
       notifyStatus(el, STATUS_ERROR, e);
     }
+    // A committed derived change becomes a cause for this node's subscribers,
+    // chaining their attribution through this node to the root write.
+    if (attrHooks !== null) {
+      devChanged = valueChanged && !el._x?._error;
+      if (devChanged && !isEffect && !create) attrHooks.derivedChanged(el);
+    }
     // Effects use `_equals: false` (no per-effect closure). The side effects that
     // the equals closure used to perform — flagging the effect dirty and enqueueing
     // its runner — happen here instead. `!create` matches the previous `initialized`
     // gate: the explicit recompute(node, true) inside effect() does not enqueue, so
     // effect() can call its runner synchronously for the first run.
     if (isEffect && valueChanged) {
-      el._modified = !el._error;
+      el._modified = !el._x?._error;
       // Reuse one bound runner per effect — runEffect no-ops on a stale
       // `_modified`, so re-enqueueing the same function is harmless.
       if (!create)
         el._queue.enqueue(isEffect, (el._boundRunEffect ??= GlobalQueue._runEffect.bind(null, el)));
     }
-    if (el._error);
+    if (el._x?._error);
     else if (valueChanged) {
-      const prevVisible = hasOverride ? el._overrideValue : undefined;
+      const prevVisible = hasOverride ? el._x?._overrideValue : undefined;
       if (
         create ||
         // Plain sync flush (no transition on either side) commits effect
@@ -2704,6 +3457,13 @@ function recompute(el, create = false) {
         // paying it per effect on the plain path is pure overhead.
         (isEffect && (activeTransition !== el._transition || activeTransition === null)) ||
         isOptimisticDirty
+        // NOTE (stage-3, 2026-08-21): a quiet-world MEMO direct-commit was
+        // attempted here and REVERTED — memo staging is load-bearing beyond
+        // transitions: mid-batch pulls (latest()/isPending()/read-triggered
+        // recomputes before sources commit) must see the fresh value while
+        // PLAIN reads stay committed until flush (#3009 purity). The pending
+        // round-trip is that separation; it cannot be skipped on any path a
+        // pull can reach.
       ) {
         el._value = value;
         // Lane-propagated correction: upstream data is fresh, correct the
@@ -2711,7 +3471,7 @@ function recompute(el, create = false) {
         // own reveal schedule; drop any superseded older hold so its queued
         // commit can't clobber the fresh value.
         if (hasOverride && isOptimisticDirty) {
-          el._overrideValue = value === undefined ? OVERRIDE_UNDEFINED : value;
+          ext(el)._overrideValue = value === undefined ? OVERRIDE_UNDEFINED : value;
           el._pendingValue = NOT_PENDING;
         }
       } else {
@@ -2731,7 +3491,7 @@ function recompute(el, create = false) {
       // subscriber-less node has nothing to notify.
       if (
         el._subs !== null &&
-        (!hasOverride || isOptimisticDirty || el._overrideValue !== prevVisible)
+        (!hasOverride || isOptimisticDirty || el._x?._overrideValue !== prevVisible)
       )
         insertSubs(el, isOptimisticDirty || hasOverride);
     } else if (hasOverride) {
@@ -2750,15 +3510,28 @@ function recompute(el, create = false) {
     // dependents still holding the propagated error consumed their dirty flag
     // in an errored run and may sit on stale commits (#2949). Changed-value
     // recoveries ride insertSubs above; a comparator throw re-errored the node
-    // (el._error re-set), so this only runs on a genuinely clean recovery.
-    if (outgoingError !== undefined && !valueChanged && !el._error)
+    // (el._x?._error re-set), so this only runs on a genuinely clean recovery.
+    if (outgoingError !== undefined && !valueChanged && !el._x?._error)
       settleErroredDependents(el, outgoingError);
   }
+  // Attribution hook: fired before the lane restore so `currentOptimisticLane`
+  // still reflects THIS run's posture. The facts distinguish an overlay
+  // recompute (optimistic lane, transition replay, transition-held commit)
+  // from a plain committed one — the engine must not blame overlay runs as
+  // waste or double-count them against plain aggregates.
+  if (attrHooks !== null)
+    attrHooks.recomputeEnd(
+      el,
+      create,
+      devChanged,
+      isOptimisticDirty || currentOptimisticLane !== null,
+      activeTransition !== null || el._transition !== null,
+      el._pendingValue !== NOT_PENDING
+    );
   currentOptimisticLane = prevLane;
   const needsPendingCommit =
     el._pendingValue !== NOT_PENDING ||
-    el._pendingFirstChild !== null ||
-    el._pendingDisposal !== null ||
+    (el._x !== null && (el._x._pendingFirstChild !== null || el._x._pendingDisposal !== null)) ||
     (el._statusFlags & (STATUS_PENDING | STATUS_UNINITIALIZED)) !== 0;
   // Override-covered holds (hasOverride) always queue: their commit belongs
   // to their own transition's schedule (A18 re-rule) and is unobservable
@@ -2773,8 +3546,22 @@ function recompute(el, create = false) {
     isEffect &&
     activeTransition !== el._transition &&
     runInTransition(el._transition, () => recompute(el));
+  // Missed-wake reschedule (see the finally above): values this pass read
+  // before the nested commit are stale, so run again now that the heap will
+  // accept the node. Equality gates stop same-value landings from cascading,
+  // and a re-run only latches again if another nested commit changes a dep
+  // beneath it — convergent unless deps genuinely keep changing.
+  if (missedWake) {
+    enqueueSub(el);
+    schedule();
+  }
 }
 function updateIfNecessary(el) {
+  // Never re-enter a node that is currently computing: its dep bookkeeping
+  // (_depsTail/_depGen) is live, and a nested recompute would corrupt it.
+  // A mid-pass mark stays latched for recompute's own tail to reschedule
+  // (#3037); readers meanwhile serve the values the pass has so far.
+  if (el._flags & REACTIVE_RECOMPUTING_DEPS) return;
   if (el._flags & REACTIVE_CHECK) {
     for (let d = el._deps; d; d = d._nextDep) {
       const dep1 = d._dep;
@@ -2789,7 +3576,7 @@ function updateIfNecessary(el) {
   }
   if (
     el._flags & (REACTIVE_DIRTY | REACTIVE_OPTIMISTIC_DIRTY) ||
-    (el._error && el._time < clock && !el._inFlight)
+    (el._x?._error && el._time < clock && !el._x?._inFlight)
   ) {
     recompute(el);
   }
@@ -2811,7 +3598,6 @@ function computed(fn, options) {
       (options?._noSnapshot ? CONFIG_NO_SNAPSHOT : 0) |
       (snapshotCaptureActive && ownerInSnapshotScope(context) ? CONFIG_IN_SNAPSHOT_SCOPE : 0),
     _equals: options?.equals != null ? options.equals : isEqual,
-    _unobserved: options?.unobserved,
     _disposal: null,
     _queue: context?._queue ?? globalQueue,
     _context: context?._context ?? defaultContext,
@@ -2819,7 +3605,6 @@ function computed(fn, options) {
     _fn: fn,
     _value: loading ? options.loadingValue : undefined,
     _height: 0,
-    _child: null,
     _nextHeap: undefined,
     _prevHeap: null,
     _deps: null,
@@ -2836,17 +3621,47 @@ function computed(fn, options) {
     _statusFlags: loading ? 0 : STATUS_UNINITIALIZED,
     _time: clock,
     _pendingValue: NOT_PENDING,
-    _pendingDisposal: null,
-    _pendingFirstChild: null,
-    _inFlight: null,
     _transition: null,
-    _reask: false,
-    _loading: loading
+    _notifiedAt: -1,
+    _loading: loading,
+    // Cold machinery (async/transition/optimistic/verdict slots) lives one
+    // hop away in the lazily-allocated extension — the core literal MUST
+    // stay under V8's in-object boundary (§12: past ~39 fields every
+    // allocation spills to a backing store and creation cost ~4x's).
+    _x: null
   };
   self._name = options?.name ?? "computed";
+  if (options?.unobserved) ext(self)._unobserved = options.unobserved;
   setupComputedNode(self, options);
   return self;
 }
+/** Lazily allocate a node's cold extension (ONE shape for signals and
+ * computeds — `_x` access stays monomorphic). Installers write through
+ * this; hot paths read `el._x?._field` gated by the _config presence bits.
+ * Never call ext() just to store a field's default. */
+function ext(el) {
+  return (el._x ??= {
+    _overrideValue: undefined,
+    _overrideOwner: undefined,
+    _optimisticLane: undefined,
+    _pendingSignal: undefined,
+    _latestValueComputed: undefined,
+    _parentSource: undefined,
+    _affectsCount: 0,
+    _inFlight: null,
+    _error: undefined,
+    _blocked: undefined,
+    _pendingSources: undefined,
+    _notifyStatus: undefined,
+    _reask: false,
+    _child: null,
+    _unobserved: undefined,
+    _snapshotValue: undefined,
+    _pendingDisposal: null,
+    _pendingFirstChild: null,
+    _companionChildren: undefined
+  });
+}
 /**
  * Build an Effect node with all effect-specific fields baked into a single object literal,
  * so V8 sees the full hidden class shape at construction time. Effects always run in lazy
@@ -2863,7 +3678,6 @@ function createEffectNode(fn, effectFn, errorFn, type, notifyStatus, options) {
       (options?.sync ? CONFIG_SYNC : 0) |
       (snapshotCaptureActive && ownerInSnapshotScope(context) ? CONFIG_IN_SNAPSHOT_SCOPE : 0),
     _equals: false,
-    _unobserved: options?.unobserved,
     _disposal: null,
     _queue: context?._queue ?? globalQueue,
     _context: context?._context ?? defaultContext,
@@ -2871,7 +3685,6 @@ function createEffectNode(fn, effectFn, errorFn, type, notifyStatus, options) {
     _fn: fn,
     _value: undefined,
     _height: 0,
-    _child: null,
     _nextHeap: undefined,
     _prevHeap: null,
     _deps: null,
@@ -2887,11 +3700,8 @@ function createEffectNode(fn, effectFn, errorFn, type, notifyStatus, options) {
     _statusFlags: STATUS_UNINITIALIZED,
     _time: clock,
     _pendingValue: NOT_PENDING,
-    _pendingDisposal: null,
-    _pendingFirstChild: null,
-    _inFlight: null,
     _transition: null,
-    _reask: false,
+    _notifiedAt: -1,
     _loading: false,
     _modified: false,
     _prevValue: undefined,
@@ -2899,9 +3709,12 @@ function createEffectNode(fn, effectFn, errorFn, type, notifyStatus, options) {
     _errorFn: errorFn,
     _cleanup: undefined,
     _type: type,
-    _notifyStatus: notifyStatus
+    _x: null
   };
   self._name = options?.name ?? "effect";
+  // Boundary effects carry a status channel; most effects never touch _x.
+  if (notifyStatus !== undefined) ext(self)._notifyStatus = notifyStatus;
+  if (options?.unobserved) ext(self)._unobserved = options.unobserved;
   setupComputedNode(self, lazyOptions);
   return self;
 }
@@ -2936,7 +3749,8 @@ function setupComputedNode(self, options) {
   !options?.lazy && recompute(self, true);
   if (snapshotCaptureActive && !options?.lazy) {
     if (!(self._statusFlags & STATUS_PENDING) && !(self._config & CONFIG_NO_SNAPSHOT)) {
-      self._snapshotValue = self._value === undefined ? NO_SNAPSHOT : self._value;
+      ext(self)._snapshotValue = self._value === undefined ? NO_SNAPSHOT : self._value;
+      self._config |= CONFIG_HAS_SNAPSHOT;
       snapshotSources.add(self);
     }
   }
@@ -2947,38 +3761,52 @@ function signal(v, options, firewall = null) {
     _config:
       (options?.ownedWrite ? CONFIG_OWNED_WRITE : 0) |
       (options?._noSnapshot ? CONFIG_NO_SNAPSHOT : 0),
-    _unobserved: options?.unobserved,
     _value: v,
     _subs: null,
     _subsTail: null,
     _time: clock,
     _firewall: firewall,
-    _nextChild: firewall?._child || null,
-    _pendingValue: NOT_PENDING
+    _nextChild: firewall?._x?._child || null,
+    _pendingValue: NOT_PENDING,
+    // Signal-literal diet (§12e): NO _time/_fn/_statusFlags slots. Stores
+    // materialize one signal per touched leaf, so signal bytes are store
+    // bytes. _time is write-only on signals (every read site is computed-
+    // typed error-retry gating); _fn/_statusFlags read falsy-identically as
+    // missing properties on the shared paths (undefined masks to 0).
+    _transition: null,
+    _notifiedAt: -1,
+    _x: null
   };
   {
     s._name = options?.name ?? "signal";
     s._internal = !!firewall;
   }
-  firewall && (firewall._child = s);
+  if (options?.unobserved) ext(s)._unobserved = options.unobserved;
+  if (firewall) {
+    ext(firewall)._child = s;
+    firewall._config |= CONFIG_FW_CHILDREN;
+  }
   if (
     snapshotCaptureActive &&
     !(s._config & CONFIG_NO_SNAPSHOT) &&
     !((firewall?._statusFlags ?? 0) & STATUS_PENDING)
   ) {
-    s._snapshotValue = v === undefined ? NO_SNAPSHOT : v;
+    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);
-  s._overrideValue = NOT_PENDING;
+  ext(s)._overrideValue = NOT_PENDING;
+  s._config |= CONFIG_OPTIMISTIC;
   return s;
 }
 function optimisticComputed(fn, options) {
   const c = computed(fn, options);
-  c._overrideValue = NOT_PENDING;
+  ext(c)._overrideValue = NOT_PENDING;
+  c._config |= CONFIG_OPTIMISTIC;
   return c;
 }
 function isEqual(a, b) {
@@ -3041,7 +3869,13 @@ function prepareComputed(comp, refresh) {
     comp._flags &= ~REACTIVE_LAZY;
     recompute(comp, true);
   } else if (comp._flags & REACTIVE_DISPOSED) {
-    recompute(comp, true);
+    // Two disposal lifecycles share the flag (#3024). Observation-lifecycle
+    // nodes (CONFIG_AUTO_DISPOSE) are dormant — torn down by unobserved()
+    // when the last subscriber left — and reads reawaken them; that is the
+    // pay-for-use contract. Owner-lifecycle nodes are dead: recomputing would
+    // re-run user code in a torn-down tree (and discard manual writes on
+    // derived-writable signals), so reads return the last committed value.
+    if (comp._config & CONFIG_AUTO_DISPOSE) recompute(comp, true);
   } else if (refresh) {
     updateIfNecessary(comp);
   }
@@ -3066,8 +3900,8 @@ function readNodeFast(el) {
     pendingCheckActive ||
     el._fn ||
     el._firewall ||
-    el._overrideValue !== undefined ||
-    el._snapshotValue !== undefined ||
+    el._x?._overrideValue !== undefined ||
+    el._x?._snapshotValue !== undefined ||
     activeTransition !== null ||
     currentOptimisticLane !== null ||
     snapshotCaptureActive ||
@@ -3107,8 +3941,8 @@ function read(el) {
   if (
     !computed._fn &&
     owner === el &&
-    el._overrideValue === undefined &&
-    el._snapshotValue === undefined &&
+    el._x?._overrideValue === undefined &&
+    el._x?._snapshotValue === undefined &&
     activeTransition === null &&
     currentOptimisticLane === null &&
     !snapshotCaptureActive &&
@@ -3168,13 +4002,23 @@ function read(el) {
       // active override throws.
       if (currentOptimisticLane === null || GlobalQueue._laneSuspends(owner)) {
         if (!tracking && el !== c) link(el, c);
-        throw owner._error;
+        throw owner._x?._error;
       }
-    } else if (c && owner !== el && owner._statusFlags & STATUS_UNINITIALIZED) {
+    } else if (c && owner._statusFlags & STATUS_UNINITIALIZED) {
+      // A stale (render) reader of a node held pending in ANOTHER transition
+      // normally keeps showing the node's committed value instead of
+      // entangling the two transactions — but an uninitialized node has no
+      // committed value to show. Suspend on it (firewall-backed store reads
+      // always took this branch; plain memos now do too): the reader
+      // registers as a reporter of that source, and its pending-node stamp
+      // ties it to the active transaction, so the two transactions merge
+      // when the source settles. Falling through served `undefined` as if
+      // settled and stranded the reader outside both transactions, so it
+      // never re-ran when either landed (#3043 port).
       if (!tracking && el !== c) link(el, c);
-      throw owner._error;
+      throw owner._x?._error;
     } else if (!c && owner._statusFlags & STATUS_UNINITIALIZED) {
-      throw owner._error;
+      throw owner._x?._error;
     }
   }
   // `owner` is the computed itself, or the firewall behind a store node —
@@ -3189,10 +4033,10 @@ function read(el) {
     if (tracking && !pendingCheckActive && owner._time < clock) {
       recompute(owner);
       return read(el);
-    } else throw owner._error;
+    } else throw owner._x?._error;
   }
   if (snapshotCaptureActive && c && c._config & CONFIG_IN_SNAPSHOT_SCOPE) {
-    const sv = el._snapshotValue;
+    const sv = el._x?._snapshotValue;
     if (sv !== undefined) {
       const snapshot = sv === NO_SNAPSHOT ? undefined : sv;
       const current = el._pendingValue !== NOT_PENDING ? el._pendingValue : el._value;
@@ -3206,9 +4050,9 @@ function read(el) {
       ownerName: c?._name,
       nodeName: owner?._name
     });
-  if (el._overrideValue !== undefined && el._overrideValue !== NOT_PENDING) {
+  if (el._x?._overrideValue !== undefined && el._x?._overrideValue !== NOT_PENDING) {
     // A17: the override IS the value for every reader.
-    return unwrapOverride(el._overrideValue);
+    return unwrapOverride(el._x?._overrideValue);
   }
   // Entanglement gate: a reader recomputing under an optimistic lane that reads
   // a pending mid-transition write sees the committed value. Projection-store
@@ -3300,9 +4144,10 @@ function setSignal(el, v) {
     globalQueue.initTransition(el._transition);
   // The optimistic write path lives with the engine: only optimisticSignal /
   // optimisticComputed callers and optimistic store nodes carry an
-  // _overrideValue slot, and every module that creates one installs the
-  // engine first.
-  if (el._overrideValue !== undefined && !projectionWriteActive)
+  // _overrideValue slot (flagged by CONFIG_OPTIMISTIC — a masked read of the
+  // always-present config instead of a missing-property probe), and every
+  // module that installs one installs the engine first.
+  if (el._config & CONFIG_OPTIMISTIC && !projectionWriteActive)
     return GlobalQueue._optimisticWrite(el, v);
   const currentValue = el._pendingValue === NOT_PENDING ? el._value : el._pendingValue;
   if (typeof v === "function") v = v(currentValue);
@@ -3311,15 +4156,29 @@ function setSignal(el, v) {
   const valueChanged =
     !!(el._statusFlags & STATUS_UNINITIALIZED) || !el._equals || !el._equals(currentValue, v);
   if (!valueChanged) return v;
-  if (el._pendingValue === NOT_PENDING) queuePendingNode(el);
+  // Attribution hook: this committed write is where a re-run chain begins.
+  if (attrHooks !== null) attrHooks.write(el, currentValue, v);
+  const wasStaged = el._pendingValue !== NOT_PENDING;
+  if (!wasStaged) queuePendingNode(el);
   el._pendingValue = v;
   // syncCompanions only pokes _pendingSignal/_latestValueComputed — with
   // neither companion present the call is a guaranteed no-op (companions are
-  // only ever created, never removed, and creating one installs the hook).
-  (el._pendingSignal !== undefined || el._latestValueComputed !== undefined) &&
+  // only ever created, never removed, and creating one installs the hook and
+  // sets CONFIG_HAS_COMPANIONS — one masked read replaces two optional-field
+  // probes on every write).
+  el._config & CONFIG_HAS_COMPANIONS &&
     GlobalQueue._syncCompanions !== null &&
     GlobalQueue._syncCompanions(el, v);
-  el._time = clock;
+  // _time is a computed-only slot (§12e): writing it on a signal would fork
+  // the lean shape. Every read site is computed-typed.
+  if (el._fn !== undefined) el._time = clock;
+  // Staged-rewrite fast path (§12d): a re-write to a node whose subscribers
+  // were already walked — and where nothing has recomputed or linked since
+  // (epoch) — re-stages the value and stops. The walk is idempotent (subs
+  // marked, heap entries flag-guarded, effects queued once); lane and reask
+  // contexts change what a walk MEANS, so they always walk.
+  if (wasStaged && el._notifiedAt === notifyEpoch && currentOptimisticLane === null && !reaskArmed)
+    return v;
   insertSubs(el);
   schedule();
   return v;
@@ -3338,6 +4197,7 @@ function suppressComputedRecompute(el) {
     schedule();
   }
   el._flags = (el._flags & -4) | REACTIVE_MANUAL_WRITE;
+  el._manualWriteTime = clock;
 }
 /**
  * User-facing setter for the memo form of `createSignal(fn)`. Behaves like
@@ -3456,10 +4316,19 @@ function refresh(target) {
     });
     throw new Error(REACTIVE_WRITE_IN_OWNED_SCOPE_REFRESH_MESSAGE);
   }
-  if (
-    typeof node._fn === "function" &&
-    !(node._flags & (REACTIVE_DISPOSED | REACTIVE_MANUAL_WRITE))
-  ) {
+  if (typeof node._fn === "function" && !(node._flags & REACTIVE_DISPOSED)) {
+    if (node._flags & REACTIVE_MANUAL_WRITE) {
+      // A manual write in the CURRENT tick wins over the refresh (#2692).
+      // A mask stamped in an earlier tick only survives because a
+      // transaction (action) is holding the pending drain open; there the
+      // refresh is a later, explicit re-ask and lifts the mask — otherwise
+      // any setStore early in an action silently swallows every refresh()
+      // 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.
+    }
     // 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
     // pending window as quiet (not pending). If the node is already dirty
@@ -3467,11 +4336,14 @@ function refresh(target) {
     // 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.
-    if (!(node._flags & (REACTIVE_DIRTY | REACTIVE_CHECK | REACTIVE_IN_HEAP))) {
+    else if (!(node._flags & (REACTIVE_DIRTY | REACTIVE_CHECK | REACTIVE_IN_HEAP))) {
       node._flags |= REACTIVE_REASK;
       armReaskClear();
     }
     node._flags = (node._flags & ~REACTIVE_CHECK) | REACTIVE_DIRTY;
+    // A refresh() self-invalidation is a root cause too — the target's next
+    // run has no changed dep to point at, so it points here instead.
+    if (attrHooks !== null) attrHooks.refreshed(node);
     insertIntoHeap(node, queueFor(node));
     schedule();
   }
@@ -3631,11 +4503,20 @@ function isUndefined(value) {
  */
 /** The optimistic half of setSignal, fired when `_overrideValue !== undefined`. */
 function optimisticWrite(el, v) {
-  const hasOverride = el._overrideValue !== NOT_PENDING;
-  const currentValue = hasOverride ? unwrapOverride(el._overrideValue) : el._value;
+  const hasOverride = el._x?._overrideValue !== NOT_PENDING;
+  const currentValue = hasOverride ? unwrapOverride(el._x?._overrideValue) : el._value;
   if (typeof v === "function") v = v(currentValue);
   const valueChanged =
-    !!(el._statusFlags & STATUS_UNINITIALIZED) || !el._equals || !el._equals(currentValue, v);
+    !!(el._statusFlags & STATUS_UNINITIALIZED) ||
+    // A dirty node's _value is stale (its queued recompute hasn't run — e.g.
+    // a latest() shadow marked by the previous landing's companion snap), so
+    // equality against it must not swallow the write. Without this, a sync
+    // push returning the shadow to that stale value was dropped, the snap
+    // recompute then committed the parent's old value, and the banner showed
+    // the previous transition's target (#3041 follow-up).
+    !!((el._flags ?? 0) & (REACTIVE_DIRTY | REACTIVE_CHECK)) ||
+    !el._equals ||
+    !el._equals(currentValue, v);
   if (!valueChanged) {
     // Same-value write with an active override still entangles the current
     // action's transition — the hold must outlast all overlapping actions.
@@ -3653,19 +4534,20 @@ function optimisticWrite(el, v) {
   // Stamp ownership on the node (post-merge, so entangled writers share the
   // joint root). resolveTransition prefers this over the lane's _transition,
   // which a shared subscriber can merge across transactions (#2912).
-  el._overrideOwner = activeTransition;
+  ext(el)._overrideOwner = activeTransition;
   const lane = getOrCreateLane(el);
-  el._optimisticLane = lane;
+  ext(el)._optimisticLane = lane;
+  el._config |= CONFIG_HAS_LANE;
   // Literal undefined must not land raw: the slot doubles as the optimistic
   // brand, and erasing it makes the write invisible and routes follow-up
   // writes off the optimistic path into permanent commits (#2898).
-  el._overrideValue = v === undefined ? OVERRIDE_UNDEFINED : v;
+  ext(el)._overrideValue = v === undefined ? OVERRIDE_UNDEFINED : v;
   // syncCompanions only pokes _pendingSignal/_latestValueComputed — with
   // neither companion present the call is a guaranteed no-op.
-  (el._pendingSignal !== undefined || el._latestValueComputed !== undefined) &&
+  (el._x?._pendingSignal !== undefined || el._x?._latestValueComputed !== undefined) &&
     GlobalQueue._syncCompanions !== null &&
     GlobalQueue._syncCompanions(el, v);
-  el._time = clock;
+  if (el._fn !== undefined) el._time = clock; // §12e: computed-only slot
   insertSubs(el, true);
   schedule();
   return v;
@@ -3682,7 +4564,7 @@ function transitionBlocked(transition) {
       hasActiveOverride$1(node) &&
       "_statusFlags" in node &&
       node._statusFlags & STATUS_PENDING &&
-      node._error instanceof NotReadyError
+      node._x?._error instanceof NotReadyError
     ) {
       return true;
     }
@@ -3696,26 +4578,26 @@ function resolveOptimisticNodes(nodes) {
   const len = nodes.length;
   for (let i = 0; i < len; i++) {
     const node = nodes[i];
-    node._optimisticLane = undefined;
+    if (node._x !== null) node._x._optimisticLane = undefined;
     // Revert is a pure drop: there is no revert target to commit —
     // override-covered authoritative values hold in _pendingValue and
     // elevate on their OWN transition's schedule (A18 as re-ruled 2026-07-07).
     if (!(node._statusFlags & STATUS_PENDING)) node._statusFlags &= ~STATUS_UNINITIALIZED;
-    const prevOverride = node._overrideValue;
-    node._overrideValue = NOT_PENDING;
+    const prevOverride = node._x?._overrideValue;
+    ext(node)._overrideValue = NOT_PENDING;
     if (prevOverride !== NOT_PENDING && node._value !== unwrapOverride(prevOverride))
       insertSubs(node, true);
     node._transition = null;
-    node._overrideOwner = null;
+    if (node._x !== null) node._x._overrideOwner = null;
   }
   // Settlement checkpoint (#2838): companions caught in this batch (or owned
   // by a node in it) re-derive from committed state, so verdicts survive the
   // transition that produced them (A19 — pending is a property of the data).
   for (let i = 0; i < len; i++) {
     const node = nodes[i];
-    if (node._pendingSignal || node._latestValueComputed) GlobalQueue._snapCompanions(node);
-    const owner = node._parentSource;
-    if (owner && (owner._pendingSignal === node || owner._latestValueComputed === node))
+    if (node._x?._pendingSignal || node._x?._latestValueComputed) GlobalQueue._snapCompanions(node);
+    const owner = node._x?._parentSource;
+    if (owner && (owner._x?._pendingSignal === node || owner._x?._latestValueComputed === node))
       GlobalQueue._snapCompanions(owner);
   }
   nodes.splice(0, len);
@@ -3746,7 +4628,8 @@ function cleanupCompletedLanes(completingTransition) {
       if (lane._effectQueues[0].length) runQueue(lane._effectQueues[0], EFFECT_RENDER);
       if (lane._effectQueues[1].length) runQueue(lane._effectQueues[1], EFFECT_USER);
     }
-    if (lane._source._optimisticLane === lane) lane._source._optimisticLane = undefined;
+    if (lane._source._x?._optimisticLane === lane)
+      if (lane._source._x !== null) lane._source._x._optimisticLane = undefined;
     lane._pendingAsync.clear();
     lane._effectQueues[0].length = 0;
     lane._effectQueues[1].length = 0;
@@ -3759,7 +4642,7 @@ function laneSuspends(owner) {
   // 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)
-  const pendingLane = owner._optimisticLane;
+  const pendingLane = owner._x?._optimisticLane;
   if (!pendingLane) return false;
   return findLane(pendingLane) === findLane(currentOptimisticLane) && !hasActiveOverride$1(owner);
 }
@@ -3786,21 +4669,36 @@ function gatedRead(el, owner, c) {
  */
 function laneReadsCommitted(el, owner, c) {
   if (
-    el._overrideValue !== undefined ||
-    !!el._optimisticLane ||
+    el._x?._overrideValue !== undefined ||
+    !!el._x?._optimisticLane ||
     !!(owner._statusFlags & STATUS_PENDING)
-  )
+  ) {
+    // The committed view hides a staged in-flight value that will promote
+    // silently (commitPendingNode never re-notifies). gatedRead records plain
+    // signals for replay at commit; async memos are excluded from it by the
+    // `_fn` check and reach here instead — a lane-assigned source whose async
+    // already settled (laneAsyncSettled keeps _optimisticLane) served its
+    // committed value to a reader that never re-ran after the landing, so a
+    // pending-gated branch stayed one value behind permanently (#3041
+    // follow-up). Record the reader under the same replay contract.
+    if (el._pendingValue !== NOT_PENDING)
+      (activeTransition ?? globalQueue._batch)._gatedSubs.add(c);
     return true;
-  if (owner === el && stale && c._parentSource !== el) {
-    // The committed view can hide a same-tick ambient write (a lane member —
-    // even just an isPending companion flip — puts the reader "under a lane"
-    // against unrelated plain writes). With no transaction the write commits
-    // at THIS flush's end with no re-delivery, so record the reader for
-    // replay at commit — the same contract gatedRead provides when a
-    // transaction is active (#2963). If a transaction forms mid-flush,
-    // initTransition carries the recording over to it.
-    if (el._pendingValue !== NOT_PENDING && activeTransition === null)
-      globalQueue._batch._gatedSubs.add(c);
+  }
+  if (owner === el && stale && c._x?._parentSource !== el) {
+    // The committed view can hide a staged write (a lane member — even just
+    // an isPending companion flip — puts the reader "under a lane"). The
+    // staged value commits with no re-delivery (commitPendingNode never
+    // re-notifies), so record the reader for replay at commit — the same
+    // contract gatedRead provides (#2963). gatedRead itself only covers
+    // signal reads where the reading computed differs from the source; the
+    // owner === el memo/self read lands here instead. With a transaction
+    // active the staged value promotes silently at ITS landing, so record
+    // into the transaction (#3041 follow-up: a pending-gated branch that
+    // first read its async source during the landing flush stayed one value
+    // behind permanently); with none, into the ambient batch.
+    if (el._pendingValue !== NOT_PENDING)
+      (activeTransition ?? globalQueue._batch)._gatedSubs.add(c);
     return true;
   }
   return false;
@@ -3827,10 +4725,10 @@ function recomputeLane(el, own) {
       !globalQueue._running &&
       !activeTransition &&
       !lane._transition &&
-      lane._source._parentSource !== undefined &&
-      el._overrideValue === undefined
+      lane._source._x?._parentSource !== undefined &&
+      el._x?._overrideValue === undefined
     ) {
-      el._optimisticLane = undefined;
+      if (el._x !== null) el._x._optimisticLane = undefined;
       return false;
     }
     return lane;
@@ -3853,7 +4751,8 @@ function laneAsyncPending(el) {
   const lane = findLane(currentOptimisticLane);
   if (lane._source !== el) {
     lane._pendingAsync.add(el);
-    el._optimisticLane = lane;
+    ext(el)._optimisticLane = lane;
+    el._config |= CONFIG_HAS_LANE;
     GlobalQueue._updatePendingSignal !== null && GlobalQueue._updatePendingSignal(lane._source);
   }
 }
@@ -3902,18 +4801,43 @@ function installOptimisticEngine() {
 // same lanes, so the verdict layer brings the engine with it.
 installOptimisticEngine();
 let pendingProbe = null;
+/**
+ * Probes whose verdict was suppressed by the fresh-read pairing rule while
+ * the held write's fate was still undecided (see recordFreshRead /
+ * wakeSuppressedProbes): held node → the wrapper computeds that probed it.
+ * Entries die with the hold — the commit/revert snap clears them.
+ */
+const suppressedProbes = new Map();
 /**
  * Get or create the pending signal for a node (lazy).
  * Used by isPending() to track pending state reactively.
  */
+/** #3038: register a companion-carrying firewall child on its firewall's
+ * companion set and arm the post-recompute snap (CONFIG_CHILD_COMPANIONS is
+ * the one-load gate at the call sites). The snap then iterates exactly the
+ * children someone asked verdicts of — O(companions) — never the full
+ * `_child` chain, which carries one node per materialized leaf (the
+ * O(all-leaves-ever-read)-per-update pathology). Entries are permanent like
+ * the companions themselves; a store with no leaf-level isPending()/latest()
+ * reads never allocates the set or pays the walk. */
+function markFirewallChildCompanions(el) {
+  const fw = el._firewall;
+  if (!fw) return;
+  fw._config |= CONFIG_CHILD_COMPANIONS;
+  (ext(fw)._companionChildren ??= new Set()).add(el);
+}
 function getPendingSignal(el) {
-  if (!el._pendingSignal) {
+  let ps = el._x?._pendingSignal;
+  if (!ps) {
     // Start false, write true if pending - ensures reversion returns to false
-    el._pendingSignal = optimisticSignal(false, { ownedWrite: true });
-    el._pendingSignal._parentSource = el;
-    if (computePendingState(el)) setSignal(el._pendingSignal, true);
+    ps = optimisticSignal(false, { ownedWrite: true });
+    ext(el)._pendingSignal = ps;
+    el._config |= CONFIG_HAS_COMPANIONS;
+    markFirewallChildCompanions(el);
+    ext(ps)._parentSource = el;
+    if (computePendingState(el)) setSignal(ps, true);
   }
-  return el._pendingSignal;
+  return ps;
 }
 function collectPendingSources(el) {
   if (!pendingProbe) return;
@@ -3942,7 +4866,7 @@ function witnessAffects(node) {
  * inherits the coverage it reports on.
  */
 function markWalk(el, seen) {
-  if (el._affectsCount) return true;
+  if (el._x?._affectsCount) return true;
   // A real error outranks an inherited mark (A16/A24c): an errored node
   // answers probes with its error, not a coverage verdict, and coverage does
   // not flow through it — matching the rails' behavior, where propagation
@@ -3972,11 +4896,11 @@ function markCovered(el) {
   return activeAffectsMarks !== 0 && markWalk(el, new Set());
 }
 function quietPending(el) {
-  if (el._pendingSources) {
-    for (const source of el._pendingSources) if (!source._reask) return false;
+  if (el._x?._pendingSources) {
+    for (const source of el._x._pendingSources) if (!source._x?._reask) return false;
     return true;
   }
-  return el._reask;
+  return el._x?._reask ?? false;
 }
 // NOTE: a loadingValue node's open loading window (_loading) is verdict-quiet
 // on purpose: commit #0 answers the question by declaration, so the window
@@ -4000,15 +4924,15 @@ function computePendingState(el) {
   // so the one walk covers direct marks, derivation, and companion chains.
   if (markCovered(el)) return true;
   const firewall = el._firewall;
-  if (el._parentSource) {
-    const parentNode = el._parentSource;
+  if (el._x?._parentSource) {
+    const parentNode = el._x?._parentSource;
     const parent = parentNode._firewall || parentNode;
     return newQuestionInFlight(parent);
   }
   if (firewall && el._pendingValue !== NOT_PENDING && !hasActiveOverride$1(el)) {
     return (
       !!(firewall._flags & REACTIVE_MANUAL_WRITE) ||
-      (!firewall._inFlight && !(firewall._statusFlags & STATUS_PENDING)) ||
+      (!firewall._x?._inFlight && !(firewall._statusFlags & STATUS_PENDING)) ||
       (!!(firewall._statusFlags & STATUS_PENDING) && quietPending(firewall))
     );
   }
@@ -4022,25 +4946,25 @@ function computePendingState(el) {
     !comp._loading
   ) {
     if (hasActiveOverride$1(el))
-      return !el._equals || !el._equals(el._pendingValue, unwrapOverride(el._overrideValue));
+      return !el._equals || !el._equals(el._pendingValue, unwrapOverride(el._x?._overrideValue));
     return true;
   }
   return newQuestionInFlight(comp);
 }
 function syncCompanions(el, value) {
-  if (el._pendingSignal) updatePendingSignal(el);
-  if (el._latestValueComputed) setSignal(el._latestValueComputed, value);
+  if (el._x?._pendingSignal) updatePendingSignal(el);
+  if (el._x?._latestValueComputed) setSignal(el._x?._latestValueComputed, value);
 }
 function updatePendingSignal(el) {
-  if (el._pendingSignal) {
-    setSignal(el._pendingSignal, computePendingState(el));
+  if (el._x?._pendingSignal) {
+    setSignal(el._x?._pendingSignal, computePendingState(el));
   }
-  if (el._latestValueComputed) updatePendingSignal(el._latestValueComputed);
+  if (el._x?._latestValueComputed) updatePendingSignal(el._x?._latestValueComputed);
 }
 function updateChildCompanions(el) {
-  for (let child = el._child; child !== null; child = child._nextChild) {
-    if (child._pendingSignal || child._latestValueComputed) updatePendingSignal(child);
-  }
+  const companions = el._x?._companionChildren;
+  if (companions === undefined) return;
+  for (const child of companions) updatePendingSignal(child);
 }
 /**
  * Re-derive every verdict companion downstream of `el` (subs + firewall
@@ -4057,30 +4981,65 @@ function repollDownstreamVerdicts(el, snap = false) {
   const visit = node => {
     if (visited.has(node)) return;
     visited.add(node);
-    if (node._pendingSignal || node._latestValueComputed) update(node);
+    if (node._x?._pendingSignal || node._x?._latestValueComputed) update(node);
     for (let s = node._subs; s !== null; s = s._nextSub) visit(s._sub);
-    for (let child = node._child ?? null; child !== null; child = child._nextChild) {
+    for (let child = node._x?._child ?? null; child !== null; child = child._nextChild) {
       visit(child);
     }
   };
   visit(el);
 }
+/**
+ * The correction half of the provisional fresh-read suppression (see
+ * collectPending): fired from the sanctioned async-registration site
+ * (GlobalQueue.notify) when a transaction gains an in-flight async blocker.
+ * Every probe that returned "not pending" purely because it read a held
+ * value belonging to that transaction re-runs — its re-probe now sees the
+ * live blocker through heldAwaitingAsync and lands the true verdict. The
+ * wake mirrors a companion write's own notification (optimistic-dirty on the
+ * companion's lane) so the corrected verdict commits and flushes immediately
+ * instead of being held with the transaction it reports on.
+ */
+function wakeSuppressedProbes(transition) {
+  if (suppressedProbes.size === 0) return;
+  let woke = false;
+  for (const [node, probes] of suppressedProbes) {
+    const nt = node._transition;
+    const t = nt ? currentTransition(nt) : null;
+    if (!t) {
+      suppressedProbes.delete(node);
+      continue;
+    }
+    if (t !== transition) continue;
+    suppressedProbes.delete(node);
+    const lane = node._x?._pendingSignal?._x?._optimisticLane;
+    for (const p of probes) {
+      if (p._flags & REACTIVE_DISPOSED) continue;
+      p._flags |= REACTIVE_OPTIMISTIC_DIRTY;
+      if (lane) assignOrMergeLane(p, lane);
+      else if (p._x !== null) p._x._optimisticLane = undefined;
+      enqueueSub(p);
+      woke = true;
+    }
+  }
+  if (woke) schedule();
+}
 function snapCompanionsToState(owner) {
-  const sig = owner._pendingSignal;
-  if (sig && (sig._overrideValue === undefined || sig._overrideValue === NOT_PENDING)) {
+  suppressedProbes.size !== 0 && suppressedProbes.delete(owner);
+  const sig = owner._x?._pendingSignal;
+  if (sig && (sig._x?._overrideValue === undefined || sig._x?._overrideValue === NOT_PENDING)) {
     const pending = computePendingState(owner);
     if (sig._value !== pending || sig._pendingValue !== NOT_PENDING) {
       sig._value = pending;
       sig._pendingValue = NOT_PENDING;
-      sig._time = clock;
       insertSubs(sig);
       schedule();
     }
   }
-  const shadow = owner._latestValueComputed;
+  const shadow = owner._x?._latestValueComputed;
   if (shadow && !(shadow._flags & REACTIVE_DISPOSED)) {
     if (
-      (shadow._overrideValue === undefined || shadow._overrideValue === NOT_PENDING) &&
+      (shadow._x?._overrideValue === undefined || shadow._x?._overrideValue === NOT_PENDING) &&
       shadow._pendingValue === NOT_PENDING &&
       !Object.is(shadow._value, owner._value) &&
       !(shadow._flags & (REACTIVE_DIRTY | REACTIVE_CHECK))
@@ -4094,20 +5053,37 @@ function snapCompanionsToState(owner) {
   }
 }
 function getLatestValueComputed(el) {
-  if (!el._latestValueComputed) {
+  let lvc = el._x?._latestValueComputed;
+  // A shadow disposed while unobserved (its gated reader unmounted at a
+  // landing) is a corpse: sync writes into it equality-swallow against its
+  // frozen _value, and a later read revives it via recompute — clearing
+  // DISPOSED and re-deriving from the committed view, so the banner showed
+  // the previous transition's target (#3041 follow-up). Treat it as absent;
+  // recreation backfills from the in-flight write below.
+  if (lvc && lvc._flags & REACTIVE_DISPOSED) lvc = undefined;
+  if (!lvc) {
     const prevPending = latestReadActive;
     setLatestReadActive(false);
     const prevCheck = pendingCheckActive;
     setPendingCheckActive(false);
     const prevContext = context;
     setContextInternal(null); // Detach from owner so it isn't disposed with effects
-    el._latestValueComputed = optimisticComputed(() => read(el));
-    el._latestValueComputed._parentSource = el; // Parent-child lane relationship
+    lvc = optimisticComputed(() => read(el));
+    ext(el)._latestValueComputed = lvc;
+    el._config |= CONFIG_HAS_COMPANIONS;
+    markFirewallChildCompanions(el);
+    ext(lvc)._parentSource = el; // Parent-child lane relationship
+    // Backfill an in-flight write (mirrors getPendingSignal): the companion is
+    // created lazily, possibly after the write was processed — syncCompanions
+    // only pushes into companions that already exist, so the first latest()
+    // read inside a held transition showed the committed value (#3041).
+    if (el._pendingValue !== NOT_PENDING && !hasActiveOverride$1(el))
+      setSignal(lvc, el._pendingValue);
     setContextInternal(prevContext);
     setPendingCheckActive(prevCheck);
     setLatestReadActive(prevPending);
   }
-  return el._latestValueComputed;
+  return lvc;
 }
 /** The latest()-mode read path, installed as GlobalQueue._latestRead. */
 function latestRead(el) {
@@ -4115,8 +5091,8 @@ function latestRead(el) {
   const prevPending = latestReadActive;
   setLatestReadActive(false);
   const visibleValue =
-    el._overrideValue !== undefined && el._overrideValue !== NOT_PENDING
-      ? unwrapOverride(el._overrideValue)
+    el._x?._overrideValue !== undefined && el._x?._overrideValue !== NOT_PENDING
+      ? unwrapOverride(el._x?._overrideValue)
       : el._value;
   let value;
   try {
@@ -4142,8 +5118,8 @@ function latestRead(el) {
     setLatestReadActive(prevPending);
   }
   if (pendingComputed._statusFlags & STATUS_PENDING) return visibleValue;
-  if (stale && currentOptimisticLane && pendingComputed._optimisticLane) {
-    const pcLane = findLane(pendingComputed._optimisticLane);
+  if (stale && currentOptimisticLane && pendingComputed._x?._optimisticLane) {
+    const pcLane = findLane(pendingComputed._x?._optimisticLane);
     const curLane = findLane(currentOptimisticLane);
     if (pcLane !== curLane && pcLane._pendingAsync.size > 0) {
       return visibleValue;
@@ -4169,21 +5145,47 @@ function pendingCheckRead(el, c, owner, firewall) {
   if (c && ownerStatus & STATUS_PENDING && ownerStatus & STATUS_UNINITIALIZED) {
     if (tracking && el !== c) link(el, c);
     setPendingCheckActive(true);
-    throw owner._error;
+    throw owner._x?._error;
   }
   collectPendingSources(el);
   if (firewall) collectPendingSources(firewall);
   setPendingCheckActive(true);
 }
+/**
+ * A held node whose transaction still has an async question in flight. The
+ * probe's fresh-read pairing rule (#2831 — "a reader that sees the fresh
+ * value must not also be told it is pending") only applies to LANDED answers
+ * awaiting reveal; while the answer is still computing, the fresh value the
+ * reader saw is an input, and pending remains the truth for every reader
+ * (#3028).
+ */
+function heldAwaitingAsync(el) {
+  const et = el._transition;
+  const t = et ? currentTransition(et) : null;
+  if (!t || t._done) return false;
+  for (const [source, reporters] of t._asyncReporters) {
+    if (
+      reporters.size &&
+      source._statusFlags & STATUS_PENDING &&
+      source._x?._error?.source === source
+    )
+      return true;
+  }
+  return false;
+}
 function recordFreshRead(el, value) {
-  if (pendingProbe !== null && el._pendingValue !== NOT_PENDING && value === el._pendingValue)
+  if (pendingProbe !== null && el._pendingValue !== NOT_PENDING && value === el._pendingValue) {
+    if (heldAwaitingAsync(el)) return;
     pendingProbe.freshReads.add(el);
+  }
 }
 function applyReask(el, hadReask) {
   const wasPending = !!(el._statusFlags & STATUS_PENDING);
-  const isReask = hadReask && !(wasPending && !el._reask);
-  const changed = wasPending && el._reask !== isReask;
-  el._reask = isReask;
+  const isReask = hadReask && !(wasPending && !el._x?._reask);
+  const changed = wasPending && (el._x?._reask ?? false) !== isReask;
+  // Allocation-free for the quiet case: false is the extension default.
+  if (isReask) ext(el)._reask = true;
+  else if (el._x !== null) el._x._reask = false;
   return changed;
 }
 function latest(fn) {
@@ -4202,7 +5204,8 @@ function isPending(fn) {
   const probe = (pendingProbe = {
     found: false,
     sources: new Set(),
-    freshReads: new Set()
+    freshReads: new Set(),
+    suppressed: []
   });
   const collectPending = () => {
     setPendingCheckActive(false);
@@ -4210,12 +5213,27 @@ function isPending(fn) {
     setStrictRead(false);
     try {
       probe.sources.forEach(source => {
-        if (read(getPendingSignal(source)) && !probe.freshReads.has(source)) probe.found = true;
+        if (read(getPendingSignal(source))) {
+          if (!probe.freshReads.has(source)) probe.found = true;
+          else probe.suppressed.push(source);
+        }
       });
     } finally {
       setStrictRead(prevStrictRead);
       setPendingCheckActive(true);
     }
+    // A "not pending" verdict that exists only because this reader saw the
+    // fresh held value is provisional: if the write turns out NOT to commit
+    // this flush (a downstream async pends and holds it), the suppression was
+    // wrong and the wrapper must re-ask (#3028). Remember who to wake — the
+    // async registration (GlobalQueue.notify) triggers wakeSuppressedProbes.
+    if (!probe.found && probe.suppressed.length && context && typeof context._fn === "function") {
+      for (const source of probe.suppressed) {
+        let probes = suppressedProbes.get(source);
+        if (!probes) suppressedProbes.set(source, (probes = new Set()));
+        probes.add(context);
+      }
+    }
   };
   try {
     fn();
@@ -4247,6 +5265,7 @@ GlobalQueue._recordFresh = recordFreshRead;
 GlobalQueue._applyReask = applyReask;
 GlobalQueue._repollVerdicts = repollDownstreamVerdicts;
 GlobalQueue._witnessAffects = witnessAffects;
+GlobalQueue._wakeSuppressedProbes = wakeSuppressedProbes;
 
 /**
  * Effects are the leaf nodes of our reactive graph. When their sources change, they are
@@ -4286,7 +5305,7 @@ function effect(compute, effect, error, options) {
 function notifyEffectStatus(status, error) {
   // Use passed values if provided, otherwise read from node
   const actualStatus = status !== undefined ? status : this._statusFlags;
-  const actualError = error !== undefined ? error : this._error;
+  const actualError = error !== undefined ? error : this._x?._error;
   if (actualStatus & STATUS_ERROR) {
     this._queue.notify(this, STATUS_PENDING, 0);
     if (this._type === EFFECT_USER) {
@@ -4345,7 +5364,7 @@ function runEffect(node) {
   // notifyEffectStatus, and a runner queued by an earlier valueChanged in the
   // same flush must not be hijacked by a later-arriving error status.
   if (node._statusFlags & STATUS_ERROR && node._type === EFFECT_USER) {
-    const err = unwrapStatusError(node._error);
+    const err = unwrapStatusError(node._x?._error);
     node._prevValue = node._value;
     node._modified = false;
     try {
@@ -4382,7 +5401,7 @@ function runEffect(node) {
     // The final cleanup is invoked by disposeChildren at true disposal.
     node._cleanup = nextCleanup;
   } catch (error) {
-    node._error = new StatusError(node, error);
+    ext(node)._error = new StatusError(node, error);
     node._statusFlags |= STATUS_ERROR;
     if (!node._queue.notify(node, STATUS_ERROR, STATUS_ERROR)) {
       haltReactivity(error);
@@ -4433,11 +5452,11 @@ function trackedEffect(fn, options) {
   node._config = (node._config & ~CONFIG_AUTO_DISPOSE) | CONFIG_CHILDREN_FORBIDDEN;
   node._modified = true;
   node._type = EFFECT_TRACKED;
-  node._notifyStatus = (status, error) => {
+  ext(node)._notifyStatus = (status, error) => {
     const actualStatus = status !== undefined ? status : node._statusFlags;
     if (actualStatus & STATUS_ERROR) {
       node._queue.notify(node, STATUS_PENDING, 0);
-      const err = error !== undefined ? error : node._error;
+      const err = error !== undefined ? error : node._x?._error;
       if (!node._queue.notify(node, STATUS_ERROR, STATUS_ERROR)) {
         haltReactivity(unwrapStatusError(err));
         throw err;
@@ -5207,7 +6226,7 @@ function inheritAffectsMarks(node, raw, property) {
   // A live scope exists, so affects.ts already installed the mark engine.
   for (const [carrier, entry] of affectsScopes) {
     if (
-      carrier._affectsCount &&
+      carrier._x?._affectsCount &&
       entry.scope.has(raw) &&
       (entry.key === undefined || entry.key === property)
     ) {
@@ -5327,7 +6346,7 @@ function witnessAffectsMark(target, property) {
   // Callers guard on `pendingCheckActive`, which only flips inside
   // isPending() — the verdict layer is loaded and its hook installed.
   const own = target[STORE_NODE]?.[$AFFECTS];
-  if (own?._affectsCount) GlobalQueue._witnessAffects(own);
+  if (own?._x?._affectsCount) GlobalQueue._witnessAffects(own);
   if (affectsScopes.size) {
     // Chained backings (§7b): a wrapper's STORE_VALUE can be another store's
     // proxy — marks cover by identity of the BASE raw, so resolve the chain
@@ -5336,7 +6355,7 @@ function witnessAffectsMark(target, property) {
     for (const [carrier, entry] of affectsScopes) {
       if (
         carrier !== own &&
-        carrier._affectsCount &&
+        carrier._x?._affectsCount &&
         (entry.key === undefined || entry.key === property)
       ) {
         let r = raw;
@@ -5404,7 +6423,7 @@ function getStoreAffectsNodes(target, key) {
  * mid-window recomputes.
  */
 function markAffects(node) {
-  node._affectsCount = (node._affectsCount || 0) + 1;
+  ext(node)._affectsCount = (node._x?._affectsCount || 0) + 1;
   shiftAffectsMarks(1);
 }
 /**
@@ -5420,7 +6439,7 @@ function markAffects(node) {
  * no visual change.
  */
 function notifyMarkBoundaries(node) {
-  if (!node._subs && !node._child) return;
+  if (!node._subs && !node._x?._child) return;
   const error = new NotReadyError(node);
   error._markVisual = true;
   const visited = new Set();
@@ -5429,8 +6448,8 @@ function notifyMarkBoundaries(node) {
     visited.add(sub);
     // Display consumers (render effects, boundary computeds) act on the
     // notification; descent stops there, exactly like the status rails.
-    if (sub._notifyStatus) {
-      sub._notifyStatus(STATUS_PENDING, error);
+    if (sub._x?._notifyStatus) {
+      sub._x._notifyStatus.call(sub, STATUS_PENDING, error);
       return;
     }
     forEachDependent(sub, visit);
@@ -5463,8 +6482,8 @@ function registerAffectsMark(node) {
  */
 function releaseAffectsMark(node) {
   shiftAffectsMarks(-1);
-  node._affectsCount--;
-  if (!node._affectsCount) {
+  node._x._affectsCount--;
+  if (!node._x._affectsCount) {
     GlobalQueue._repollVerdicts !== null && GlobalQueue._repollVerdicts(node, true);
     GlobalQueue._releaseAffectsScope?.(node);
   }
@@ -5558,13 +6577,46 @@ function affects(target, key) {
  */
 // ---------------------------------------------------------------------------
 // wrap / dedupe
+/** Pre-shaped constructor for OBJECT proxy targets: V8 tips a bare `{}` into
+ * dictionary mode once ~19 named properties are assigned onto it (the #3044
+ * `ovl`/`del` fields crossed that line — every trap's field read became a
+ * hash lookup, a 15% deep-dbmon tick regression). Declaring every field in a
+ * constructor pre-allocates in-object slots so the map stays fast, with
+ * headroom for future fields. The prototype is reset to `Object.prototype`
+ * so proxy-forwarded semantics (getPrototypeOf, constructor) are exactly a
+ * plain object's. Array targets keep the bare-`[]` path — they must carry
+ * the array exotic class for `Array.isArray(proxy)`, and arrays store named
+ * fields off-object where this cliff does not apply. */
+function TargetShape() {
+  this.v = undefined;
+  this.ch = undefined;
+  this.pb = undefined;
+  this.n = undefined;
+  this.h = undefined;
+  this.k = undefined;
+  this.dk = undefined;
+  this.u = undefined;
+  this.pk = undefined;
+  this.px = undefined;
+  this.d = undefined;
+  this.a = undefined;
+  this.sc = undefined;
+  this.nc = undefined;
+  this.adopted = undefined;
+  this.fam = undefined;
+  this.s = undefined;
+  this.ovl = undefined;
+  this.del = undefined;
+  this.wk = undefined;
+}
+TargetShape.prototype = Object.prototype;
 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.
   // Direct field assignment in one fixed order (no Object.assign literal
   // copy): every target shares a hidden-class transition chain — createTarget
   // was the #2 store cost in the uibench creation profile.
-  const t = Array.isArray(value) ? [] : {};
+  const t = Array.isArray(value) ? [] : new TargetShape();
   t.v = value;
   // Chained-backing flag (backing IS another store's proxy, §7b) — cached so
   // the hot read path never does a per-read symbol lookup on the backing.
@@ -5584,6 +6636,9 @@ function createTarget(value, parent, parentKey, fam = parent?.fam ?? null) {
   t.adopted = false;
   t.fam = fam;
   t.s = false;
+  t.ovl = false;
+  t.del = null;
+  t.wk = null;
   t.px = new Proxy(t, traps);
   // Legacy interop: shared machinery (affects walks, wrap dedupe) reads the
   // proxy off looked-up targets as a field.
@@ -5610,7 +6665,13 @@ function wrapNext(value, parent = null, parentKey = null, fam = parent?.fam ?? n
 function unwrapValue(v) {
   if (v == null || typeof v !== "object") return v;
   const t = v[$TARGET];
-  if (t !== undefined && t.px === v && t.v !== undefined) return t.pb ?? t.v;
+  if (t !== undefined && t.px === v && t.v !== undefined) {
+    // A draft escaping into other storage must be a REAL container that
+    // becomes this target's committed backing at fold (the shared-raw
+    // contract) — a prototype overlay is neither.
+    if (t.ovl) materializePB(t);
+    return t.pb ?? t.v;
+  }
   return v;
 }
 // ---------------------------------------------------------------------------
@@ -5622,13 +6683,19 @@ function getNode(target, key, current) {
     const created = (node = signal(
       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._affectsCount) return;
+          if (created._x?._affectsCount) return;
           if (target.n && target.n[key] === created) {
             delete target.n[key];
             target.nc--;
@@ -5655,7 +6722,10 @@ function getNode(target, key, current) {
     created.pxv = undefined;
     // Optimistic families: arm the override slot — setSignal routes armed
     // nodes through the core engine (lanes, ownership, reverts all native).
-    if (target.fam?.opt) created._overrideValue = NOT_PENDING;
+    if (target.fam?.opt) {
+      ext(created)._overrideValue = NOT_PENDING;
+      created._config |= CONFIG_OPTIMISTIC;
+    }
     // A node born inside a live mark's identity scope inherits the mark
     // (the declaration walk could only cover nodes existing then).
     if (key !== $AFFECTS && affectsScopesLive()) inheritAffectsMarks(created, target.v, key);
@@ -5680,14 +6750,17 @@ function getHasNode(target, key, present) {
       {
         equals: isEqual,
         unobserved() {
-          if (created._affectsCount) return;
+          if (created._x?._affectsCount) return;
           if (target.h && target.h[key] === created) delete target.h[key];
         }
       },
       target.fam?.node ?? undefined
     ));
     created._config |= CONFIG_OWNED_WRITE;
-    if (target.fam?.opt) created._overrideValue = NOT_PENDING;
+    if (target.fam?.opt) {
+      ext(created)._overrideValue = NOT_PENDING;
+      created._config |= CONFIG_OPTIMISTIC;
+    }
     if (affectsScopesLive()) inheritAffectsMarks(created, target.v, key);
     nodes[key] = node;
     markDescendants(target);
@@ -5708,7 +6781,10 @@ function getKeySetNode(target) {
       target.fam?.node ?? undefined
     ));
     created._config |= CONFIG_OWNED_WRITE;
-    if (target.fam?.opt) created._overrideValue = NOT_PENDING;
+    if (target.fam?.opt) {
+      ext(created)._overrideValue = NOT_PENDING;
+      created._config |= CONFIG_OPTIMISTIC;
+    }
     target.k = k;
     markDescendants(target);
   }
@@ -5728,7 +6804,10 @@ function getDeepNode(target) {
       target.fam?.node ?? undefined
     ));
     created._config |= CONFIG_OWNED_WRITE;
-    if (target.fam?.opt) created._overrideValue = NOT_PENDING;
+    if (target.fam?.opt) {
+      ext(created)._overrideValue = NOT_PENDING;
+      created._config |= CONFIG_OPTIMISTIC;
+    }
     if (affectsScopesLive()) inheritAffectsMarks(created, target.v, $TRACK);
     target.dk = dk;
     markDescendants(target);
@@ -5771,10 +6850,62 @@ function cloneRaw(source, t) {
     ? Object.defineProperties([], descs)
     : Object.create(Object.getPrototypeOf(source), descs);
 }
+/** One-time own-accessor scan (Annex-B probes, no descriptor allocation);
+ * returns true when the container is plain data (overlay-safe). */
+function scanAccessorsOnce(target) {
+  const src = target.v;
+  for (const key of Reflect.ownKeys(src)) {
+    // Own keys shadow prototype accessors, so the lookups are exact here.
+    if (lookupGetter.call(src, key) !== undefined || lookupSetter.call(src, key) !== undefined) {
+      target.a = true;
+      break;
+    }
+  }
+  target.sc = true;
+  return !target.a;
+}
+/** Downgrade a prototype-overlay pending backing to the clone path: builds
+ * the real container (committed + overlay writes − deletes) that fold will
+ * SWAP in as the committed backing, exactly as if the draft had started on
+ * the clone path. Consumers that need a complete container (reconcile's
+ * diff walks, drafts escaping into other storage) call this. */
+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;
+  }
+  if (target.del !== null) {
+    for (const key of target.del) delete clone[key];
+    target.del = null;
+  }
+  const map = target.fam?.map ?? storeNextLookup;
+  map.delete(proto);
+  ownedRaw.add(clone);
+  map.set(clone, target);
+  target.pb = clone;
+  target.ovl = false;
+}
 function ensurePB(target) {
   let pb = target.pb;
   if (pb === null) {
-    pb = target.pb = cloneRaw(target.v, target);
+    // Prototype-chain overlay (#3044): plain-data non-array containers
+    // outside projection/optimistic families open drafts in O(1) — own keys
+    // are the writes, reads fall through to committed. Everything else
+    // (arrays: splice/length semantics; families: seeding/revert machinery;
+    // accessor containers: live getters) keeps the descriptor clone.
+    if (
+      target.fam === null &&
+      !Array.isArray(target.v) &&
+      (target.sc ? !target.a : scanAccessorsOnce(target))
+    ) {
+      pb = target.pb = Object.create(target.v);
+      target.ovl = true;
+    } else pb = target.pb = cloneRaw(target.v, target);
     // Optimistic families: seed USER drafts from the OPTIMISTIC VIEW
     // (committed + active node overrides), so follow-up writes compose on
     // optimism instead of clobbering from base (#2951's compose half).
@@ -5786,14 +6917,14 @@ function ensurePB(target) {
       if (nodes !== null) {
         for (const key of Reflect.ownKeys(nodes)) {
           const node = nodes[key];
-          if (hasActiveOverride(node)) pb[key] = unwrapOverride(node._overrideValue);
+          if (hasActiveOverride(node)) pb[key] = unwrapOverride(node._x?._overrideValue);
         }
       }
       const has = target.h;
       if (has !== null) {
         for (const key of Reflect.ownKeys(has)) {
           const node = has[key];
-          if (hasActiveOverride(node) && !unwrapOverride(node._overrideValue)) delete pb[key];
+          if (hasActiveOverride(node) && !unwrapOverride(node._x?._overrideValue)) delete pb[key];
         }
       }
     }
@@ -5820,6 +6951,18 @@ function adoptPB(target, incoming, eager = false) {
     target.adopted = true;
   }
   target.pb = null;
+  // Overlay and accessor-scan state describe the OUTGOING backing — a
+  // swapped container must not inherit them: a stale `ovl` beside a nulled
+  // pb crashes materializePB (unwrapValue consults ovl before the
+  // null-coalesce), a stale `del` would read the adoptee's keys as deleted
+  // in the next draft, and a stale plain-data verdict (`sc`/`a`) could
+  // admit an accessor-bearing adoptee to the overlay path. Reset; the next
+  // draft rescans once (#3044 audit follow-up).
+  target.ovl = false;
+  target.del = null;
+  target.wk = null; // adoption supersedes any staged trap writes
+  target.sc = false;
+  target.a = false;
   target.v = incoming;
   target.ch = incoming[$TARGET] !== undefined;
   (target.fam?.map ?? storeNextLookup).set(incoming, target);
@@ -5863,9 +7006,17 @@ function drainFolds() {
       const pb = t.pb;
       const nodes = t.n;
       if (nodes !== null) {
-        for (const key of Reflect.ownKeys(nodes)) {
+        // 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.wk;
+        const keys =
+          wkh === null || wkh === WK_ALL || t.a === true || !plainProto(t.ovl ? t.v : pb)
+            ? Reflect.ownKeys(nodes)
+            : wkh;
+        for (const key of keys) {
           const node = nodes[key];
-          if (node._pendingValue !== NOT_PENDING) {
+          if (node !== undefined && node._pendingValue !== NOT_PENDING) {
             held = true;
             break;
           }
@@ -5875,9 +7026,36 @@ function drainFolds() {
         foldOlds.set(t, old); // re-queue: commit happens when the hold settles
         continue;
       }
-      t.v = pb;
-      t.ch = false; // pb is always a plain clone
-      t.pb = null;
+      if (t.ovl) {
+        // Overlay flatten (#3044): apply this batch's writes onto an OWNED
+        // committed backing in place — O(written), not O(container). The
+        // backing keeps its identity, so the `t.v === old` gate below skips
+        // path copying (the parent slot already points here) and the
+        // adopted-notify (setter notifications happened at write time).
+        // Unowned backings privatize first (clone once, parents re-slotted)
+        // — 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;
+        }
+        if (t.del !== null) {
+          for (const key of t.del) delete v[key];
+          t.del = null;
+        }
+        (t.fam?.map ?? storeNextLookup).delete(pb);
+        t.pb = null;
+        t.ovl = false;
+        t.wk = null; // written-keys window closes with the fold commit
+      } else {
+        t.v = pb;
+        t.ch = false; // pb is always a plain clone
+        t.pb = null;
+        t.wk = null; // written-keys window closes with the fold commit
+      }
     }
     if (t.v === old) continue; // adopted then re-adopted back, or no-op
     // Path copying (CAS: see the eager-fold twin above).
@@ -5900,8 +7078,19 @@ function drainFolds() {
  * "pending home = the node when a node exists"). Unobserved keys stay in the
  * pending backing and fold directly at commit.
  */
+/** Sentinel for `t.wk`: the written-keys bound is unusable this batch (an
+ * array length write implicitly deleted indices) — consumers full-scan. */
+const WK_ALL = new Set();
+/** Plain-prototype check for the written-keys bound: prototype getters on
+ * class instances can derive from ANY field, so only plain-data containers
+ * may bound the notify to written keys. Overlay pbs chain to the COMMITTED
+ * object (#3044), so overlay plainness is judged on the committed proto. */
+const plainProto = o => {
+  const p = Object.getPrototypeOf(o);
+  return p === Object.prototype || p === Array.prototype || p === null;
+};
 function notifyWrites(t) {
-  const pb = t.pb;
+  let pb = t.pb;
   if (pb === null) return;
   // Optimistic channel: user writes on an optimistic family become node-level
   // engine writes (armed nodes route setSignal through optimisticWrite) — the
@@ -5931,8 +7120,11 @@ function notifyWrites(t) {
   }
   const old = t.v;
   // Devtools mutation hook: full-key diff (dev-only cost) so unobserved
-  // writes report too, matching the legacy set-trap hook.
+  // writes report too, matching the legacy set-trap hook. Overlay backings
+  // materialize first so the diff walks a real container.
   if (DEV$1.hooks.onStoreNodeUpdate) {
+    if (t.ovl) materializePB(t);
+    pb = t.pb;
     for (const key of Reflect.ownKeys(pb)) {
       if (Array.isArray(pb) && key === "length") continue;
       const ov = old[key];
@@ -5945,9 +7137,20 @@ function notifyWrites(t) {
     }
   }
   const nodes = t.n;
+  // Written-keys bound: trap writes record their keys, so the notify visits
+  // O(written) nodes instead of every subscription on the record (a selection
+  // map with thousands of per-key subscribers pays two visits per select,
+  // not a full scan). Falls back to the full node scan when the bound can't
+  // hold: no trap granularity (wk null), an array length write (WK_ALL —
+  // 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.
+  const wk0 = t.wk;
+  const writtenKeys = wk0 === WK_ALL || t.a === true || !plainProto(t.ovl ? t.v : pb) ? null : wk0;
   if (nodes !== null) {
-    for (const key of Reflect.ownKeys(nodes)) {
+    const keys = writtenKeys ?? Reflect.ownKeys(nodes);
+    for (const key of keys) {
       const node = nodes[key];
+      if (node === undefined) continue;
       // Per-key accessor handling: the node's cached flag plus ONE getter
       // probe on the incoming side (getters arriving via merge/adoption).
       // Setter-only props read as data (value undefined) so lookupSetter is
@@ -5968,31 +7171,48 @@ function notifyWrites(t) {
       // projection recompute can run before the prior fold commits) — the
       // node's OWN current value is the true old side, and setSignal's
       // internal equality already checks exactly that.
-      const nv = pb[key];
+      const nv = t.del !== null && t.del.has(key) ? undefined : pb[key];
       setSignal(node, () => nv);
     }
   }
   const has = t.h;
   if (has !== null) {
-    for (const key of Reflect.ownKeys(has)) setSignal(has[key], key in pb);
+    for (const key of Reflect.ownKeys(has))
+      setSignal(has[key], key in pb && !(t.del !== null && t.del.has(key)));
   }
   // Deep-witness (dk): setter writes must notify a deep() subscriber even on
   // keys with no node. O(pb keys) equality only when a witness exists.
   if (t.dk !== null) {
-    for (const key of Reflect.ownKeys(pb)) {
-      const nv = pb[key];
-      const ov = old[key];
-      if (nv !== null && typeof nv === "object" ? !targetsEqual(ov, nv) : !isEqual(ov, nv)) {
-        bumpDeep(t);
-        break;
+    if (t.del !== null && t.del.size !== 0) bumpDeep(t);
+    else
+      for (const key of Reflect.ownKeys(pb)) {
+        const nv = pb[key];
+        const ov = old[key];
+        if (nv !== null && typeof nv === "object" ? !targetsEqual(ov, nv) : !isEqual(ov, nv)) {
+          bumpDeep(t);
+          break;
+        }
       }
-    }
   }
   if (t.k !== null) {
-    const changed =
-      Array.isArray(pb) && Array.isArray(old)
-        ? arrayStructureChanged(old, pb)
-        : membershipChanged(old, pb);
+    let changed;
+    if (t.ovl) {
+      // Overlay membership: only NEW own keys or deletes can change it.
+      changed = t.del !== null && t.del.size !== 0;
+      if (!changed) {
+        for (const key of Reflect.ownKeys(pb)) {
+          if (!hasOwn.call(old, key)) {
+            changed = true;
+            break;
+          }
+        }
+      }
+    } else {
+      changed =
+        Array.isArray(pb) && Array.isArray(old)
+          ? arrayStructureChanged(old, pb)
+          : membershipChanged(old, pb);
+    }
     if (changed) setSignal(t.k, v => v + 1);
   }
   // Projection backing folds split by channel (two pinned contracts):
@@ -6008,6 +7228,7 @@ function notifyWrites(t) {
   if (t.fam !== null && t.pb !== null && getWriteOverride()) {
     const oldBacking = t.v;
     t.pb = null;
+    t.wk = null; // written-keys window closes with the eager fold
     t.v = pb;
     t.ch = false;
     if (t.u && t.u.v[t.pk] === oldBacking) {
@@ -6278,7 +7499,7 @@ function runAuthoritative(fn) {
 /** Active optimistic override on an armed node (armed slot idles at
  * NOT_PENDING; undefined = unarmed plain node). */
 function hasActiveOverride(node) {
-  return node._overrideValue !== undefined && node._overrideValue !== NOT_PENDING;
+  return node._x?._overrideValue !== undefined && node._x?._overrideValue !== NOT_PENDING;
 }
 /** Context-aware node view for reads outside tracking: active override >
  * held pending (owner context) > the BACKING value. Committed truth lives in
@@ -6289,7 +7510,7 @@ function hasActiveOverride(node) {
  * keys, which are served by the trap, not the node). */
 function nodeValue(node, backing) {
   const v = hasActiveOverride(node)
-    ? unwrapOverride(node._overrideValue)
+    ? unwrapOverride(node._x?._overrideValue)
     : node._pendingValue !== NOT_PENDING && inOwnerContext()
       ? node._pendingValue
       : backing;
@@ -6325,7 +7546,8 @@ function serveDataKey(target, key, backingValue, src, node) {
     // #2951). Once ensurePB runs, the seeded clone carries the view.
     if (target.fam?.opt && target.pb === null) {
       const node = target.n?.[key];
-      if (node !== undefined && hasActiveOverride(node)) v = unwrapOverride(node._overrideValue);
+      if (node !== undefined && hasActiveOverride(node))
+        v = unwrapOverride(node._x?._overrideValue);
     }
   } else {
     if (node !== undefined) {
@@ -6368,6 +7590,15 @@ function serveDataKey(target, key, backingValue, src, node) {
  * link is what wakes async-memo readers when the landing writes values;
  * the firewall link rides the same read). */
 function firewallGate(target) {
+  // Own-draft ops are exempt: an async derive's continuation (generator body
+  // after an `await`/`yield`) runs OUTSIDE the sync write scope (inDraft is
+  // already false), but its draft-proxy traps mark every op with the write
+  // override. Those reads are the derive working its own draft (state.push
+  // reading .length) — gating them throws NotReadyError back into the derive
+  // itself, which the post-await read diagnostic (#2987) then escalates to a
+  // reactivity halt. The gate exists for EXTERNAL readers (seed invisibility,
+  // proj R23); the derive is the author.
+  if (projectionWriteActive || getWriteOverride()) return;
   const fw = target.fam?.node;
   if (fw != null && fw._statusFlags & (STATUS_UNINITIALIZED | STATUS_ERROR)) read(fw);
 }
@@ -6399,6 +7630,12 @@ const traps = {
     if (pendingCheckActive) witnessAffectsMark(target, key);
     if (target.fam !== null && getObserver() === null && !inDraft(target)) firewallGate(target);
     const src = readSource(target);
+    // Overlay delete (#3044): a prototype overlay cannot shadow a delete, so
+    // deleted keys are tracked aside and read as absent in the pending view.
+    if (target.del !== null && src === target.pb && target.del.has(key)) {
+      if (!inDraft(target) && getObserver() !== null) read(getNode(target, key, undefined));
+      return undefined;
+    }
     // Hot inline case: existing PLAIN node (non-accessor), unchained backing,
     // tracked read of a present data key — the dbmon/uibench effect re-read
     // shape. Skips serveDataKey's frame, the FORCE compare (only accessor
@@ -6439,14 +7676,21 @@ const traps = {
     // the node's cached flag; the first TRACKED read (which creates the
     // node) probes once — untracked node-less reads take the plain path,
     // where a raw-receiver getter still returns correct committed values.
+    // Tracking suppression is PER-TARGET (inDraft), never global: `writing`
+    // counts every open setter anywhere, and a projection derive runs its
+    // whole body inside one — a global gate silently swallowed EXTERNAL
+    // 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];
     {
       const acc =
         node0 !== undefined
           ? node0.acc === true
-          : !writing && getObserver() !== null && isOwnAccessor(src, key);
+          : !inDraft(target) && getObserver() !== null && isOwnAccessor(src, key);
       if (acc) {
-        if (!writing && getObserver() !== null) read(node0 ?? getNode(target, key, undefined));
+        if (!inDraft(target) && getObserver() !== null)
+          read(node0 ?? getNode(target, key, undefined));
         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;
@@ -6455,19 +7699,27 @@ const traps = {
     // Plain-data fast path: no descriptor allocation per read.
     // Inherited pollution keys are never served (core R30) — checked before
     // the proto-function branch can leak `constructor`. Interned-string
-    // compares beat a Set hash on this per-read path.
+    // compares beat a Set hash on this per-read path. Overlay pending
+    // backings chain to the committed backing, so "own in the view" means
+    // own on either layer (ownInView) — a genuine prototype method is one
+    // that is own on NEITHER.
+    const viewOvl = target.ovl && src === target.pb;
     if (
       (key === "constructor" || key === "__proto__" || key === "prototype") &&
-      !hasOwn.call(src, key)
+      !hasOwn.call(src, key) &&
+      !(viewOvl && hasOwn.call(target.v, key))
     )
       return undefined;
     let v = src[key];
-    if (v === undefined ? !hasOwn.call(src, key) : false) {
+    if (
+      v === undefined ? !hasOwn.call(src, key) && !(viewOvl && hasOwn.call(target.v, key)) : false
+    ) {
       // Inherited: prototype getters/methods run with the proxy receiver.
       v = Reflect.get(src, key, receiver);
       if (typeof v === "function") return v; // proto methods untracked
-      // Reading a currently-absent own key subscribes to it (R12).
-      if (v === undefined && !writing) {
+      // 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));
         const node = target.n?.[key];
         if (node) {
@@ -6477,12 +7729,18 @@ const traps = {
         }
       } else if (v === undefined && inDraft(target) && target.fam?.opt && target.pb === null) {
         const node = target.n?.[key];
-        if (node !== undefined && hasActiveOverride(node)) v = unwrapOverride(node._overrideValue);
+        if (node !== undefined && hasActiveOverride(node))
+          v = unwrapOverride(node._x?._overrideValue);
       }
       if (target.s) return serveShallow(target, key, v);
       return isWrappable(v) ? draftServe(target, wrapNext(v, target, key)) : v;
     }
-    if (typeof v === "function" && !hasOwn.call(src, key)) return v; // proto method
+    if (
+      typeof v === "function" &&
+      !hasOwn.call(src, key) &&
+      !(viewOvl && hasOwn.call(target.v, key))
+    )
+      return v; // proto method
     return serveDataKey(target, key, v, src, node0);
   },
   has(target, key) {
@@ -6491,6 +7749,8 @@ const traps = {
     if (target.fam !== null && getObserver() === null && !inDraft(target)) firewallGate(target);
     const src = readSource(target);
     let present = key in src;
+    // Overlay deletes read as absent in the pending view (#3044).
+    if (present && target.del !== null && src === target.pb && target.del.has(key)) present = false;
     if (!inDraft(target)) {
       if (getObserver() !== null) {
         const node = getHasNode(target, key, present);
@@ -6499,12 +7759,12 @@ const traps = {
       } else {
         const node = target.h?.[key];
         if (node !== undefined && hasActiveOverride(node))
-          present = !!unwrapOverride(node._overrideValue);
+          present = !!unwrapOverride(node._x?._overrideValue);
       }
     } else if (target.fam?.opt && target.pb === null) {
       const node = target.h?.[key];
       if (node !== undefined && hasActiveOverride(node))
-        present = !!unwrapOverride(node._overrideValue);
+        present = !!unwrapOverride(node._x?._overrideValue);
     }
     return present;
   },
@@ -6512,7 +7772,18 @@ const traps = {
     if (pendingCheckActive) witnessAffectsMark(target);
     if (target.fam !== null && getObserver() === null && !inDraft(target)) firewallGate(target);
     if (!inDraft(target) && getObserver() !== null) read(getKeySetNode(target));
-    const keys = Reflect.ownKeys(readSource(target));
+    const src = readSource(target);
+    let keys;
+    if (target.ovl && src === target.pb) {
+      // Overlay merge (#3044): committed keys in their order, then this
+      // batch's NEW keys, minus deletes.
+      keys = Reflect.ownKeys(target.v);
+      const del = target.del;
+      if (del !== null && del.size !== 0) keys = keys.filter(key => !del.has(key));
+      for (const key of Reflect.ownKeys(src)) {
+        if (!hasOwn.call(target.v, key)) keys.push(key);
+      }
+    } else keys = Reflect.ownKeys(src);
     // Optimistic membership overlay: presence-node overrides add/remove keys
     // (per-transaction lifecycle rides the nodes — §6, FINDING-2's fix).
     // Draft reads before the first write overlay too (pb, once created, is
@@ -6523,7 +7794,7 @@ const traps = {
         const node = target.h[key];
         if (!hasActiveOverride(node)) continue;
         set ??= new Set(keys);
-        if (unwrapOverride(node._overrideValue)) set.add(key);
+        if (unwrapOverride(node._x?._overrideValue)) set.add(key);
         else set.delete(key);
       }
       if (set !== null) return [...set];
@@ -6531,11 +7802,18 @@ const traps = {
     return keys;
   },
   getOwnPropertyDescriptor(target, key) {
-    const desc = Object.getOwnPropertyDescriptor(readSource(target), key);
+    const srcD = readSource(target);
+    let desc = Object.getOwnPropertyDescriptor(srcD, key);
+    // Overlay (#3044): unwritten keys live on the committed backing;
+    // deleted keys are absent from the pending view.
+    if (target.ovl && srcD === target.pb) {
+      if (target.del !== null && target.del.has(key)) return undefined;
+      if (desc === undefined) desc = Object.getOwnPropertyDescriptor(target.v, key);
+    }
     if (target.fam?.opt && !inDraft(target)) {
       const node = target.h?.[key];
       if (node !== undefined && hasActiveOverride(node)) {
-        if (!unwrapOverride(node._overrideValue)) return undefined; // opt delete
+        if (!unwrapOverride(node._x?._overrideValue)) return undefined; // opt delete
         if (desc === undefined) {
           const vn = target.n?.[key];
           return {
@@ -6562,24 +7840,50 @@ const traps = {
     const override = !draft && getWriteOverride();
     if (!draft && !override) return true;
     if (key === "__proto__") return true; // pollution guard (core R30)
+    // Unwrap BEFORE ensurePB: unwrapValue materializes a self-referencing
+    // draft's overlay (replacing target.pb), so a pb local captured earlier
+    // would be the abandoned overlay and the write would vanish.
+    // Shallow slots store what was written VERBATIM — another store's proxy
+    // passes through by reference (#2932; markRawOne skips proxies), while
+    // deep stores unwrap to raw backings.
+    const uv = target.s ? value : unwrapValue(value);
     const pb = ensurePB(target);
     pendingNotify.add(target);
+    // 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.
+    if (Array.isArray(pb)) {
+      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 (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)) {
       Object.defineProperty(pb, key, {
-        value: unwrapValue(value),
+        value: uv,
         writable: true,
         enumerable: true,
         configurable: true
       });
+      if (target.del !== null) target.del.delete(key);
       return true;
     }
-    // Shallow slots store what was written VERBATIM — another store's proxy
-    // passes through by reference (#2932; markRawOne skips proxies), while
-    // deep stores unwrap to raw backings.
-    const uv = target.s ? value : unwrapValue(value);
-    pb[key] = uv;
+    // Overlay first-write DEFINES the own key: assignment through the proto
+    // chain would reject on a non-writable committed property (the clone
+    // path normalized descriptors for exactly this — R51 parity).
+    if (target.ovl && !hasOwn.call(pb, key)) {
+      Object.defineProperty(pb, key, {
+        value: uv,
+        writable: true,
+        enumerable: true,
+        configurable: true
+      });
+    } else pb[key] = uv;
+    if (target.del !== null) target.del.delete(key);
     // Shallow ingest: written records are sticky raw-marked (one entity is
     // never both deep-wrapped and raw — R41/#2932, shared invariant).
     if (target.s && uv !== null && typeof uv === "object") markRawOne(uv);
@@ -6594,10 +7898,13 @@ const traps = {
     if (!draft && !override) return true;
     if (key === "__proto__") return true;
     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);
-    if ("value" in desc) desc = { ...desc, value: unwrapValue(desc.value) };
+    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);
     return true;
   },
@@ -6607,7 +7914,11 @@ const traps = {
     if (!draft && !override) return true;
     const pb = ensurePB(target);
     pendingNotify.add(target);
+    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.
+    if (target.ovl && hasOwn.call(target.v, key)) (target.del ??= new Set()).add(key);
     if (override) notifyWrites(target);
     return true;
   }
@@ -6749,6 +8060,9 @@ function snapshotWalk(value, seen, fam) {
     if (t === undefined) break;
     if (t.fam !== null) fam = t.fam;
     if (t.fam?.opt === true) (optOwners ??= []).push(t);
+    // Snapshot runs mid-flush (tracked memos execute before commit), so a
+    // pending prototype overlay must present as a REAL merged container.
+    if (t.ovl) materializePB(t);
     const backing = t.pb ?? t.v;
     if (backing === src) break;
     src = backing;
@@ -6848,6 +8162,10 @@ function reconcileNextState(value, state, key, replace = false) {
   if (state == null) throw new Error("Cannot reconcile null or undefined state");
   const t = state?.[$TARGET];
   if (t === undefined || t.px !== state) throw new Error("reconcile target is not a store proxy");
+  // Reconcile's diff walks need a REAL pending container — a prototype
+  // overlay (#3044) materializes to the clone path first (edge: reconcile
+  // inside a setter that already wrote this target).
+  if (t.ovl) materializePB(t);
   let keyFn = key === null ? null : typeof key === "string" ? item => item?.[key] : key;
   // §7b chained backing: a projection derive returning a LIVE store proxy
   // adopts the proxy itself as the backing — reads flow through the inner
@@ -7176,10 +8494,29 @@ function descend(pv, nv, keyFn, fam, proj = false) {
  * primitives; the generic draft write-traps are reused from the legacy
  * module unchanged.
  */
-function createWriteTraps(isActive, onDraftWrite) {
-  // Save/restore, never hard-reset: the draft can be driven from inside an
-  // enclosing authoritative-write scope (next-store optimistic derives), and
-  // a hard `false` would clobber it mid-derive.
+/**
+ * Wrap a store proxy as a projection DRAFT: every operation carries the write
+ * override (the derive is the author — its ops must not hit the §6c firewall
+ * gate, even in a continuation after an `await`/`yield` where the sync write
+ * scope has closed).
+ *
+ * FAKE TARGET, not the store proxy itself (#3060): after a proxy trap
+ * returns, the engine runs spec invariant validation against the proxy's
+ * TARGET — [[OwnPropertyKeys]] after ownKeys, [[GetOwnProperty]] after
+ * set/getOwnPropertyDescriptor/defineProperty. With the store proxy as
+ * target those checks re-enter the store's traps OUTSIDE the override
+ * bracket (the trap's finally has already run), so `Object.keys(state)` in
+ * a derive continuation fired the firewall gate and re-threw the
+ * projection's own pending NotReadyError into the derive. A dummy of
+ * matching kind (array/object, same trick as the store's own TargetShape)
+ * keeps invariant validation away from the store entirely; the traps
+ * forward to the closed-over inner proxy inside the bracket.
+ *
+ * Save/restore projectionWriteActive, never hard-reset: the draft can be
+ * driven from inside an enclosing authoritative-write scope (next-store
+ * optimistic derives), and a hard `false` would clobber it mid-derive.
+ */
+function wrapDraft(inner, isActive, onDraftWrite) {
   const traps = {
     get(_, prop) {
       let value;
@@ -7187,13 +8524,15 @@ function createWriteTraps(isActive, onDraftWrite) {
       setWriteOverride(true);
       setProjectionWriteActive(true);
       try {
-        value = _[prop];
+        value = inner[prop];
       } finally {
         setWriteOverride(false);
         setProjectionWriteActive(was);
       }
       if (prop === $TARGET) return value;
-      return typeof value === "object" && value !== null ? new Proxy(value, traps) : value;
+      return typeof value === "object" && value !== null
+        ? wrapDraft(value, isActive, onDraftWrite)
+        : value;
     },
     has(_, prop) {
       let value;
@@ -7201,7 +8540,7 @@ function createWriteTraps(isActive, onDraftWrite) {
       setWriteOverride(true);
       setProjectionWriteActive(true);
       try {
-        value = prop in _;
+        value = prop in inner;
       } finally {
         setWriteOverride(false);
         setProjectionWriteActive(was);
@@ -7214,7 +8553,7 @@ function createWriteTraps(isActive, onDraftWrite) {
       setWriteOverride(true);
       setProjectionWriteActive(true);
       try {
-        _[prop] = value;
+        inner[prop] = value;
         onDraftWrite?.();
       } finally {
         setWriteOverride(false);
@@ -7228,7 +8567,49 @@ function createWriteTraps(isActive, onDraftWrite) {
       setWriteOverride(true);
       setProjectionWriteActive(true);
       try {
-        delete _[prop];
+        delete inner[prop];
+        onDraftWrite?.();
+      } finally {
+        setWriteOverride(false);
+        setProjectionWriteActive(was);
+      }
+      return true;
+    },
+    ownKeys() {
+      const was = projectionWriteActive;
+      setWriteOverride(true);
+      setProjectionWriteActive(true);
+      try {
+        return Reflect.ownKeys(inner);
+      } finally {
+        setWriteOverride(false);
+        setProjectionWriteActive(was);
+      }
+    },
+    getOwnPropertyDescriptor(_, prop) {
+      let d;
+      const was = projectionWriteActive;
+      setWriteOverride(true);
+      setProjectionWriteActive(true);
+      try {
+        d = Reflect.getOwnPropertyDescriptor(inner, prop);
+      } finally {
+        setWriteOverride(false);
+        setProjectionWriteActive(was);
+      }
+      // The dummy target doesn't hold the key, so a non-configurable report
+      // would violate the proxy invariant. Store descriptors are already
+      // normalized configurable; enforce it for raw leaves too.
+      if (d) d.configurable = true;
+      return d;
+    },
+    defineProperty(_, prop, desc) {
+      if (isActive && !isActive()) return true;
+      const was = projectionWriteActive;
+      setWriteOverride(true);
+      setProjectionWriteActive(true);
+      try {
+        Reflect.defineProperty(inner, prop, desc);
         onDraftWrite?.();
       } finally {
         setWriteOverride(false);
@@ -7237,7 +8618,8 @@ function createWriteTraps(isActive, onDraftWrite) {
       return true;
     }
   };
-  return traps;
+  // Matching-kind dummy so Array.isArray(draft) answers like the store.
+  return new Proxy(Array.isArray(inner) ? [] : {}, traps);
 }
 function createProjectionNextInternal(fn, seed, options) {
   const fam = {
@@ -7291,9 +8673,10 @@ function runProjectionComputedNext(wrappedStore, fn, key, wrapCommit, onDraftWri
   const shadow = owner._loading
     ? JSON.parse(JSON.stringify(wrappedStore[$TARGET][STORE_VALUE]))
     : null;
-  const draft = new Proxy(
+  const draft = wrapDraft(
     wrappedStore,
-    createWriteTraps(() => !settled || owner._inFlight === result, onDraftWrite)
+    () => !settled || owner._x?._inFlight === result,
+    onDraftWrite
   );
   storeSetterNext(
     draft,
@@ -7374,10 +8757,15 @@ function familyHasLiveOverrides(fam) {
       if (bucket === null) continue;
       for (const key of Reflect.ownKeys(bucket)) {
         const node = bucket[key];
-        if (node._overrideValue !== undefined && node._overrideValue !== NOT_PENDING) return true;
+        if (node._x?._overrideValue !== undefined && node._x?._overrideValue !== NOT_PENDING)
+          return true;
       }
     }
-    if (t.k !== null && t.k._overrideValue !== undefined && t.k._overrideValue !== NOT_PENDING)
+    if (
+      t.k !== null &&
+      t.k._x?._overrideValue !== undefined &&
+      t.k._x?._overrideValue !== NOT_PENDING
+    )
       return true;
   }
   overlaid.clear(); // nothing live — drop the bookkeeping
@@ -7451,13 +8839,13 @@ function notifyOptimisticWrites(t, pb) {
   const visible = (key, fallback) => {
     const node = t.n?.[key];
     return node !== undefined && hasActiveOverride(node)
-      ? unwrapOverride(node._overrideValue)
+      ? unwrapOverride(node._x?._overrideValue)
       : fallback;
   };
   const visiblePresent = key => {
     const node = t.h?.[key];
     return node !== undefined && hasActiveOverride(node)
-      ? !!unwrapOverride(node._overrideValue)
+      ? !!unwrapOverride(node._x?._overrideValue)
       : key in old;
   };
   let structural = false;
@@ -7518,14 +8906,18 @@ function consumeOverridesNext(fam) {
     for (const t of overlaid) {
       const drop = (node, committed) => {
         if (!hasActiveOverride(node)) return;
-        const prev = unwrapOverride(node._overrideValue);
+        const prev = unwrapOverride(node._x?._overrideValue);
         // Full legacy reset (clearOptimisticOverride parity): the landing is
         // authoritative NOW — fold committed into the node directly instead
         // of riding a transaction's commit (whose queues may be stashed with
         // the transaction parked; the wake would strand until it settles).
-        node._overrideValue = NOT_PENDING;
-        node._overrideOwner = null;
-        node._optimisticLane = undefined;
+        ext(node)._overrideValue = NOT_PENDING;
+        node._config |= CONFIG_OPTIMISTIC;
+        const nx = node._x;
+        if (nx) {
+          nx._overrideOwner = null;
+          nx._optimisticLane = undefined;
+        }
         node._pendingValue = NOT_PENDING;
         node._value = committed;
         if (!node._equals || !node._equals(prev, committed)) {
@@ -7561,9 +8953,13 @@ function consumeOverridesNext(fam) {
         for (const key of Reflect.ownKeys(has)) drop(has[key], key in t.v);
       }
       if (t.k !== null && hasActiveOverride(t.k)) {
-        t.k._overrideValue = NOT_PENDING;
-        t.k._overrideOwner = null;
-        t.k._optimisticLane = undefined;
+        ext(t.k)._overrideValue = NOT_PENDING;
+        t.k._config |= CONFIG_OPTIMISTIC;
+        const kx = t.k._x;
+        if (kx) {
+          kx._overrideOwner = null;
+          kx._optimisticLane = undefined;
+        }
         insertSubs(t.k, true);
         schedule();
       }
@@ -7583,7 +8979,7 @@ function optimisticView(t, src) {
     for (const key of Reflect.ownKeys(nodes)) {
       const node = nodes[key];
       if (!hasActiveOverride(node)) continue;
-      const ov = unwrapOverride(node._overrideValue);
+      const ov = unwrapOverride(node._x?._overrideValue);
       if (key === "length" && Array.isArray(src)) {
         if (src.length !== ov) ensure().length = ov;
       } else if (!isEqual(src[key], ov)) ensure()[key] = ov;
@@ -7594,7 +8990,7 @@ function optimisticView(t, src) {
     for (const key of Reflect.ownKeys(has)) {
       const node = has[key];
       if (!hasActiveOverride(node)) continue;
-      const present = !!unwrapOverride(node._overrideValue);
+      const present = !!unwrapOverride(node._x?._overrideValue);
       if (!present && key in (out ?? src)) delete ensure()[key];
     }
   }
@@ -8322,10 +9718,10 @@ function compare(key, a, b) {
 
 function boundaryComputed(fn, propagationMask) {
   const node = computed(fn, { lazy: true });
-  node._notifyStatus = (status, error) => {
+  ext(node)._notifyStatus = (status, error) => {
     // Use passed values if provided, otherwise read from node
     const flags = status !== undefined ? status : node._statusFlags;
-    const actualError = error !== undefined ? error : node._error;
+    const actualError = error !== undefined ? error : node._x?._error;
     // Notify both status dimensions like a render effect does; the queue chain
     // consumes this boundary's own type and forwards the remainder upward until
     // a boundary that handles it is found.
@@ -8338,8 +9734,8 @@ function boundaryComputed(fn, propagationMask) {
     const foreign = flags & ~node._propagationMask & (STATUS_PENDING | STATUS_ERROR);
     if (foreign) {
       node._statusFlags &= ~foreign;
-      if (node._error === actualError && !(node._statusFlags & (STATUS_PENDING | STATUS_ERROR)))
-        node._error = undefined;
+      if (node._x?._error === actualError && !(node._statusFlags & (STATUS_PENDING | STATUS_ERROR)))
+        if (node._x !== null) node._x._error = undefined;
     }
     // An ERROR the chain could not deliver to any boundary is uncaught. The
     // scrub above already removed it from reader-visible state, so without
@@ -8579,13 +9975,13 @@ class CollectionQueue extends Queue {
       return super.notify(node, type, flags, error);
     if (flags & this._collectionType) {
       this._pending = true;
-      const source = error?.source || node._error?.source;
+      const source = error?.source || node._x?._error?.source;
       if (source) {
         const wasEmpty = this._sources.size === 0;
         this._sources.add(source);
         if (wasEmpty) setSignal(this._disabled, true);
         if (this._collectionType & STATUS_ERROR) {
-          setSignal(this._error, unwrapStatusError(source._error));
+          setSignal(this._error, unwrapStatusError(source._x?._error));
         }
       }
     }
@@ -8600,7 +9996,7 @@ class CollectionQueue extends Queue {
       // sweep (finalizePureQueue after mark release) re-runs this check.
       if (
         source._flags & REACTIVE_DISPOSED ||
-        (!source._affectsCount &&
+        (!source._x?._affectsCount &&
           !(source._statusFlags & this._collectionType) &&
           !(this._collectionType & STATUS_ERROR && source._statusFlags & STATUS_PENDING))
       )
@@ -8661,7 +10057,7 @@ function createCollectionBoundary(type, fn, fallback, onFn) {
       else throw e;
     }
     queue._pending =
-      pending || !!(tree._statusFlags & type) || tree._error instanceof NotReadyError;
+      pending || !!(tree._statusFlags & type) || tree._x?._error instanceof NotReadyError;
   });
   const controller =
     _revealUsed && type === STATUS_PENDING ? getContext(RevealControllerContext) : null;