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

package/dist/dev.attribution.js

@@ -1,25 +1,25 @@
 import {
-  bv as OBSERVE,
-  bF as setAttributionHooks,
-  bG as liveRootOwners,
+  bN as OBSERVE,
+  bY as setAttributionHooks,
+  bZ as liveRootOwners,
   N as NOT_PENDING,
-  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,
+  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,
-  bO as GRAPH_SIZE_WARN_AT,
-  bP as noteFanOut,
-  bQ as CONFIG_SUPERSEDES,
-  aV 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);
@@ -1915,8 +1925,7 @@ function checkOptimisticRevert(el, shown, truth, how) {
 // --- Graph growth -----------------------------------------------------------------
 /**
  * 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.
+ * graph's size and the part of it already alive as a navigation opened.
  */
 const routeCounts = new Map();
 /**
@@ -1924,6 +1933,12 @@ const routeCounts = new Map();
  * 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
@@ -1944,7 +1959,7 @@ function graphSize() {
  * 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.
+ * 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) {
@@ -1999,12 +2014,12 @@ function walkGraph(before, survived) {
 }
 /**
  * openNavigation, while the growth check is on: what is alive as a
- * navigation opens, for its settle to tell apart from what it created.
+ * navigation opens, added to what earlier ones met, for its settle to tell
+ * apart from what it created.
  */
 function snapshotGraph() {
-  const before = new WeakSet();
-  walkGraph(before);
-  return before;
+  walkGraph(opened);
+  return opened;
 }
 /**
  * settleNavigation: the app has finished moving to a route — count the live
@@ -2017,10 +2032,19 @@ function snapshotGraph() {
  *
  * 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.
+ * 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(state) {
@@ -2088,7 +2112,7 @@ function trackGraph(state) {
     `(${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,
@@ -3102,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);
   }
 };