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

package/dist/dev.attribution.js

@@ -1,25 +1,25 @@
 import {
-  br as OBSERVE,
-  bB as setAttributionHooks,
-  bC as liveRootOwners,
+  bN as OBSERVE,
+  bY as setAttributionHooks,
+  bZ 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,
+  as as emitDiagnostic,
+  b_ as ownerPath,
+  aJ as reportDiagnostic,
+  b$ as isSuppressed,
+  c0 as blockersOf,
+  c1 as CONFIG_PLUMBING,
+  c2 as anyExcluded,
+  c3 as isExcluded,
+  c4 as CONFIG_WIDE,
+  c 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
+  f as CONFIG_VERDICT,
+  c5 as GRAPH_SIZE_WARN_AT,
+  c6 as noteFanOut,
+  c7 as CONFIG_SUPERSEDES,
+  b0 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. */
@@ -1070,7 +1070,15 @@ function trackEffectWrite(node, record, value) {
   const writer = info === undefined ? 0 : devId(info.node);
   recordNodes.set(record, node);
   n._devSoleWriter = n._devSoleWriter === undefined || n._devSoleWriter === writer ? writer : null;
-  if (info !== undefined && value !== undefined && value === info.node._value) {
+  // An apply half that takes no argument cannot be copying its compute
+  // output: a match is coincidence (`createEffect(open, () =>
+  // setFlipped(measure()))`).
+  if (
+    info !== undefined &&
+    value !== undefined &&
+    value === info.node._value &&
+    (info.node._effectFn?.length ?? 1)
+  ) {
     copyWrites.add(record);
     n._devCopyRuns = n._devCopyFrom === writer ? (n._devCopyRuns ?? 0) + 1 : 1;
     n._devCopyFrom = writer;
@@ -1168,7 +1176,13 @@ function checkRelayTear(victim, causes, prevCauses) {
   // "reset editable state from a source" shape — the tear is real, but a memo
   // is not the answer, so it stays advisory like any other non-derivable tear.
   const derivable = copy && soleWriter;
-  const severity = derivable || state.count >= RELAY_WARN_AT ? "warn" : "info";
+  // An apply half that ignores its argument writes from outside the graph
+  // (layout, time, a ref; a signal read there is STRICT_READ's): measuring,
+  // so it stays advisory however often it repeats.
+  const severity =
+    derivable || (state.count >= RELAY_WARN_AT && (relay.node._effectFn?.length ?? 1))
+      ? "warn"
+      : "info";
   // First sighting always reports (advisory); afterwards only the escalation.
   if (state.count > 1 && (severity !== "warn" || state.warned)) return;
   // One verdict per derivable signal: the copy report (checkCopyEffect) and
@@ -1187,12 +1201,10 @@ function checkRelayTear(victim, causes, prevCauses) {
         `writers — editable state reset from a source. If the reset is the intent, the tear ` +
         `is its cost; if "${write.name}" only ever mirrors the source, drop the local copy ` +
         `and read the source.`
-      : soleWriter
-        ? `Nothing else writes "${write.name}" — it is derived state: make it a memo over what ` +
-          `the effect reads and every reader gets it in the same flush.`
-        : `If "${write.name}" is computed from what the effect reads, make it a memo so readers ` +
-          `get it in the same flush; if the write reads something outside the graph (layout, ` +
-          `time), the tear is the cost of measuring.`;
+      : (soleWriter ? `Nothing else writes "${write.name}". ` : "") +
+        `If "${write.name}" is computed from what the effect reads, make it a memo so readers ` +
+        `get it in the same flush; if the write reads something outside the graph (layout, ` +
+        `time), the tear is the cost of measuring.`;
   const message =
     `[EFFECT_RELAY_TEAR] ${victimKind} "${nodeName(victim)}" ran twice for one write of ` +
     `"${shared.name}": once in the flush where "${shared.name}" changed, and again after ` +
@@ -1363,13 +1375,11 @@ function asyncOrigin(el) {
 // WeakMaps: an errored/abandoned flight must not leak its node or block GC.
 const liveFlights = new WeakMap();
 const landedFlights = new WeakMap();
-/**
- * Flight-object identity → earliest known start. Fed by markFlight() (the
- * cooperative preload/cache declaration — populated even while attribution
- * is disabled, so navigation-time marks survive a later enable()) and by
- * first sightings at registration.
- */
-const flightOrigins = new WeakMap();
+// Flight-object identity → earliest known start lives on the core's slot
+// (`OBSERVE.attribution.markFlight`/`flightOrigin`), so marks made with no
+// engine loaded — a router's preloads, `lazy()`'s import — and the server's
+// boundary check share it. Fed by markFlight() and by first sightings at
+// registration.
 let waterfallLog = [];
 /** Deepest landed-flight cause reachable through a cause list (derived links included). */
 function flightCauseIn(causes) {
@@ -1412,8 +1422,8 @@ function emitFlight(el, flight, endedAt, outcome) {
 }
 function trackFlightStart(el, flight) {
   const at = now();
-  const origin = flightOrigins.get(flight) ?? at;
-  if (origin === at) flightOrigins.set(flight, at);
+  const origin = OBSERVE.attribution.flightOrigin(flight) ?? at;
+  if (origin === at) OBSERVE.attribution.markFlight(flight, at);
   // Census: a flight still in the air when the node starts another was
   // superseded — its answer will be discarded.
   const superseded = liveFlights.get(el);
@@ -1913,8 +1923,22 @@ function checkOptimisticRevert(el, shown, truth, how) {
   );
 }
 // --- Graph growth -----------------------------------------------------------------
-/** Per route: the graph's size at its last `visits` settles, oldest first. */
+/**
+ * Per route: at its last `visits` compared settles, oldest first, the
+ * graph's size and the part of it already alive as a navigation opened.
+ */
 const routeCounts = new Map();
+/**
+ * The route the app last arrived on: a navigation that stays on it (only
+ * its params or query change) continues the visit and is not compared.
+ */
+let visitRoute;
+/**
+ * Every node met as a navigation opened, weakly, for the session: one set,
+ * not one per navigation (see `trackGraph`). Never reset — a node in it was
+ * alive as a navigation opened whichever window met it.
+ */
+const opened = new WeakSet();
 /**
  * The live graph's size — a walk, not a counter: nothing is charged at node
  * creation, disposal, write or re-run; the engine asks at a navigation's
@@ -1929,26 +1953,42 @@ const routeCounts = new Map();
  * counted unless a subscription still reaches them.
  */
 function graphSize() {
+  return walkGraph();
+}
+/**
+ * The walk behind `graphSize()`. Given `before` alone, it adds every node it
+ * meets to that set: what is alive as a navigation opens. Given `before` and
+ * `survived`, it also counts into `survived` the nodes it meets that are in
+ * the set, and an edge when both its ends are: what outlived a navigation.
+ * Nothing is retained — the set is weak.
+ */
+function walkGraph(before, survived) {
   const roots = liveRootOwners();
-  const size = { roots: roots.length, owners: 0, computations: 0, signals: 0, edges: 0 };
+  const size = { roots: 0, owners: 0, computations: 0, signals: 0, edges: 0 };
   const seen = new Set();
   // A worklist, not recursion: a subscriber chain can be thousands deep.
   const work = [];
   const stack = [];
+  const count = (node, key) => {
+    size[key]++;
+    if (survived !== undefined) {
+      if (before.has(node)) survived[key]++;
+    } else if (before !== undefined) before.add(node);
+  };
   const meet = node => {
     if (seen.has(node)) return;
     seen.add(node);
-    if (typeof node._fn === "function") size.computations++;
-    else size.signals++;
+    count(node, typeof node._fn === "function" ? "computations" : "signals");
     work.push(node);
   };
   for (const root of roots) {
-    size.owners++;
+    count(root, "roots");
+    count(root, "owners");
     // Iterative: a deep tree must not grow the call stack.
     let child = root._firstChild;
     for (;;) {
       while (child !== null) {
-        size.owners++;
+        count(child, "owners");
         if (typeof child._fn === "function") meet(child);
         if (child._firstChild !== null) stack.push(child);
         child = child._nextSibling;
@@ -1967,10 +2007,20 @@ function graphSize() {
       for (let link = node._deps; link !== null; link = link._nextDep) {
         size.edges++;
         meet(link._dep);
+        if (survived !== undefined && before.has(node) && before.has(link._dep)) survived.edges++;
       }
   }
   return size;
 }
+/**
+ * openNavigation, while the growth check is on: what is alive as a
+ * navigation opens, added to what earlier ones met, for its settle to tell
+ * apart from what it created.
+ */
+function snapshotGraph() {
+  walkGraph(opened);
+  return opened;
+}
 /**
  * settleNavigation: the app has finished moving to a route — count the live
  * graph. One record per settle for a listener; the growth check compares
@@ -1979,54 +2029,95 @@ function graphSize() {
  * `createRoot` in an effect with no dispose, a subscription a component
  * registered outside its owner. Nothing here runs per node; the walk is
  * the cost, at navigation cadence.
+ *
+ * A count taken at an arrival also holds everything the visit just created,
+ * so a page whose correctly owned content is bigger each visit climbs too.
+ * What tells the two apart is what outlived a navigation: the nodes alive
+ * as this or any earlier navigation opened (`opened`) that are still alive
+ * at this settle. A visit's own content is not among them; what an earlier
+ * visit left behind is, whatever the content does. A series reports only
+ * when both climb.
+ *
+ * The set is the session's, not this navigation's own snapshot: the walk
+ * meets a long-lived source only through a page that reads it, so a
+ * per-navigation snapshot holds a module-level signal (an HMR registry, a
+ * global store) only when the page just left read it too, and arriving from
+ * pages that share ever more with this one read as growth (#4101). Kept
+ * across navigations, such a source counts at every settle once met, the
+ * same each visit; only what keeps accumulating climbs.
  */
 const GRAPH_SERIES = ["owners", "computations", "signals", "edges"];
-function trackGraph(navigation) {
+function trackGraph(state) {
+  const navigation = state.event;
+  const before = state.before;
+  state.before = undefined;
   const cfg = options.graphGrowth;
   if (cfg === false && !records.observed("graph")) return;
-  const size = graphSize();
+  const survived = before && {
+    roots: 0,
+    owners: 0,
+    computations: 0,
+    signals: 0,
+    edges: 0
+  };
+  const size = walkGraph(before, survived);
   const route = navigation.name ?? navigation.to;
   const event = { at: now(), ...size, navigation };
   if (route !== undefined) event.route = route;
   records.emit("graph", event, undefined);
+  if (cfg === false || route === undefined) return;
+  // A navigation that stays on the route pattern continues the visit: the
+  // page it kept outlived the move by design, so comparing it would read the
+  // page itself as growth. Only arrivals that enter the route are compared —
+  // a leak made during a visit is still alive when the next one starts. A
+  // superseded navigation never showed, so the app is still where it was.
+  const left = visitRoute;
+  if (navigation.outcome !== "superseded") visitRoute = route;
   // 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;
+  // A navigation opened before the check was on has no snapshot to compare.
+  if (navigation.initial || route === left || survived === undefined) return;
   let history = routeCounts.get(route);
   if (history === undefined) routeCounts.set(route, (history = []));
-  history.push(size);
+  history.push({ size, survived });
   if (history.length > cfg.visits) history.shift();
   if (history.length < cfg.visits) return;
-  // Any series climbing on every visit to the ratio is growth; which ones
-  // did says what leaked — computations with owners flat is an ownerless
-  // effect per visit, edges alone is a subscription per visit to something
-  // long-lived, owners is an undisposed root.
-  const grew = GRAPH_SERIES.filter(key => {
-    for (let i = 1; i < history.length; i++)
-      if (history[i][key] <= history[i - 1][key]) return false;
-    return history[history.length - 1][key] >= history[0][key] * cfg.ratio;
-  });
+  const totals = history.map(h => h.size);
+  const kept = history.map(h => h.survived);
+  const climbs = (series, key) => {
+    for (let i = 1; i < series.length; i++) if (series[i][key] <= series[i - 1][key]) return false;
+    return series[series.length - 1][key] >= series[0][key] * cfg.ratio;
+  };
+  // Any series climbing on every visit to the ratio — in the totals and in
+  // what outlived each navigation — is growth; which ones did says what
+  // leaked — computations with owners flat is an ownerless effect per visit,
+  // edges alone is a subscription per visit to something long-lived, owners
+  // is an undisposed root.
+  const grew = GRAPH_SERIES.filter(key => climbs(totals, key) && climbs(kept, key));
   if (grew.length === 0) return;
   // The count is the whole graph's, so a leak shows at every route's settle;
   // the first route to complete its climb reports, naming the others seen.
   const routes = [...routeCounts.keys()];
-  const series = grew.map(key => `${key} ${history.map(h => h[key]).join(" → ")}`).join("; ");
+  const join = (series, key) => series.map(h => h[key]).join(" → ");
+  const series = grew.map(key => `${key} ${join(kept, key)} (of ${join(totals, key)})`).join("; ");
   const shape = grew.includes("owners")
     ? "a createRoot() in an effect or handler with no dispose, or a Portal or panel mounted per visit"
     : grew.includes("computations")
       ? "an effect or memo created with no owner (a module-level or callback createEffect) that only its sources keep alive"
       : "a subscription per visit to something long-lived — a global store or signal read by a computation that outlives the visit";
   const message =
-    `[GRAPH_GROWTH] the live graph grew on ${cfg.visits} consecutive visits to ${route}: ${series} ` +
+    `[GRAPH_GROWTH] the live graph grew on ${cfg.visits} consecutive visits to ${route}, and so did ` +
+    `the part that outlived each navigation there: ${series} ` +
     `(${size.roots} roots)${routes.length > 1 ? `, across visits to ${routes.join(", ")}` : ""}. Each ` +
     `visit left something behind that the next did not reclaim — the shape says ${shape}. Dispose ` +
     `what a visit creates (onCleanup, or return the disposer from onSettled) and own it under the ` +
-    `route's component so leaving the route tears it down.`;
+    `route's component so leaving the route tears it down. A cache that never evicts grows alike.`;
   const data = {
     route,
     grew,
-    history: history.map(h => ({ ...h })),
+    history: totals,
+    survived: kept,
     roots: size.roots,
     routes
   };
@@ -2159,6 +2250,14 @@ const openNavs = new Set();
 let navigationLog = [];
 /** Drains completed since enable() — the clock `writeDrain` reads. */
 let drainSeq = 0;
+/**
+ * Navigations settled in a landing, waiting for their graph count: the hook
+ * fires before the landing's commits dispose the frame parked for the page
+ * left, which the walk would still reach through the sources both pages read
+ * (#3989). `land()` runs only inside `flush()`'s drain, so `flushEnd` counts
+ * them, after those commits — the instant a one-drain navigation is counted.
+ */
+const landedGraphs = [];
 /**
  * Copy what the router currently says onto the frame (what writes stamped —
  * `formatOrigin` reads it) and the event. Called when the frame opens, when a
@@ -2193,6 +2292,8 @@ function openNavigation(frame, ref) {
     held: false,
     writeDrain: drainSeq
   };
+  // The initial declaration is never compared (see `trackGraph`).
+  if (options.graphGrowth !== false && ref.initial !== true) state.before = snapshotGraph();
   syncNavigation(state);
   navStates.set(frame, state);
   openNavs.add(state);
@@ -2268,7 +2369,7 @@ function settleNavigations(t, hold) {
     if (state === undefined || !openNavs.has(state)) continue;
     // A navigation whose frame is still open when its transition commits
     // (`until()` inside the frame) settles here too: its writes are through.
-    settleNavigation(state, state.held ? "held" : "committed", hold);
+    settleNavigation(state, state.held ? "held" : "committed", hold, true);
   }
 }
 let openFlush = null;
@@ -2384,11 +2485,14 @@ function trackFlushEnd() {
   drainSeq++;
   // The swaps this drain committed have rendered.
   displayFallbacks();
+  // Landed first: they settled before anything this drain settles below.
+  for (let i = 0; i < landedGraphs.length; i++) trackGraph(landedGraphs[i]);
+  landedGraphs.length = 0;
   for (const state of openNavs)
     if (state.open === 0 && !state.held) settleNavigation(state, "committed");
   for (const state of openInteractions) maybeSettleInteraction(state);
 }
-function settleNavigation(state, outcome, hold) {
+function settleNavigation(state, outcome, hold, landed) {
   if (!openNavs.has(state)) return;
   openNavs.delete(state);
   syncNavigation(state);
@@ -2401,7 +2505,8 @@ function settleNavigation(state, outcome, hold) {
   // 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);
+  if (landed) landedGraphs.push(state);
+  else trackGraph(state);
   // The interaction that performed it may have been waiting only on this.
   const under = openInteractionOf(event.interaction);
   if (under !== undefined) maybeSettleInteraction(under);
@@ -2885,8 +2990,10 @@ function resetTracking() {
   stagedFallbacks.delete(DRAIN);
   trackingGen++;
   openNavs.clear();
+  landedGraphs.length = 0;
   openInteractions.clear();
   routeCounts.clear();
+  visitRoute = undefined;
   drainSeq = 0;
   originFrames.length = 0;
   effectStack.length = 0;
@@ -3019,11 +3126,10 @@ const attribution = {
     // The buffers are typed by their variable; the switch is the proof.
     return buffer;
   },
-  markFlight(flight, startedAt = now()) {
-    // Earliest wins: re-marking (a cache re-serving the same promise) must
-    // not move the origin later.
-    const existing = flightOrigins.get(flight);
-    if (existing === undefined || startedAt < existing) flightOrigins.set(flight, startedAt);
+  markFlight(flight, startedAt) {
+    // Earliest wins (the slot's rule): re-marking (a cache re-serving the
+    // same promise) must not move the origin later.
+    OBSERVE.attribution.markFlight(flight, startedAt);
   }
 };