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

package/dist/dev.attribution.js

@@ -1,25 +1,25 @@
 import {
-  br as OBSERVE,
-  bB as setAttributionHooks,
-  bC as liveRootOwners,
+  bv as OBSERVE,
+  bF as setAttributionHooks,
+  bG 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,
+  ap as emitDiagnostic,
+  bH as ownerPath,
+  aD as reportDiagnostic,
+  bI as isSuppressed,
+  bJ as blockersOf,
+  bK as CONFIG_PLUMBING,
+  bL as anyExcluded,
+  bM as isExcluded,
+  bN 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
+  bO as GRAPH_SIZE_WARN_AT,
+  bP as noteFanOut,
+  bQ as CONFIG_SUPERSEDES,
+  aV 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. */
@@ -1913,8 +1913,17 @@ 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 that was already alive when that
+ * 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;
 /**
  * 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 +1938,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 the 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 +1992,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, for its settle to tell apart from what it created.
+ */
+function snapshotGraph() {
+  const before = new WeakSet();
+  walkGraph(before);
+  return before;
+}
 /**
  * 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,46 +2014,77 @@ 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 the navigation: the nodes alive
+ * when it opened (`NavState.before`) that are still alive at its 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.
  */
 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 ` +
@@ -2026,7 +2092,8 @@ function trackGraph(navigation) {
   const data = {
     route,
     grew,
-    history: history.map(h => ({ ...h })),
+    history: totals,
+    survived: kept,
     roots: size.roots,
     routes
   };
@@ -2159,6 +2226,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 +2268,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 +2345,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 +2461,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 +2481,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 +2966,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;