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

package/dist/observe/core/attribution.js

@@ -17,7 +17,7 @@ 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.i & CONFIG_PLUMBING) !== 0) return true;
+    if ((e.l & CONFIG_PLUMBING) !== 0) return true;
     if (!anyExcluded()) return false;
     const n = e;
     if (n.he === undefined) n.he = isExcluded(e);
@@ -121,7 +121,7 @@ function nodeName(e) {
 }
 
 /** The record vocabulary for a computation's kind: effects carry a `_type`, memos do not. */ function nodeKind(e) {
-    return e.u ? "effect" : "memo";
+    return e.i ? "effect" : "memo";
 }
 
 /**
@@ -327,7 +327,7 @@ const effectFrames = new WeakMap;
     const n = effectStack[effectStack.length - 1];
     if (n !== undefined) effectFrames.set(e, {
         node: n,
-        causes: n.me
+        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.ge !== undefined) i.run = e.ge;
+        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.o) {
+    for (let n = e.o; n !== null; n = n.t) {
         o++;
-        if (!(n.l.i & 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.we;
-    e.we = 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.we = {
+    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.ve ?? 0;
+    const n = e.we ?? 0;
     const t = [];
-    const o = e.we;
+    const o = e.ge;
     if (o !== undefined && o.seq > n && o.kind === "refresh") t.push(o);
-    for (let o = e.G; o !== null; o = o._) {
-        const e = o.I.we;
+    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.ve = 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.G; t !== null; t = t._) {
-        n.push(t.I);
-        if (t === e.p) 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.G; n !== null; n = n._) {
+    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.i & 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.p) break;
+        if (n === e._) break;
  // the validated prefix, as captureDeps
         }
     const i = e;
-    if (t < n || t < (i.ke ?? 0) * 1.5) return;
-    i.ke = 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.ye === undefined || i - o.ye > t.windowMs) {
-        o.ye = i;
-        o.$e = 0;
-        o.be = false;
-    }
-    o.$e = (o.$e ?? 0) + 1;
-    if (o.be || o.$e < t.count) return;
-    o.be = 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.$e;
+    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.$e} times ` + `in ${Math.max(1, i - o.ye)}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.$e,
+                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.Fe === undefined || s - i.Fe > o.windowMs) {
-        i.Fe = s;
-        i.Le = 0;
-        i.Ce = false;
-    }
-    i.Le = (i.Le ?? 0) + n;
-    if (i.Ce || i.Le < o.budgetMs) return;
-    i.Ce = 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.Le.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.Le,
+            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.Me === undefined || n - a.Me > r.windowMs) {
-        a.Me = n;
-        a.He = 0;
-        a.We = 0;
-        a.Ge = 0;
-        a.Ue = false;
-    }
-    a.He = a.He + 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.We = a.We + 1;
-        a.Ge = a.Ge + i;
+        a.Re = a.Re + 1;
+        a.Le = a.Le + i;
     }
-    if (a.Ue || a.He < r.minRuns || a.We / a.He < r.ratio || a.Ge < r.budgetMs) return;
-    a.Ue = 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.He,
-        wasted: a.We,
-        wastedMs: a.Ge
+        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.me;
+    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.qe = d;
-        a.ge = undefined;
-        a.me = 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.Be = (a.Be ?? 0) + 1;
-    a.qe = d;
-    a.ge = f;
-    a.me = 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.xe = 0;
-        i.Ke = false;
+        i.He = 0;
+        i.We = false;
         return;
     }
-    i.xe = (i.xe ?? 0) + 1;
-    if (i.Ke || i.xe < o) return;
-    i.Ke = 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.xe} 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.xe,
+            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.Ve = o.Ve === undefined || o.Ve === r ? r : null;
-    if (s !== undefined && t !== undefined && t === s.node.Ae) {
+    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.je = o.Ye === r ? (o.je ?? 0) + 1 : 1;
-        o.Ye = r;
-        if (o.je >= 2 && o.Ve === r) checkCopyEffect(s.node, e);
-    } else o.je = 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.G; n !== null; n = n._) if (n.I.Ae === e.Ae) 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.Ve === 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
@@ -1164,9 +1170,9 @@ function checkCopyEffect(e, n) {
         copyReported.add(f);
     }
     if (h === "warn") c.warned = true;
-    const p = e.u ? "effect" : "memo";
+    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.ze ?? 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.we;
+    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.Xe ?? 0) >= i) return;
-    r.Xe = 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.i & (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.Qe?.(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,9 +1532,9 @@ 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.o) {
-            const e = n.l;
-            if (e.u) return e;
+        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);
                 o.push(e);
@@ -1553,11 +1557,11 @@ 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.o) {
-            const s = t.l;
-            if (s.i & CONFIG_VERDICT) {
-                const t = s.Ze ?? 0;
-                const o = s.u ? s : reachesEffect(s, i);
+        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.Je) {
-        if (typeof n.ee === "function" || isCompanion(n)) continue;
-        const e = n.we;
+    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.Je, ...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.en;
+        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
@@ -1847,8 +1851,7 @@ function checkLongHold(e, n) {
 // --- 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;
 
 /**
@@ -1856,6 +1859,12 @@ function checkLongHold(e, n) {
  * 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
@@ -1876,7 +1885,7 @@ function checkLongHold(e, n) {
  * 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(e, n) {
     const t = liveRootOwners();
@@ -1900,35 +1909,35 @@ function checkLongHold(e, n) {
     const meet = e => {
         if (i.has(e)) return;
         i.add(e);
-        count(e, typeof e.ee === "function" ? "computations" : "signals");
+        count(e, typeof e.X === "function" ? "computations" : "signals");
         s.push(e);
     };
     for (const e of t) {
         count(e, "roots");
         count(e, "owners");
         // Iterative: a deep tree must not grow the call stack.
-                let n = e.nn;
+                let n = e.ze;
         for (;;) {
             while (n !== null) {
                 count(n, "owners");
-                if (typeof n.ee === "function") meet(n);
-                if (n.nn !== null) r.push(n);
-                n = n.tn;
+                if (typeof n.X === "function") meet(n);
+                if (n.ze !== null) r.push(n);
+                n = n.Xe;
             }
             const e = r.pop();
             if (e === undefined) break;
-            n = e.nn;
+            n = e.ze;
         }
     }
     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 = i.t; e !== null; e = e.o) meet(e.l);
-        if (typeof i.ee === "function") for (let t = i.G; t !== null; t = t._) {
+                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.I);
-            if (n !== undefined && e.has(i) && e.has(t.I)) n.edges++;
+            meet(t.S);
+            if (n !== undefined && e.has(i) && e.has(t.S)) n.edges++;
         }
     }
     return o;
@@ -1936,11 +1945,11 @@ function checkLongHold(e, n) {
 
 /**
  * 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 e = new WeakSet;
-    walkGraph(e);
-    return e;
+    walkGraph(opened);
+    return opened;
 }
 
 /**
@@ -1954,10 +1963,19 @@ function checkLongHold(e, n) {
  *
  * 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(e) {
@@ -2022,7 +2040,7 @@ function trackGraph(e) {
     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.`;
+    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,
@@ -2265,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.Je) {
-        const e = n.we?.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;
@@ -2275,8 +2293,8 @@ 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.Je) {
-        const e = t.we?.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;
@@ -2597,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.Je) {
-        const t = openInteractionOf(n.we?.origin);
+    for (const n of e.je) {
+        const t = openInteractionOf(n.ge?.origin);
         if (t !== undefined) {
             t.heldIn.add(e);
             t.held = true;
@@ -2685,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.Oe !== NOT_PENDING ? e.Oe : e.Ae,
+            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.
@@ -2711,8 +2729,8 @@ const engineHooks = {
         // committed compute output is an unchanged run. `undefined` outputs are
         // exempt — a side-effect-only compute's work IS its effect phase, and
         // identity of `undefined` proves nothing.
-                if (t && r.causes !== null && e.u) {
-            const n = e.Oe !== NOT_PENDING ? e.Oe : e.Ae;
+                if (t && r.causes !== null && e.i) {
+            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
@@ -2720,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.u) checkUnstableOutput(e, r.prevValue, e.Oe !== NOT_PENDING ? e.Oe : e.Ae);
+                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.Oe !== NOT_PENDING ? e.Oe : e.Ae) === 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
@@ -2737,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.qe = r.interaction;
+                        e.Me = r.interaction;
             if (openFlush !== null) noteFlushRun(openFlush, true, r.interaction);
             if (records.observed("create")) {
                 const n = {
@@ -2767,9 +2785,9 @@ const engineHooks = {
         trackFlightStart(e, n);
     },
     asyncStart(e) {
-        asyncStartSeq = e.we?.seq ?? 0;
-        asyncStartTime = e.Ie;
-        asyncStartValue = e.Ae;
+        asyncStartSeq = e.ge?.seq ?? 0;
+        asyncStartTime = e.ie;
+        asyncStartValue = e.Ie;
     },
     asyncEnd(e, n, t, o) {
         if (o) {
@@ -2779,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.Ae !== asyncStartValue || e.Ie !== asyncStartTime || e.Oe === 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).
@@ -2789,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.we;
+                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.qe, 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.
@@ -3049,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);
     }
 };