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

package/dist/observe/core/attribution.js

@@ -17,11 +17,11 @@ import { blockersOf, GlobalQueue } from "./scheduler.js";
  * observer exclusion is cached per node once any exists, before that a flag
  * read.
  */ function excludedNode(e) {
-    if ((e.u & CONFIG_PLUMBING) !== 0) return true;
+    if ((e.l & CONFIG_PLUMBING) !== 0) return true;
     if (!anyExcluded()) return false;
     const n = e;
-    if (n.me === undefined) n.me = isExcluded(e);
-    return n.me;
+    if (n.he === undefined) n.he = isExcluded(e);
+    return n.he;
 }
 
 let attributionActive = false;
@@ -327,7 +327,7 @@ const effectFrames = new WeakMap;
     const n = effectStack[effectStack.length - 1];
     if (n !== undefined) effectFrames.set(e, {
         node: n,
-        causes: n.ge
+        causes: n.pe
     });
 }
 
@@ -345,7 +345,7 @@ function pushFrame(e, n, t, o) {
     if (s !== undefined) i.interaction = s;
     if (o !== undefined) {
         const e = o;
-        if (e.we !== undefined) i.run = e.we;
+        if (e.me !== undefined) i.run = e.me;
         // The frame → node map is filled by the first write inside the callback
         // (noteEffectOrigin), not here: most callbacks never write.
                 effectStack.push(o);
@@ -458,9 +458,9 @@ function originEnd() {
     if (typeof t !== "number") return;
     let o = 0;
     let i = 0;
-    for (let n = e.t; n !== null; n = n.l) {
+    for (let n = e.o; n !== null; n = n.t) {
         o++;
-        if (!(n.o.u & CONFIG_PLUMBING)) i++;
+        if (!(n.u.l & CONFIG_PLUMBING)) i++;
     }
     if (i < t || o >= GRAPH_SIZE_WARN_AT) return;
     noteFanOut(e, i, n);
@@ -483,8 +483,8 @@ function stampWrite(e, n, t = NO_VALUES, o = NO_VALUES) {
     i.origin = n === "async" ? asyncOrigin(e) : currentOrigin();
     i.at = now();
     i.stack = captureStack();
-    const s = e.ve;
-    e.ve = i;
+    const s = e.ge;
+    e.ge = i;
     noteNavigationWrite(s, i);
     noteInteractionWrite(i.origin, excludedNode(e));
     if (n === "write") trackEffectWrite(e, i, o);
@@ -495,7 +495,7 @@ function stampWrite(e, n, t = NO_VALUES, o = NO_VALUES) {
 }
 
 /** Record a derived change (memo produced a new value) with its causes. */ function stampDerived(e, n) {
-    e.ve = {
+    e.ge = {
         seq: ++changeSeq,
         kind: "derived",
         name: nodeName(e),
@@ -510,19 +510,19 @@ function stampWrite(e, n, t = NO_VALUES, o = NO_VALUES) {
  * run's links. A refresh() stamp on the node itself also counts — that is a
  * self-invalidation, not a dep change.
  */ function collectCauses(e) {
-    const n = e.ke ?? 0;
+    const n = e.we ?? 0;
     const t = [];
-    const o = e.ve;
+    const o = e.ge;
     if (o !== undefined && o.seq > n && o.kind === "refresh") t.push(o);
-    for (let o = e._; o !== null; o = o.p) {
-        const e = o.I.ve;
+    for (let o = e.C; o !== null; o = o.G) {
+        const e = o.S.ge;
         if (e !== undefined && e.seq > n) t.push(e);
     }
     return t;
 }
 
 /** Advance the node's seen-cursor to the present. Call after every run. */ function markSeen(e) {
-    e.ke = changeSeq;
+    e.we = changeSeq;
 }
 
 /**
@@ -534,9 +534,9 @@ function stampWrite(e, n, t = NO_VALUES, o = NO_VALUES) {
  * still owed) and not part of the subscription diff.
  */ function captureDeps(e) {
     const n = [];
-    for (let t = e._; t !== null; t = t.p) {
-        n.push(t.I);
-        if (t === e.S) break;
+    for (let t = e.C; t !== null; t = t.G) {
+        n.push(t.S);
+        if (t === e._) break;
     }
     return n;
 }
@@ -555,18 +555,18 @@ function stampWrite(e, n, t = NO_VALUES, o = NO_VALUES) {
         if (n === false || false) return;
     let t = 0;
     const o = [];
-    for (let n = e._; n !== null; n = n.p) {
+    for (let n = e.C; n !== null; n = n.G) {
         // HMR plumbing is a dev-only hop the scope cannot read past: not a source.
-        if (!(n.I.u & CONFIG_PLUMBING)) {
+        if (!(n.S.l & CONFIG_PLUMBING)) {
             t++;
-            if (o.length < 12) o.push(nodeName(n.I));
+            if (o.length < 12) o.push(nodeName(n.S));
         }
-        if (n === e.S) break;
+        if (n === e._) break;
  // the validated prefix, as captureDeps
         }
     const i = e;
-    if (t < n || t < (i.ye ?? 0) * 1.5) return;
-    i.ye = t;
+    if (t < n || t < (i.ve ?? 0) * 1.5) return;
+    i.ve = t;
     const s = `[WIDE_SCOPE_DEPS] ${nodeKind(e)} "${nodeName(e)}" is subscribed to ${t} sources — ` + `it re-runs when any of them change. Narrow its reads or split it into smaller memos. ` + `Sources: ${o.join(", ")}${t > o.length ? ", …" : ""}`;
     reportDiagnostic(emitDiagnostic({
         code: "WIDE_SCOPE_DEPS",
@@ -595,14 +595,14 @@ const HOT_FANOUT_FIRST_MILESTONE = 5;
     if (t === false) return;
     const o = e;
     const i = Date.now();
-    if (o.$e === undefined || i - o.$e > t.windowMs) {
-        o.$e = i;
-        o.be = 0;
-        o.Fe = false;
-    }
-    o.be = (o.be ?? 0) + 1;
-    if (o.Fe || o.be < t.count) return;
-    o.Fe = true;
+    if (o.ke === undefined || i - o.ke > t.windowMs) {
+        o.ke = i;
+        o.ye = 0;
+        o.$e = false;
+    }
+    o.ye = (o.ye ?? 0) + 1;
+    if (o.$e || o.ye < t.count) return;
+    o.$e = true;
     // Root-cause key: the set of originating writes behind this scope's latest
     // re-run. Scopes hot from the SAME roots share one aggregation window.
         const s = new Set;
@@ -619,10 +619,10 @@ const HOT_FANOUT_FIRST_MILESTONE = 5;
         hotCauses.set(r, a);
     }
     a.scopes++;
-    a.runs += o.be;
+    a.runs += o.ye;
     if (a.scopes === 1) {
         const s = n.map(e => `"${e.name}" (${e.kind})`).join(", ");
-        const r = `[HOT_SCOPE_RERUNS] ${nodeKind(e)} "${nodeName(e)}" re-ran ${o.be} times ` + `in ${Math.max(1, i - o.$e)}ms — a hot signal is likely leaking into this ` + `scope. Latest cause: ${s || "(untracked pull)"}`;
+        const r = `[HOT_SCOPE_RERUNS] ${nodeKind(e)} "${nodeName(e)}" re-ran ${o.ye} times ` + `in ${Math.max(1, i - o.ke)}ms — a hot signal is likely leaking into this ` + `scope. Latest cause: ${s || "(untracked pull)"}`;
         reportDiagnostic(emitDiagnostic({
             code: "HOT_SCOPE_RERUNS",
             kind: "perf",
@@ -630,7 +630,7 @@ const HOT_FANOUT_FIRST_MILESTONE = 5;
             message: r,
             nodeName: nodeName(e),
             data: {
-                runs: o.be,
+                runs: o.ye,
                 windowMs: t.windowMs,
                 causes: n.map(e => e.name)
             }
@@ -668,16 +668,16 @@ const HOT_FANOUT_FIRST_MILESTONE = 5;
     if (o === false) return;
     const i = e;
     const s = now();
-    if (i.Le === undefined || s - i.Le > o.windowMs) {
-        i.Le = s;
-        i.Ce = 0;
-        i.Me = false;
-    }
-    i.Ce = (i.Ce ?? 0) + n;
-    if (i.Me || i.Ce < o.budgetMs) return;
-    i.Me = true;
+    if (i.be === undefined || s - i.be > o.windowMs) {
+        i.be = s;
+        i.Oe = 0;
+        i.Fe = false;
+    }
+    i.Oe = (i.Oe ?? 0) + n;
+    if (i.Fe || i.Oe < o.budgetMs) return;
+    i.Fe = true;
     const r = t.map(e => `"${e.name}" (${e.kind})`).join(", ");
-    const a = `[HOT_SCOPE_TIME] ${nodeKind(e)} "${nodeName(e)}" spent ` + `${i.Ce.toFixed(1)}ms of compute inside one ${o.windowMs}ms window ` + `(budget ${o.budgetMs}ms). Latest cause: ${r || "(untracked pull)"}`;
+    const a = `[HOT_SCOPE_TIME] ${nodeKind(e)} "${nodeName(e)}" spent ` + `${i.Oe.toFixed(1)}ms of compute inside one ${o.windowMs}ms window ` + `(budget ${o.budgetMs}ms). Latest cause: ${r || "(untracked pull)"}`;
     reportDiagnostic(emitDiagnostic({
         code: "HOT_SCOPE_TIME",
         kind: "perf",
@@ -685,7 +685,7 @@ const HOT_FANOUT_FIRST_MILESTONE = 5;
         message: a,
         nodeName: nodeName(e),
         data: {
-            spentMs: i.Ce,
+            spentMs: i.Oe,
             budgetMs: o.budgetMs,
             windowMs: o.windowMs,
             causes: t.map(e => e.name)
@@ -710,24 +710,24 @@ const HOT_FANOUT_FIRST_MILESTONE = 5;
     // This runs on every re-run: fields on the node (one property read each,
     // like hotRuns) and the run's own `at` — no clock read, no map lookup.
         const a = e;
-    if (a.He === undefined || n - a.He > r.windowMs) {
-        a.He = n;
-        a.We = 0;
-        a.Ge = 0;
-        a.qe = 0;
-        a.Be = false;
-    }
-    a.We = a.We + 1;
+    if (a._e === undefined || n - a._e > r.windowMs) {
+        a._e = n;
+        a.Ae = 0;
+        a.Re = 0;
+        a.Le = 0;
+        a.Ce = false;
+    }
+    a.Ae = a.Ae + 1;
     if (!o) {
-        a.Ge = a.Ge + 1;
-        a.qe = a.qe + i;
+        a.Re = a.Re + 1;
+        a.Le = a.Le + i;
     }
-    if (a.Be || a.We < r.minRuns || a.Ge / a.We < r.ratio || a.qe < r.budgetMs) return;
-    a.Be = true;
+    if (a.Ce || a.Ae < r.minRuns || a.Re / a.Ae < r.ratio || a.Le < r.budgetMs) return;
+    a.Ce = true;
     const c = {
-        runs: a.We,
-        wasted: a.Ge,
-        wastedMs: a.qe
+        runs: a.Ae,
+        wasted: a.Re,
+        wastedMs: a.Le
     };
     const d = s.map(e => `"${e.name}" (${e.kind})`).join(", ");
     const f = `[WASTED_RECOMPUTE] ${nodeKind(e)} "${nodeName(e)}" re-ran ${c.runs} times in ` + `${r.windowMs}ms and ${c.wasted} of those produced the same value — ` + `${c.wastedMs.toFixed(1)}ms of compute the equality gate then discarded. Its inputs ` + `change without changing its result: put an equality boundary upstream (a memo over the ` + `part of the input it reads, or an \`equals\` on the source), or read a narrower slice ` + `(the property, not the object). Latest cause: ${d || "(untracked pull)"}`;
@@ -750,14 +750,14 @@ const HOT_FANOUT_FIRST_MILESTONE = 5;
 function recordRerun(e, n, t, o, i, s) {
     const r = n.causes;
     const a = e;
-    const c = a.ge;
+    const c = a.pe;
     const d = n.interaction;
     if (excludedNode(e)) {
         // The observer's own computation: keep the per-node bookkeeping its
         // effect phase reads (see effectRunStart) and record nothing.
-        a.xe = d;
-        a.we = undefined;
-        a.ge = r;
+        a.Me = d;
+        a.me = undefined;
+        a.pe = r;
         return;
     }
     // The facts every run leaves on the node, record or not: the run sequence
@@ -766,10 +766,10 @@ function recordRerun(e, n, t, o, i, s) {
     // cause list of its own, so it takes this run's interaction and causes
     // (see effectRunStart / pushFrame).
         const f = ++runSeq;
-    const u = a.Ke = (a.Ke ?? 0) + 1;
-    a.xe = d;
-    a.we = f;
-    a.ge = r;
+    const u = a.De = (a.De ?? 0) + 1;
+    a.Me = d;
+    a.me = f;
+    a.pe = r;
     noteInteractionRun(d, t.selfMs, false);
     if (openFlush !== null) noteFlushRun(openFlush, false, d);
     // The checks read the facts, not the record, so they run with or without
@@ -910,15 +910,15 @@ function shallowEquivalent(e, n) {
     const i = e;
     if (n === t || // paranoia: changed runs should never hit this
     !isPlainShape(n) || !isPlainShape(t) || !shallowEquivalent(n, t)) {
-        i.Ve = 0;
-        i.je = false;
+        i.He = 0;
+        i.We = false;
         return;
     }
-    i.Ve = (i.Ve ?? 0) + 1;
-    if (i.je || i.Ve < o) return;
-    i.je = true;
+    i.He = (i.He ?? 0) + 1;
+    if (i.We || i.He < o) return;
+    i.We = true;
     const s = Array.isArray(t) ? "array" : "object";
-    const r = `[UNSTABLE_MEMO_OUTPUT] memo "${nodeName(e)}" produced a new-but-equivalent ${s} on ` + `${i.Ve} consecutive runs — its equality gate never closes, so every ` + `subscriber re-runs on every upstream change. Return stable references or pass an ` + `\`equals\` option.`;
+    const r = `[UNSTABLE_MEMO_OUTPUT] memo "${nodeName(e)}" produced a new-but-equivalent ${s} on ` + `${i.He} consecutive runs — its equality gate never closes, so every ` + `subscriber re-runs on every upstream change. Return stable references or pass an ` + `\`equals\` option.`;
     reportDiagnostic(emitDiagnostic({
         code: "UNSTABLE_MEMO_OUTPUT",
         kind: "perf",
@@ -926,7 +926,7 @@ function shallowEquivalent(e, n) {
         message: r,
         nodeName: nodeName(e),
         data: {
-            runs: i.Ve,
+            runs: i.He,
             shape: s
         }
     }, e));
@@ -1065,17 +1065,20 @@ const copyReported = new WeakSet;
     const s = i !== undefined && i.kind === "effect" ? effectFrames.get(i) : undefined;
     const r = s === undefined ? 0 : devId(s.node);
     recordNodes.set(n, e);
-    o.Ye = o.Ye === undefined || o.Ye === r ? r : null;
-    if (s !== undefined && t !== undefined && t === s.node.pe) {
+    o.Pe = o.Pe === undefined || o.Pe === r ? r : null;
+    // An apply half that takes no argument cannot be copying its compute
+    // output: a match is coincidence (`createEffect(open, () =>
+    // setFlipped(measure()))`).
+        if (s !== undefined && t !== undefined && t === s.node.Ie && (s.node.Ge?.length ?? 1)) {
         copyWrites.add(n);
-        o.ze = o.Xe === r ? (o.ze ?? 0) + 1 : 1;
-        o.Xe = r;
-        if (o.ze >= 2 && o.Ye === r) checkCopyEffect(s.node, e);
-    } else o.ze = 0;
+        o.Ue = o.qe === r ? (o.Ue ?? 0) + 1 : 1;
+        o.qe = r;
+        if (o.Ue >= 2 && o.Pe === r) checkCopyEffect(s.node, e);
+    } else o.Ue = 0;
 }
 
 /** The effect's source whose current value the compute output is, if any (the prop-to-state port). */ function passthroughSource(e) {
-    for (let n = e._; n !== null; n = n.p) if (n.I.pe === e.pe) return nodeName(n.I);
+    for (let n = e.C; n !== null; n = n.G) if (n.S.Ie === e.Ie) return nodeName(n.S);
     return undefined;
 }
 
@@ -1148,13 +1151,16 @@ function checkCopyEffect(e, n) {
     c.count++;
     const d = copyWrites.has(s);
     const f = recordNodes.get(s);
-    const u = f !== undefined && f.Ye === devId(i.node);
+    const u = f !== undefined && f.Pe === devId(i.node);
     // Derivable outright: the value is the compute output and nothing else
     // writes the signal. A copy INTO a signal that has other writers is the
     // "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 l = d && u;
-    const h = l || c.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 h = l || c.count >= RELAY_WARN_AT && (i.node.Ge?.length ?? 1) ? "warn" : "info";
     // First sighting always reports (advisory); afterwards only the escalation.
         if (c.count > 1 && (h !== "warn" || c.warned)) return;
     // One verdict per derivable signal: the copy report (checkCopyEffect) and
@@ -1166,7 +1172,7 @@ function checkCopyEffect(e, n) {
     if (h === "warn") c.warned = true;
     const p = e.i ? "effect" : "memo";
     const m = nodeName(i.node);
-    const g = l ? copyRepair(i.node, s.name) : d ? `The written value is the effect's compute output, but "${s.name}" has other ` + `writers — editable state reset from a source. If the reset is the intent, the tear ` + `is its cost; if "${s.name}" only ever mirrors the source, drop the local copy ` + `and read the source.` : u ? `Nothing else writes "${s.name}" — it is derived state: make it a memo over what ` + `the effect reads and every reader gets it in the same flush.` : `If "${s.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 g = l ? copyRepair(i.node, s.name) : d ? `The written value is the effect's compute output, but "${s.name}" has other ` + `writers — editable state reset from a source. If the reset is the intent, the tear ` + `is its cost; if "${s.name}" only ever mirrors the source, drop the local copy ` + `and read the source.` : (u ? `Nothing else writes "${s.name}". ` : "") + `If "${s.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 w = `[EFFECT_RELAY_TEAR] ${p} "${nodeName(e)}" ran twice for one write of ` + `"${r.name}": once in the flush where "${r.name}" changed, and again after ` + `effect "${m}" relayed it by writing "${s.name}" — the first frame showed the ` + `new "${r.name}" with the stale "${s.name}"` + (c.count > 1 ? ` (${c.count} times so far)` : "") + `. ${g}`;
     emitDiagnostic({
         code: "EFFECT_RELAY_TEAR",
@@ -1255,7 +1261,7 @@ const listIdentityWarned = new WeakSet;
 function recordId(e) {
     if (e === null || typeof e !== "object") return undefined;
     const n = e;
-    return n.id ?? n.key ?? n.Qe ?? undefined;
+    return n.id ?? n.key ?? n.Be ?? undefined;
 }
 
 function checkListIdentity(e, n, t, o, i) {
@@ -1317,13 +1323,11 @@ 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(e) {
@@ -1366,8 +1370,8 @@ let waterfallLog = [];
 
 function trackFlightStart(e, n) {
     const t = now();
-    const o = flightOrigins.get(n) ?? t;
-    if (o === t) flightOrigins.set(n, t);
+    const o = OBSERVE.attribution.flightOrigin(n) ?? t;
+    if (o === t) OBSERVE.attribution.markFlight(n, t);
     // Census: a flight still in the air when the node starts another was
     // superseded — its answer will be discarded.
         const i = liveFlights.get(e);
@@ -1412,7 +1416,7 @@ function trackFlightStart(e, n) {
     const o = t - n.origin;
     for (const n of folds) n.flightLanded?.(e, o);
     if (records.observed("flight")) emitFlight(e, n, t, "landed");
-    const i = e.ve;
+    const i = e.ge;
     // Only a stamp this landing produced may carry the measurement — a stale
     // async record from a previous landing must not be re-labeled.
         if (i !== undefined && i.kind === "async" && i.seq > n.startSeq) landedFlights.set(i, {
@@ -1448,8 +1452,8 @@ function checkWaterfall(e, n, t) {
     }
     if (i < 2) return;
     const r = e;
-    if ((r.Ze ?? 0) >= i) return;
-    r.Ze = i;
+    if ((r.xe ?? 0) >= i) return;
+    r.xe = i;
     const a = [ ...n.slice(n.length - (i - 1)), {
         name: nodeName(e),
         ms: t
@@ -1486,7 +1490,7 @@ let holdLog = [];
 /** 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(e) {
-    return (e.u & (CONFIG_OVERRIDE | CONFIG_GUESS)) === CONFIG_OVERRIDE;
+    return (e.l & (CONFIG_OVERRIDE | CONFIG_GUESS)) === CONFIG_OVERRIDE;
 }
 
 const HOLD_CENSUS_CAP = 1e4;
@@ -1512,9 +1516,9 @@ function acknowledge(e, n, t, o) {
     const t = {
         left: HOLD_CENSUS_CAP
     };
-    const o = GlobalQueue.Je?.(e);
+    const o = GlobalQueue.Ke?.(e);
     if (o !== undefined) for (const e of o) acknowledge(n, "optimistic", nodeName(e), reachesEffect(e, t));
-    if (e.T !== null) for (const o of e.T) acknowledge(n, "affects", nodeName(o), reachesEffect(o, t));
+    if (e.I !== null) for (const o of e.I) acknowledge(n, "affects", nodeName(o), reachesEffect(o, t));
 }
 
 /**
@@ -1528,8 +1532,8 @@ function acknowledge(e, n, t, o) {
     const o = [ e ];
     while (o.length > 0 && n.left-- > 0) {
         const e = o.pop();
-        for (let n = e.t; n !== null; n = n.l) {
-            const e = n.o;
+        for (let n = e.o; n !== null; n = n.t) {
+            const e = n.u;
             if (e.i) return e;
             if (!t.has(e)) {
                 t.add(e);
@@ -1553,10 +1557,10 @@ function acknowledge(e, n, t, o) {
         const e = o.pop();
         if (t.has(e)) continue;
         t.add(e);
-        for (let t = e.t; t !== null; t = t.l) {
-            const s = t.o;
-            if (s.u & CONFIG_VERDICT) {
-                const t = s.en ?? 0;
+        for (let t = e.o; t !== null; t = t.t) {
+            const s = t.u;
+            if (s.l & CONFIG_VERDICT) {
+                const t = s.Ve ?? 0;
                 const o = s.i ? s : reachesEffect(s, i);
                 if (t & 1 && o !== null) acknowledge(n, "isPending", nodeName(e), o);
                 if (t & 2 && o !== null) acknowledge(n, "latest", nodeName(e), o);
@@ -1628,9 +1632,9 @@ function trackHoldSettled(e) {
     let i;
     let s;
     let r = -Infinity;
-    for (const n of e.nn) {
-        if (typeof n.re === "function" || isCompanion(n)) continue;
-        const e = n.ve;
+    for (const n of e.je) {
+        if (typeof n.X === "function" || isCompanion(n)) continue;
+        const e = n.ge;
         if (e === undefined || e.kind !== "write") continue;
         if (o === null) o = n;
         const a = {
@@ -1657,7 +1661,7 @@ function trackHoldSettled(e) {
         return;
     }
     censusRegistrations(e, n);
-    censusCompanions([ ...e.nn, ...n.blockers ], n);
+    censusCompanions([ ...e.je, ...n.blockers ], n);
     const a = 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
@@ -1818,7 +1822,7 @@ function checkLongHold(e, n) {
     if (!options.optimisticReverts || isCompanion(e)) return;
     // Method call, as every commit path does: store slot nodes share one
     // comparator that reads `this._host` (#3687).
-        const i = e.tn;
+        const i = e.Ye;
     if (i && i.call(e, n, t)) return;
     const s = nodeName(e);
     // The two values are user data: quoted only under `values: "full"`; the
@@ -1845,7 +1849,21 @@ function checkLongHold(e, n) {
 }
 
 // --- Graph growth -----------------------------------------------------------------
-/** Per route: the graph's size at its last `visits` settles, oldest first. */ const routeCounts = new Map;
+/**
+ * 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
@@ -1860,51 +1878,78 @@ function checkLongHold(e, n) {
  * millisecond. Dormant nodes are spliced out of their chain and are not
  * counted unless a subscription still reaches them.
  */ function graphSize() {
-    const e = liveRootOwners();
-    const n = {
-        roots: e.length,
+    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(e, n) {
+    const t = liveRootOwners();
+    const o = {
+        roots: 0,
         owners: 0,
         computations: 0,
         signals: 0,
         edges: 0
     };
-    const t = new Set;
+    const i = new Set;
     // A worklist, not recursion: a subscriber chain can be thousands deep.
-        const o = [];
-    const i = [];
+        const s = [];
+    const r = [];
+    const count = (t, i) => {
+        o[i]++;
+        if (n !== undefined) {
+            if (e.has(t)) n[i]++;
+        } else if (e !== undefined) e.add(t);
+    };
     const meet = e => {
-        if (t.has(e)) return;
-        t.add(e);
-        if (typeof e.re === "function") n.computations++; else n.signals++;
-        o.push(e);
+        if (i.has(e)) return;
+        i.add(e);
+        count(e, typeof e.X === "function" ? "computations" : "signals");
+        s.push(e);
     };
-    for (const t of e) {
-        n.owners++;
+    for (const e of t) {
+        count(e, "roots");
+        count(e, "owners");
         // Iterative: a deep tree must not grow the call stack.
-                let e = t.sn;
+                let n = e.ze;
         for (;;) {
-            while (e !== null) {
-                n.owners++;
-                if (typeof e.re === "function") meet(e);
-                if (e.sn !== null) i.push(e);
-                e = e.rn;
+            while (n !== null) {
+                count(n, "owners");
+                if (typeof n.X === "function") meet(n);
+                if (n.ze !== null) r.push(n);
+                n = n.Xe;
             }
-            const t = i.pop();
-            if (t === undefined) break;
-            e = t.sn;
+            const e = r.pop();
+            if (e === undefined) break;
+            n = e.ze;
         }
     }
-    for (let e = 0; e < o.length; e++) {
-        const t = o[e];
+    for (let t = 0; t < s.length; t++) {
+        const i = s[t];
         // Whoever reads this node: owned computations are already known; an
         // ownerless one is met only here.
-                for (let e = t.t; e !== null; e = e.l) meet(e.o);
-        if (typeof t.re === "function") for (let e = t._; e !== null; e = e.p) {
-            n.edges++;
-            meet(e.I);
+                for (let e = i.o; e !== null; e = e.t) meet(e.u);
+        if (typeof i.X === "function") for (let t = i.C; t !== null; t = t.G) {
+            o.edges++;
+            meet(t.S);
+            if (n !== undefined && e.has(i) && e.has(t.S)) n.edges++;
         }
     }
-    return n;
+    return o;
+}
+
+/**
+ * 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;
 }
 
 /**
@@ -1915,63 +1960,105 @@ function checkLongHold(e, n) {
  * `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(e) {
-    const n = options.graphGrowth;
-    if (n === false && !records.observed("graph")) return;
-    const t = graphSize();
-    const o = e.name ?? e.to;
-    const i = {
+    const n = e.event;
+    const t = e.before;
+    e.before = undefined;
+    const o = options.graphGrowth;
+    if (o === false && !records.observed("graph")) return;
+    const i = t && {
+        roots: 0,
+        owners: 0,
+        computations: 0,
+        signals: 0,
+        edges: 0
+    };
+    const s = walkGraph(t, i);
+    const r = n.name ?? n.to;
+    const a = {
         at: now(),
-        ...t,
-        navigation: e
+        ...s,
+        navigation: n
     };
-    if (o !== undefined) i.route = o;
-    records.emit("graph", i, undefined);
+    if (r !== undefined) a.route = r;
+    records.emit("graph", a, undefined);
+    if (o === false || r === 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 c = visitRoute;
+    if (n.outcome !== "superseded") visitRoute = r;
     // 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 (n === false || o === undefined || e.initial) return;
-    let s = routeCounts.get(o);
-    if (s === undefined) routeCounts.set(o, s = []);
-    s.push(t);
-    if (s.length > n.visits) s.shift();
-    if (s.length < n.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 r = GRAPH_SERIES.filter(e => {
-        for (let n = 1; n < s.length; n++) if (s[n][e] <= s[n - 1][e]) return false;
-        return s[s.length - 1][e] >= s[0][e] * n.ratio;
+    // A navigation opened before the check was on has no snapshot to compare.
+        if (n.initial || r === c || i === undefined) return;
+    let d = routeCounts.get(r);
+    if (d === undefined) routeCounts.set(r, d = []);
+    d.push({
+        size: s,
+        survived: i
     });
-    if (r.length === 0) return;
+    if (d.length > o.visits) d.shift();
+    if (d.length < o.visits) return;
+    const f = d.map(e => e.size);
+    const u = d.map(e => e.survived);
+    const climbs = (e, n) => {
+        for (let t = 1; t < e.length; t++) if (e[t][n] <= e[t - 1][n]) return false;
+        return e[e.length - 1][n] >= e[0][n] * o.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 l = GRAPH_SERIES.filter(e => climbs(f, e) && climbs(u, e));
+    if (l.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 a = [ ...routeCounts.keys() ];
-    const c = r.map(e => `${e} ${s.map(n => n[e]).join(" → ")}`).join("; ");
-    const d = r.includes("owners") ? "a createRoot() in an effect or handler with no dispose, or a Portal or panel mounted per visit" : r.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 f = `[GRAPH_GROWTH] the live graph grew on ${n.visits} consecutive visits to ${o}: ${c} ` + `(${t.roots} roots)${a.length > 1 ? `, across visits to ${a.join(", ")}` : ""}. Each ` + `visit left something behind that the next did not reclaim — the shape says ${d}. 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.`;
-    const u = {
-        route: o,
-        grew: r,
-        history: s.map(e => ({
-            ...e
-        })),
-        roots: t.roots,
-        routes: a
+        const h = [ ...routeCounts.keys() ];
+    const join = (e, n) => e.map(e => e[n]).join(" → ");
+    const p = l.map(e => `${e} ${join(u, e)} (of ${join(f, e)})`).join("; ");
+    const m = l.includes("owners") ? "a createRoot() in an effect or handler with no dispose, or a Portal or panel mounted per visit" : l.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 g = `[GRAPH_GROWTH] the live graph grew on ${o.visits} consecutive visits to ${r}, and so did ` + `the part that outlived each navigation there: ${p} ` + `(${s.roots} roots)${h.length > 1 ? `, across visits to ${h.join(", ")}` : ""}. Each ` + `visit left something behind that the next did not reclaim — the shape says ${m}. 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. A cache that never evicts grows alike.`;
+    const w = {
+        route: r,
+        grew: l,
+        history: f,
+        survived: u,
+        roots: s.roots,
+        routes: h
     };
-    if (e.interaction !== undefined) u.interaction = {
-        type: e.interaction.name,
-        target: e.interaction.target
+    if (n.interaction !== undefined) w.interaction = {
+        type: n.interaction.name,
+        target: n.interaction.target
     };
     reportDiagnostic(emitDiagnostic({
         code: "GRAPH_GROWTH",
         kind: "perf",
         severity: "warn",
-        message: f,
-        data: u
+        message: g,
+        data: w
     }, null));
     // Judged once for the graph, not once per route: the next verdict needs
     // another `visits` climbing settles.
@@ -2088,6 +2175,14 @@ 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
@@ -2126,6 +2221,8 @@ function openNavigation(e, n) {
         held: false,
         writeDrain: drainSeq
     };
+    // The initial declaration is never compared (see `trackGraph`).
+        if (options.graphGrowth !== false && n.initial !== true) o.before = snapshotGraph();
     syncNavigation(o);
     navStates.set(e, o);
     openNavs.add(o);
@@ -2186,8 +2283,8 @@ function closeNavigation(e) {
 
 /** holdStart: `t`'s staged writes are parked — their navigations settle with `t`. */ function markNavigationsHeld(e) {
     if (openNavs.size === 0) return;
-    for (const n of e.nn) {
-        const e = n.ve?.origin;
+    for (const n of e.je) {
+        const e = n.ge?.origin;
         if (e?.kind !== "navigation") continue;
         const t = navStates.get(e);
         if (t !== undefined) t.held = true;
@@ -2196,14 +2293,14 @@ function closeNavigation(e) {
 
 /** transitionSettled: `t` commits — the navigations whose writes it staged are done. */ function settleNavigations(e, n) {
     if (openNavs.size === 0) return;
-    for (const t of e.nn) {
-        const e = t.ve?.origin;
+    for (const t of e.je) {
+        const e = t.ge?.origin;
         if (e?.kind !== "navigation") continue;
         const o = navStates.get(e);
         if (o === undefined || !openNavs.has(o)) continue;
         // A navigation whose frame is still open when its transition commits
         // (`until()` inside the frame) settles here too: its writes are through.
-                settleNavigation(o, o.held ? "held" : "committed", n);
+                settleNavigation(o, o.held ? "held" : "committed", n, true);
     }
 }
 
@@ -2330,27 +2427,30 @@ function trackFallback(e, n, t, o) {
     drainSeq++;
     // The swaps this drain committed have rendered.
         displayFallbacks();
+    // Landed first: they settled before anything this drain settles below.
+        for (let e = 0; e < landedGraphs.length; e++) trackGraph(landedGraphs[e]);
+    landedGraphs.length = 0;
     for (const e of openNavs) if (e.open === 0 && !e.held) settleNavigation(e, "committed");
     for (const e of openInteractions) maybeSettleInteraction(e);
 }
 
-function settleNavigation(e, n, t) {
+function settleNavigation(e, n, t, o) {
     if (!openNavs.has(e)) return;
     openNavs.delete(e);
     syncNavigation(e);
-    const o = e.event;
-    o.settledMs = now() - o.at;
-    o.outcome = n;
-    if (t !== undefined) o.hold = t;
+    const i = e.event;
+    i.settledMs = now() - i.at;
+    i.outcome = n;
+    if (t !== undefined) i.hold = t;
     // 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 (o.initial !== true) for (const e of folds) e.navigation?.(o);
-    records.emit("navigation", o, undefined);
-    trackGraph(o);
+        if (i.initial !== true) for (const e of folds) e.navigation?.(i);
+    records.emit("navigation", i, undefined);
+    if (o) landedGraphs.push(e); else trackGraph(e);
     // The interaction that performed it may have been waiting only on this.
-        const i = openInteractionOf(o.interaction);
-    if (i !== undefined) maybeSettleInteraction(i);
+        const s = openInteractionOf(i.interaction);
+    if (s !== undefined) maybeSettleInteraction(s);
 }
 
 const interactionStates = new WeakMap;
@@ -2515,8 +2615,8 @@ function openInteraction(e, n, t) {
 
 /** holdStart: `t` parked writes — the interactions that performed them wait for `t`. */ function markInteractionsHeld(e) {
     if (openInteractions.size === 0) return;
-    for (const n of e.nn) {
-        const t = openInteractionOf(n.ve?.origin);
+    for (const n of e.je) {
+        const t = openInteractionOf(n.ge?.origin);
         if (t !== undefined) {
             t.heldIn.add(e);
             t.held = true;
@@ -2603,7 +2703,7 @@ const engineHooks = {
             prevDeps: n || !wantsRerun() ? null : captureDeps(e),
             // Mirror recompute's own prev-value resolution: an earlier run in the
             // same flush may still be holding in _pendingValue.
-            prevValue: e.Ae !== NOT_PENDING ? e.Ae : e.pe,
+            prevValue: e.ue !== NOT_PENDING ? e.ue : e.Ie,
             // A create run inherits the interaction of whatever is building it: the
             // enclosing recompute (a parent's fn creating children) or, at the top
             // of the recompute stack, the effect callback / handler frame.
@@ -2630,7 +2730,7 @@ const engineHooks = {
         // exempt — a side-effect-only compute's work IS its effect phase, and
         // identity of `undefined` proves nothing.
                 if (t && r.causes !== null && e.i) {
-            const n = e.Ae !== NOT_PENDING ? e.Ae : e.pe;
+            const n = e.ue !== NOT_PENDING ? e.ue : e.Ie;
             if (n !== undefined && n === r.prevValue) t = false;
         }
         // Unstable-output check: memos only, non-create, plain runs with a
@@ -2638,12 +2738,12 @@ const engineHooks = {
         // 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 (r.causes !== null && t && !o && !i && !e.i) checkUnstableOutput(e, r.prevValue, e.Ae !== NOT_PENDING ? e.Ae : e.pe);
+                if (r.causes !== null && t && !o && !i && !e.i) checkUnstableOutput(e, r.prevValue, e.ue !== NOT_PENDING ? e.ue : e.Ie);
         // 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 (!t && (e.Ae !== NOT_PENDING ? e.Ae : e.pe) === undefined) t = true;
+                if (!t && (e.ue !== NOT_PENDING ? e.ue : e.Ie) === undefined) t = true;
         if (r.causes !== null) recordRerun(e, r, {
             selfMs: c,
             totalMs: a
@@ -2655,7 +2755,7 @@ const engineHooks = {
             noteInteractionRun(r.interaction, c, true);
             // The first effect callback runs with no re-run record to inherit from;
             // hand it the interaction that built the node (see effectRunStart).
-                        e.xe = r.interaction;
+                        e.Me = r.interaction;
             if (openFlush !== null) noteFlushRun(openFlush, true, r.interaction);
             if (records.observed("create")) {
                 const n = {
@@ -2685,9 +2785,9 @@ const engineHooks = {
         trackFlightStart(e, n);
     },
     asyncStart(e) {
-        asyncStartSeq = e.ve?.seq ?? 0;
-        asyncStartTime = e.Ne;
-        asyncStartValue = e.pe;
+        asyncStartSeq = e.ge?.seq ?? 0;
+        asyncStartTime = e.ie;
+        asyncStartValue = e.Ie;
     },
     asyncEnd(e, n, t, o) {
         if (o) {
@@ -2697,7 +2797,7 @@ const engineHooks = {
             // (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 o = e.pe !== asyncStartValue || e.Ne !== asyncStartTime || e.Ae === t;
+            const o = e.Ie !== asyncStartValue || e.ie !== asyncStartTime || e.ue === t;
             if (o) stampWrite(e, "async", n === undefined ? NO_VALUES : n, t);
             // Flight over either way — an equality-swallowed landing still spent
             // the wall time (finalizeFlight only chains through a fresh stamp).
@@ -2707,12 +2807,12 @@ const engineHooks = {
         // 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 i = e.ve;
+                const i = e.ge;
         if (i !== undefined && i.seq > asyncStartSeq && i.kind === "write") stampWrite(e, "async", NO_VALUES, t);
         finalizeFlight(e);
     },
     effectRunStart(e) {
-        pushFrame("effect", nodeName(e), e.xe, e);
+        pushFrame("effect", nodeName(e), e.Me, e);
         // The frame's own `at` doubles as the record's start: set only while
         // listened, so a listener arriving mid-callback finds no start and the
         // end emits nothing for it — and an unlistened callback pays no clock read.
@@ -2816,8 +2916,10 @@ const holds = [];
     stagedFallbacks.delete(DRAIN);
     trackingGen++;
     openNavs.clear();
+    landedGraphs.length = 0;
     openInteractions.clear();
     routeCounts.clear();
+    visitRoute = undefined;
     drainSeq = 0;
     originFrames.length = 0;
     effectStack.length = 0;
@@ -2965,11 +3067,10 @@ const attribution = {
         // The buffers are typed by their variable; the switch is the proof.
                 return n;
     },
-    markFlight(e, n = now()) {
-        // Earliest wins: re-marking (a cache re-serving the same promise) must
-        // not move the origin later.
-        const t = flightOrigins.get(e);
-        if (t === undefined || n < t) flightOrigins.set(e, n);
+    markFlight(e, n) {
+        // Earliest wins (the slot's rule): re-marking (a cache re-serving the
+        // same promise) must not move the origin later.
+        OBSERVE.attribution.markFlight(e, n);
     }
 };