@solidjs/signals 2.0.0-rc.11 → 2.0.0-rc.14

package/dist/dev.attribution.js

@@ -1,30 +1,37 @@
 import {
-  bL as OBSERVE,
-  bV as setAttributionHooks,
-  bW as liveRootOwners,
-  b as NOT_PENDING,
-  ay as emitDiagnostic,
-  bX as ownerPath,
-  ax as reportDiagnostic,
-  bY as isSuppressed,
-  bZ as CONFIG_PLUMBING,
-  b_ as anyExcluded,
-  b$ as isExcluded,
-  q as CONFIG_DERIVED_OVERRIDE,
-  c0 as GRAPH_SIZE_WARN_AT,
-  c1 as noteFanOut,
-  aV as $REFRESH
+  br as OBSERVE,
+  bB as setAttributionHooks,
+  bC as liveRootOwners,
+  N as NOT_PENDING,
+  an as emitDiagnostic,
+  bD as ownerPath,
+  aB as reportDiagnostic,
+  bE as isSuppressed,
+  bF as blockersOf,
+  bG as CONFIG_PLUMBING,
+  bH as anyExcluded,
+  bI as isExcluded,
+  bJ as CONFIG_WIDE,
+  a as CONFIG_OVERRIDE,
+  C as CONFIG_GUESS,
+  G as GlobalQueue,
+  b as CONFIG_VERDICT,
+  bK as GRAPH_SIZE_WARN_AT,
+  bL as noteFanOut,
+  bM as CONFIG_SUPERSEDES,
+  aT as $REFRESH
 } from "./dev-shared.js";
 
 /** A fallback shown for less than this is a flash: feedback for a wait too short to need it. */
 const FALLBACK_FLASH_MS = 150;
 /**
- * Under an owner the observer marked as its own (`OBSERVE.exclude`), or
- * framework plumbing itself (`CONFIG_PLUMBING` — the HMR memo between a
- * component's root and its body, which is nobody's node): the engine records
- * nothing about the node. Plumbing is a bit read and excludes the node alone,
- * not what it owns; the observer exclusion is cached per node once any
- * exists, before that a flag read.
+ * Under an owner the observer marked as its own (`OBSERVE.exclude`, and not
+ * re-admitted by a nearer `OBSERVE.include`), or framework plumbing itself
+ * (`CONFIG_PLUMBING` — the HMR memo between a component's root and its
+ * body, which is nobody's node): the engine records nothing about the node.
+ * Plumbing is a bit read and excludes the node alone, not what it owns; the
+ * observer exclusion is cached per node once any exists, before that a flag
+ * read.
  */
 function excludedNode(el) {
   if ((el._config & CONFIG_PLUMBING) !== 0) return true;
@@ -47,7 +54,7 @@ const defaultOptions = {
   stacks: false,
   historyLimit: 200,
   hotRuns: { count: 120, windowMs: 1000 },
-  wideDeps: 30,
+  wideDeps: 200,
   hotTime: { budgetMs: 8, windowMs: 1000 },
   unstableMemos: 4,
   wastedRecompute: { minRuns: 5, ratio: 0.8, budgetMs: 2, windowMs: 1000 },
@@ -191,13 +198,20 @@ function targetLabel(target) {
 }
 function interactionStart(ref) {
   interactionStack.push(currentInteraction);
+  // No `ref.event`: the WeakMap answers undefined.
+  const joined = eventInteractions.get(ref.event);
+  if (joined?.joinable && openInteractions.has(joined)) {
+    joined.open = true;
+    currentInteraction = joined.event.origin;
+    return;
+  }
   // One clock read: the frame opens now; the interaction began at `ref.at`
   // when the runtime dated it (the event's own timestamp), else now too.
   const opened = now();
   const origin = { kind: "interaction", name: ref.type, at: ref.at ?? opened };
   if (ref.target) origin.target = targetLabel(ref.target);
   currentInteraction = origin;
-  openInteraction(origin, opened);
+  openInteraction(origin, opened, ref.event);
 }
 function interactionEnd(returned) {
   const closing = currentInteraction;
@@ -333,9 +347,16 @@ function originStart(ref) {
       return;
     }
   }
-  const frame = { kind: ref.kind, at: ref.at ?? now() };
-  if (ref.from !== undefined) frame.from = ref.from;
-  const under = enclosingInteraction();
+  // The initial navigation is the document's: its request is the time origin
+  // unless the router says otherwise, and it left nowhere.
+  const initial = ref.initial === true;
+  const frame = { kind: ref.kind, at: ref.at ?? (initial ? 0 : now()) };
+  if (!initial && ref.from !== undefined) frame.from = ref.from;
+  // Declared beats ambient: a router that awaited before writing hands back
+  // the origin it captured in the request (`undefined` when the request ran
+  // under none — still a declaration); what is on the stack now is whatever
+  // happened to be running.
+  const under = "interaction" in ref ? interactionOf(ref.interaction) : enclosingInteraction();
   if (under !== undefined) frame.interaction = under;
   originFrames.push(frame);
   openNavigation(frame, ref);
@@ -369,19 +390,14 @@ function formatOrigin(origin) {
         notes.push(
           `redirected from ${redirects.map(hop => hop.to ?? hop.name ?? "?").join(" → ")}`
         );
-      return `navigation to ${name}${notes.length > 0 ? ` (${notes.join(", ")})` : ""}`;
+      const initial = navStates.get(origin)?.event.initial === true;
+      return `${initial ? "initial " : ""}navigation to ${name}${notes.length > 0 ? ` (${notes.join(", ")})` : ""}`;
     }
     default:
       return "outside the reactive system";
   }
 }
 /** Record a root change (setSignal / refresh / async landing) on the node. */
-/** Live subscriber count, walked on demand — the core keeps no counter. */
-function countSubscribers(node) {
-  let n = 0;
-  for (let s = node._subs; s !== null; s = s._nextSub) n++;
-  return n;
-}
 /**
  * HUGE_FAN_OUT from the engine's lower `fanOut` threshold (see dev.ts): a
  * committed root invalidation reaching hundreds of subscribers re-runs all
@@ -390,12 +406,20 @@ function countSubscribers(node) {
  * was a post-construction field that forked node shapes). Stops at
  * GRAPH_SIZE_WARN_AT, where the always-on core check takes over, so the two
  * never fire for the same write; the once-per-node dedupe is the core's.
+ * HMR plumbing subscribers (the refresh memo of every mounted instance, on
+ * a component's registration signal) are not counted toward `fanOut`; the
+ * handover is on the full list, which is what the core counts.
  */
 function checkFanOut(node, kind) {
   const limit = options.fanOut;
   if (typeof limit !== "number") return;
-  const subs = countSubscribers(node);
-  if (subs < limit || subs >= GRAPH_SIZE_WARN_AT) return;
+  let all = 0;
+  let subs = 0;
+  for (let s = node._subs; s !== null; s = s._nextSub) {
+    all++;
+    if (!(s._sub._config & CONFIG_PLUMBING)) subs++;
+  }
+  if (subs < limit || all >= GRAPH_SIZE_WARN_AT) return;
   noteFanOut(node, subs, kind);
 }
 function stampWrite(node, kind, prev = NO_VALUES, value = NO_VALUES) {
@@ -474,18 +498,25 @@ function captureDeps(el) {
 }
 /**
  * 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
+ * subscribed to hundreds 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.
+ * memo can be born too wide). Re-warns only on 50% further growth. Counts
+ * what the scope's author can act on: HMR plumbing sources are not counted,
+ * and a framework scope wide by construction (CONFIG_WIDE) is not judged —
+ * the always-on HUGE_FAN_IN still is.
  */
 function checkDepWidth(el) {
   const limit = options.wideDeps;
-  if (limit === false) return;
+  // Only dev sets CONFIG_WIDE (see constants.ts).
+  if (limit === false || el._config & CONFIG_WIDE) 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));
+    // HMR plumbing is a dev-only hop the scope cannot read past: not a source.
+    if (!(l._dep._config & CONFIG_PLUMBING)) {
+      count++;
+      if (names.length < 12) names.push(nodeName(l._dep));
+    }
     if (l === el._depsTail) break; // the validated prefix, as captureDeps
   }
   const node = el;
@@ -641,7 +672,10 @@ function checkHotTime(el, selfMs, causes) {
  * names it while it happens, with the input that keeps triggering it. The
  * fix is upstream: an equality boundary on the part of the input the scope
  * depends on, or a narrower read. Plain runs only — a held or overlay run
- * may be replayed and is never blamed as waste.
+ * may be replayed and is never blamed as waste. A run that committed
+ * `undefined` arrives here as changed (see `recomputeEnd`): its work is a
+ * side effect (a projection's draft writes, a write from inside a memo), not
+ * its output.
  */
 function checkWastedRecompute(el, at, phase, changed, selfMs, causes) {
   const cfg = options.wastedRecompute;
@@ -842,8 +876,10 @@ function shallowEquivalent(a, b) {
     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;
+  // Every own key, symbols included: a symbol-keyed box holding a fresh value
+  // each run (web's `dynamic` boxes its in-flight promise) is not equivalent.
+  const keys = Reflect.ownKeys(a);
+  if (keys.length > UNSTABLE_KEY_CAP || keys.length !== Reflect.ownKeys(b).length) return false;
   for (const key of keys) {
     if (!(key in b) || a[key] !== b[key]) return false;
   }
@@ -1477,14 +1513,11 @@ function checkWaterfall(el, chain, ms) {
 const holdStates = new WeakMap();
 let activeHold = null;
 let holdLog = [];
-/** Companions are optimistic nodes too; `_parentSource` marks them. So is a
- * memo carrying a DERIVED override (lanes stage, #3479) — a lane pass's
- * result, not a write anyone made: neither is an acknowledgement. */
+/** A lane's derivation (L2: a node carrying the lane's value that is not a
+ * written guess — lanes.ts) is a lane pass's result, not a write anyone
+ * made: not an acknowledgement. */
 function isCompanion(node) {
-  return (
-    (!!node._x && node._x._parentSource !== undefined) ||
-    (node._config & CONFIG_DERIVED_OVERRIDE) !== 0
-  );
+  return (node._config & (CONFIG_OVERRIDE | CONFIG_GUESS)) === CONFIG_OVERRIDE;
 }
 const HOLD_CENSUS_CAP = 10_000;
 function acknowledge(state, kind, source, reader) {
@@ -1500,15 +1533,17 @@ function acknowledge(state, kind, source, reader) {
     );
   else if (path !== undefined) existing.reader ??= path;
 }
+/** The declarations made against the hold: the guesses of its lanes
+ * (lanes.ts `_laneGuesses`) and its `affects()` marks (`_marks`). */
 function censusRegistrations(t, state) {
   const budget = { left: HOLD_CENSUS_CAP };
-  for (const node of t._optimisticNodes)
-    if (!isCompanion(node))
+  const guesses = GlobalQueue._laneGuesses?.(t);
+  if (guesses !== undefined)
+    for (const node of guesses)
       acknowledge(state, "optimistic", nodeName(node), reachesEffect(node, budget));
-  for (const store of t._optimisticStores)
-    acknowledge(state, "optimistic", store?._name ?? "store", null);
-  for (const node of t._affectsNodes)
-    acknowledge(state, "affects", nodeName(node), reachesEffect(node, budget));
+  if (t._marks !== null)
+    for (const node of t._marks)
+      acknowledge(state, "affects", nodeName(node), reachesEffect(node, budget));
 }
 /**
  * Does anything that paints read `companion` — an effect, through however many
@@ -1533,7 +1568,10 @@ function reachesEffect(companion, budget) {
   }
   return null;
 }
-/** Companions an effect reads, anywhere downstream of the hold's nodes. */
+/** Verdict readers an effect reads, anywhere downstream of the hold's nodes
+ * (L2: a pass that entered an `isPending`/`latest` window is marked
+ * CONFIG_VERDICT; the observe tier notes which windows — verdict.ts
+ * `_devWindows`). The reader acknowledges the node it derives from. */
 function censusCompanions(roots, state) {
   const visited = new Set();
   const stack = [...roots];
@@ -1542,20 +1580,16 @@ function censusCompanions(roots, state) {
     const node = stack.pop();
     if (visited.has(node)) continue;
     visited.add(node);
-    const x = node._x;
-    if (x) {
-      let reader;
-      if (x._pendingSignal !== undefined && (reader = reachesEffect(x._pendingSignal, budget)))
-        acknowledge(state, "isPending", nodeName(node), reader);
-      if (
-        x._latestValueComputed !== undefined &&
-        (reader = reachesEffect(x._latestValueComputed, budget))
-      )
-        acknowledge(state, "latest", nodeName(node), reader);
-      for (let child = x._child ?? null; child !== null; child = child._nextChild ?? null)
-        stack.push(child);
+    for (let s = node._subs; s !== null; s = s._nextSub) {
+      const sub = s._sub;
+      if (sub._config & CONFIG_VERDICT) {
+        const windows = sub._devWindows ?? 0;
+        const reader = sub._type ? sub : reachesEffect(sub, budget);
+        if (windows & 1 && reader !== null) acknowledge(state, "isPending", nodeName(node), reader);
+        if (windows & 2 && reader !== null) acknowledge(state, "latest", nodeName(node), reader);
+      }
+      stack.push(sub);
     }
-    for (let s = node._subs; s !== null; s = s._nextSub) stack.push(s._sub);
   }
 }
 function holdState(t) {
@@ -1581,9 +1615,8 @@ function trackHoldStart(t) {
   if (options.holds === false) return;
   const state = holdState(t);
   state.flushes++;
-  if (t._actions.length > 0) state.action = true;
-  for (const [source, reporters] of t._asyncReporters)
-    if (reporters.size > 0) state.blockers.add(source);
+  if (t._open > 0) state.action = true;
+  for (const source of blockersOf(t)) state.blockers.add(source);
   censusRegistrations(t, state);
   activeHold = state;
 }
@@ -1619,7 +1652,7 @@ function trackHoldSettled(t) {
   let interaction;
   let origin;
   let lastJoinAt = -Infinity;
-  for (const node of t._pendingNodes) {
+  for (const node of t._nodes) {
     if (typeof node._fn === "function" || isCompanion(node)) continue;
     const change = node._devChange;
     if (change === undefined || change.kind !== "write") continue;
@@ -1649,7 +1682,7 @@ function trackHoldSettled(t) {
     return;
   }
   censusRegistrations(t, state);
-  censusCompanions([...t._pendingNodes, ...state.blockers], state);
+  censusCompanions([...t._nodes, ...state.blockers], state);
   const end = now();
   // The hold began no later than its first parked flush; an interaction stamp
   // reaches further back (dispatch). A node rewritten mid-hold keeps only its
@@ -1844,8 +1877,10 @@ function checkOptimisticRevert(el, shown, truth, how) {
   // derived override promotes rather than reverts. Same predicate the hold
   // census uses to skip them.
   if (!options.optimisticReverts || isCompanion(el)) return;
+  // Method call, as every commit path does: store slot nodes share one
+  // comparator that reads `this._host` (#3687).
   const equals = el._equals;
-  if (equals && equals(shown, truth)) return;
+  if (equals && equals.call(el, shown, truth)) return;
   const source = nodeName(el);
   // The two values are user data: quoted only under `values: "full"`; the
   // other levels say what happened without saying what was shown.
@@ -1954,7 +1989,10 @@ function trackGraph(navigation) {
   const event = { at: now(), ...size, navigation };
   if (route !== undefined) event.route = route;
   records.emit("graph", event, undefined);
-  if (cfg === false || route === undefined) return;
+  // The initial declaration is not a visit (it settles before route content
+  // mounts — the same gate the feedback folds apply as `event.initial !== true`);
+  // `initial` is `true | undefined`, set only by openNavigation, so truthiness is exact.
+  if (cfg === false || route === undefined || navigation.initial) return;
   let history = routeCounts.get(route);
   if (history === undefined) routeCounts.set(route, (history = []));
   history.push(size);
@@ -2008,11 +2046,14 @@ const abandonWindows = new WeakMap();
  * One source abandoning flight after flight inside a window: every input
  * asked again and the earlier answers were thrown away — the
  * request-per-keystroke signature `feedback().flights[].abandoned` counts,
- * as a finding while it happens. Warned once per window per source.
+ * as a finding while it happens. Warned once per window per source. A
+ * framework node superseding its own flights by design (CONFIG_SUPERSEDES)
+ * is not judged; its flights are still recorded.
  */
 function checkAbandonedFlights(el, abandoned) {
   const cfg = options.abandonedFlights;
-  if (cfg === false || excludedNode(el)) return;
+  // Only dev sets CONFIG_SUPERSEDES (see constants.ts).
+  if (cfg === false || el._config & CONFIG_SUPERSEDES || excludedNode(el)) return;
   const at = Date.now();
   let win = abandonWindows.get(el);
   if (win === undefined || at - win.start > cfg.windowMs) {
@@ -2142,6 +2183,7 @@ function syncNavigation(state) {
 }
 function openNavigation(frame, ref) {
   const event = { at: frame.at, writes: 0, origin: frame };
+  if (ref.initial === true) event.initial = true;
   if (frame.from !== undefined) event.from = frame.from;
   if (frame.interaction !== undefined) event.interaction = frame.interaction;
   const state = {
@@ -2209,7 +2251,7 @@ function noteNavigationWrite(prior, record) {
 /** holdStart: `t`'s staged writes are parked — their navigations settle with `t`. */
 function markNavigationsHeld(t) {
   if (openNavs.size === 0) return;
-  for (const node of t._pendingNodes) {
+  for (const node of t._nodes) {
     const origin = node._devChange?.origin;
     if (origin?.kind !== "navigation") continue;
     const state = navStates.get(origin);
@@ -2219,7 +2261,7 @@ function markNavigationsHeld(t) {
 /** transitionSettled: `t` commits — the navigations whose writes it staged are done. */
 function settleNavigations(t, hold) {
   if (openNavs.size === 0) return;
-  for (const node of t._pendingNodes) {
+  for (const node of t._nodes) {
     const origin = node._devChange?.origin;
     if (origin?.kind !== "navigation") continue;
     const state = navStates.get(origin);
@@ -2354,7 +2396,10 @@ function settleNavigation(state, outcome, hold) {
   event.settledMs = now() - event.at;
   event.outcome = outcome;
   if (hold !== undefined) event.hold = hold;
-  for (const f of folds) f.navigation?.(event);
+  // The initial declaration is not a navigation the person waited on: its
+  // `settledMs` is document start → router built, which would read as the
+  // route's responsiveness in the feedback tables. Consumers get the record.
+  if (event.initial !== true) for (const f of folds) f.navigation?.(event);
   records.emit("navigation", event, undefined);
   trackGraph(event);
   // The interaction that performed it may have been waiting only on this.
@@ -2362,10 +2407,12 @@ function settleNavigation(state, outcome, hold) {
   if (under !== undefined) maybeSettleInteraction(under);
 }
 const interactionStates = new WeakMap();
+/** `InteractionRef.event` → the record its frames join (while `joinable`). Weak: the Event is never held. */
+const eventInteractions = new WeakMap();
 /** Opened, not yet settled. */
 const openInteractions = new Set();
 let interactionLog = [];
-function openInteraction(frame, opened) {
+function openInteraction(frame, opened, key) {
   const event = {
     name: frame.name,
     at: frame.at,
@@ -2391,13 +2438,24 @@ function openInteraction(frame, opened) {
     heldIn: new Set(),
     held: false,
     excludedWrites: 0,
-    awaiting: false,
-    actioned: false
+    awaiting: 0,
+    actioned: false,
+    joinable: key !== undefined
   };
   interactionStates.set(frame, state);
   openInteractions.add(state);
   interactionLog.push(event);
   if (interactionLog.length > options.historyLimit) interactionLog.shift();
+  if (key !== undefined) {
+    eventInteractions.set(key, state);
+    // A microtask is too early: native dispatch runs microtasks between
+    // listeners. The callback must not close over `key`: a throttled timer
+    // would hold the Event strongly long past its dispatch.
+    setTimeout(() => {
+      state.joinable = false;
+      if (openInteractions.has(state)) maybeSettleInteraction(state, state.settleAt);
+    });
+  }
 }
 /**
  * How long the record waits on a handler's returned promise before settling
@@ -2423,17 +2481,17 @@ function closeInteraction(frame, returned) {
       ? returned
       : null;
   if (thenable !== null) {
-    state.awaiting = true;
+    state.awaiting++;
     let done = false;
     let timer;
     const settle = () => {
       if (done) return;
       done = true;
       if (timer !== undefined) clearTimeout(timer);
-      if (!openInteractions.has(state)) return;
-      state.awaiting = false;
+      if (!openInteractions.has(state) || --state.awaiting > 0) return;
       const at = now();
-      state.event.continuationMs = at - end;
+      // From the last handler's return: the frames of one event share a record.
+      state.event.continuationMs = at - (state.opened + state.event.handlerMs);
       checkUntrackedAsyncHandler(state);
       maybeSettleInteraction(state, at);
     };
@@ -2513,7 +2571,7 @@ function noteInteractionNavigation(event) {
 /** holdStart: `t` parked writes — the interactions that performed them wait for `t`. */
 function markInteractionsHeld(t) {
   if (openInteractions.size === 0) return;
-  for (const node of t._pendingNodes) {
+  for (const node of t._nodes) {
     const state = openInteractionOf(node._devChange?.origin);
     if (state !== undefined) {
       state.heldIn.add(t);
@@ -2536,12 +2594,16 @@ function settleInteractionsHeld(t, hold) {
 }
 function maybeSettleInteraction(state, end = now()) {
   const event = state.event;
-  if (state.open || state.awaiting || state.heldIn.size > 0) return;
+  if (state.open || state.awaiting > 0 || state.heldIn.size > 0) return;
   // A drain must have committed the last write (the handler's, or a redirect
   // hop's after the click's own drain) — the handler returning is not the
   // screen having it.
   if (event.writes > 0 && drainSeq <= state.writeDrain) return;
   for (const nav of event.navigations) if (nav.outcome === undefined) return;
+  if (state.joinable) {
+    state.settleAt = end;
+    return;
+  }
   openInteractions.delete(state);
   // Every write went to an excluded subject and nothing of the app's ran: the
   // click was on the observer's own UI (a devtools panel's button). Not a
@@ -2638,6 +2700,12 @@ const engineHooks = {
         frame.prevValue,
         el._pendingValue !== NOT_PENDING ? el._pendingValue : el._value
       );
+    // The same exemption for memos: a run that committed `undefined` did its
+    // work as a side effect (a projection's draft writes or reconcile, a
+    // write from inside a memo), so core's `undefined === undefined` gate
+    // proves nothing. Reported as changed, so no consumer counts it as waste.
+    if (!changed && (el._pendingValue !== NOT_PENDING ? el._pendingValue : el._value) === undefined)
+      changed = true;
     if (frame.causes !== null)
       recordRerun(
         el,