@solidjs/signals 2.0.0-rc.7 → 2.0.0-rc.8

package/dist/prod/core/optimistic.js

@@ -1,6 +1,6 @@
-import { NOT_PENDING, unwrapOverride, STATUS_UNINITIALIZED, REACTIVE_DIRTY, REACTIVE_CHECK, CONFIG_HAS_LANE, OVERRIDE_UNDEFINED, STATUS_PENDING, EFFECT_RENDER, REACTIVE_MANUAL_WRITE, REACTIVE_OPTIMISTIC_DIRTY, EFFECT_USER } from "./constants.js";
+import { NOT_PENDING, unwrapOverride, STATUS_UNINITIALIZED, REACTIVE_DIRTY, REACTIVE_CHECK, CONFIG_HAS_LANE, OVERRIDE_UNDEFINED, STATUS_PENDING, CONFIG_OVERRIDE_SUPERSEDED, EFFECT_RENDER, CONFIG_AUTHORITATIVE_OBSERVED, REACTIVE_MANUAL_WRITE, REACTIVE_OPTIMISTIC_DIRTY, LANE_RUN, EFFECT_USER } from "./constants.js";
 
-import { ext, latestReadActive, currentOptimisticLane, stale } from "./core.js";
+import { ext, stale, latestReadActive, currentOptimisticLane } from "./core.js";
 
 import { NotReadyError } from "./error.js";
 
@@ -8,7 +8,7 @@ import "./invariants.js";
 
 import { resolveTransition, getOrCreateLane, hasActiveOverride, activeLanes, signalLanes, laneHeld, findLane, resolveLane, assignOrMergeLane } from "./lanes.js";
 
-import { GlobalQueue, activeTransition, globalQueue, clock, insertSubs, schedule } from "./scheduler.js";
+import { GlobalQueue, activeTransition, globalQueue, origin, clock, insertSubs, schedule, queuePendingNode } from "./scheduler.js";
 
 /**
  * The optimistic write engine, moved out of core.ts/scheduler.ts. Everything
@@ -24,9 +24,9 @@ import { GlobalQueue, activeTransition, globalQueue, clock, insertSubs, schedule
  * once the gate holds — the same late-binding contract as verdict.ts.
  */
 /** The optimistic half of setSignal, fired when `_overrideValue !== undefined`. */ function optimisticWrite(e, n) {
-    const t = e.o?.Pe !== NOT_PENDING;
-    const i = t ? unwrapOverride(e.o?.Pe) : e.be;
-    if (typeof n === "function") n = n(i);
+    const i = e.o?.be !== NOT_PENDING;
+    const t = i ? unwrapOverride(e.o?.be) : e.me;
+    if (typeof n === "function") n = n(t);
     const u = !!(e.S & STATUS_UNINITIALIZED) || 
     // A dirty node's _value is stale (its queued recompute hasn't run — e.g.
     // a latest() shadow marked by the previous landing's companion snap), so
@@ -34,36 +34,47 @@ import { GlobalQueue, activeTransition, globalQueue, clock, insertSubs, schedule
     // push returning the shadow to that stale value was dropped, the snap
     // recompute then committed the parent's old value, and the banner showed
     // the previous transition's target (#3041 follow-up).
-    !!((e.ie ?? 0) & (REACTIVE_DIRTY | REACTIVE_CHECK)) || !e.pe || !e.pe(i, n);
+    !!((e.ie ?? 0) & (REACTIVE_DIRTY | REACTIVE_CHECK)) || !e.ve || !e.ve(t, n);
     if (!u) {
         // Same-value write with an active override still entangles the current
-        // action's transition — the hold must outlast all overlapping actions.
-        if (t) {
+        // action's transition — the hold must outlast all overlapping actions —
+        // and renews the override's PROVENANCE: the newer action re-asks the
+        // question, so an older action's answer arriving later is stale to it
+        // too (#3331; a same-value re-prediction otherwise let the first
+        // action's slow source supersede and restart the downstream flight).
+        if (i) {
             const n = resolveTransition(e);
             if (n && activeTransition !== n) globalQueue.initTransition(n);
+            if (origin > e.o.Rt) e.o.Rt = origin;
         }
         return n;
     }
-    if (t) globalQueue.initTransition(resolveTransition(e));
+    if (i) globalQueue.initTransition(resolveTransition(e));
     // No revert target is stashed: while the override is active every reader
     // sees it (A17), so authoritative arrivals commit silently into _value and
     // reverting is just dropping the override — _value is already correct.
-     else globalQueue.m.Xe.push(e);
+     else globalQueue.m.it.push(e);
     // Stamp ownership on the node (post-merge, so entangled writers share the
     // joint root). resolveTransition prefers this over the lane's _transition,
     // which a shared subscriber can merge across transactions (#2912).
-        ext(e).Tt = activeTransition;
+        ext(e).Ot = activeTransition;
+    ext(e).It = clock;
+    // Provenance: the action asking. An answer an OLDER action's flight brings
+    // back is a stale question and holds silently to commit (#3331).
+        ext(e).Rt = origin;
     const r = getOrCreateLane(e);
-    ext(e).$e = r;
-    e.T |= CONFIG_HAS_LANE;
+    ext(e).Oe = r;
+    // A fresh override re-masks: whatever truth is staged, this write is the
+    // value for the graph again until the source answers it (#3331).
+        e.T = (e.T | CONFIG_HAS_LANE) & ~CONFIG_OVERRIDE_SUPERSEDED;
     // Literal undefined must not land raw: the slot doubles as the optimistic
     // brand, and erasing it makes the write invisible and routes follow-up
     // writes off the optimistic path into permanent commits (#2898).
-        ext(e).Pe = n === undefined ? OVERRIDE_UNDEFINED : n;
+        ext(e).be = n === undefined ? OVERRIDE_UNDEFINED : n;
     // syncCompanions only pokes _pendingSignal/_latestValueComputed — with
     // neither companion present the call is a guaranteed no-op.
-        (e.o?.ye !== undefined || e.o?.Ce !== undefined) && GlobalQueue.Ue !== null && GlobalQueue.Ue(e, n);
-    if (e.oe !== undefined) e.Te = clock;
+        (e.o?.Le !== undefined || e.o?.Qe !== undefined) && GlobalQueue.pe !== null && GlobalQueue.pe(e, n);
+    if (e.oe !== undefined) e._e = clock;
  // §12e: computed-only slot
         insertSubs(e, true);
     schedule();
@@ -75,9 +86,9 @@ import { GlobalQueue, activeTransition, globalQueue, clock, insertSubs, schedule
  * while one of its optimistic nodes holds an active override that is still
  * pending on real (non-affects-sentinel) async.
  */ function transitionBlocked(e) {
-    for (let n = 0; n < e.Xe.length; n++) {
-        const t = e.Xe[n];
-        if (hasActiveOverride(t) && "S" in t && t.S & STATUS_PENDING && t.o?._ instanceof NotReadyError) {
+    for (let n = 0; n < e.it.length; n++) {
+        const i = e.it[n];
+        if (hasActiveOverride(i) && "S" in i && i.S & STATUS_PENDING && i.o?._ instanceof NotReadyError) {
             return true;
         }
     }
@@ -89,33 +100,134 @@ function resolveOptimisticNodes(e) {
     // notifications) may push fresh optimistic nodes; only this batch settles
     // now, so iterate a fixed window and splice it out at the end.
     const n = e.length;
-    for (let t = 0; t < n; t++) {
-        const n = e[t];
-        if (n.o !== null) n.o.$e = undefined;
+    for (let i = 0; i < n; i++) {
+        const n = e[i];
+        if (n.o !== null) n.o.Oe = undefined;
         // Revert is a pure drop: there is no revert target to commit —
         // override-covered authoritative values hold in _pendingValue and
         // elevate on their OWN transition's schedule (A18 as re-ruled 2026-07-07).
                 if (!(n.S & STATUS_PENDING)) n.S &= ~STATUS_UNINITIALIZED;
-        const i = n.o?.Pe;
-        ext(n).Pe = NOT_PENDING;
-        if (i !== NOT_PENDING && n.be !== unwrapOverride(i)) insertSubs(n, true);
-        n.Ae = null;
-        if (n.o !== null) n.o.Tt = null;
+        const t = n.o?.be;
+        ext(n).be = NOT_PENDING;
+        // A superseded override's subscribers already re-derived from the truth
+        // when it arrived (#3331) — the drop changes nothing they read. Everyone
+        // else learns of the correction here: this drop IS their notification.
+                const u = (n.T & CONFIG_OVERRIDE_SUPERSEDED) !== 0;
+        n.T &= ~CONFIG_OVERRIDE_SUPERSEDED;
+        if (!u && t !== NOT_PENDING && n.me !== unwrapOverride(t)) insertSubs(n, true);
+        n.ge = null;
+        if (n.o !== null) n.o.Ot = null;
     }
     // Settlement checkpoint (#2838): companions caught in this batch (or owned
     // by a node in it) re-derive from committed state, so verdicts survive the
     // transition that produced them (A19 — pending is a property of the data).
-        for (let t = 0; t < n; t++) {
-        const n = e[t];
-        if (n.o?.ye || n.o?.Ce) GlobalQueue.un(n);
-        const i = n.o?.St;
-        if (i && (i.o?.ye === n || i.o?.Ce === n)) GlobalQueue.un(i);
+        for (let i = 0; i < n; i++) {
+        const n = e[i];
+        if (n.o?.Le || n.o?.Qe) GlobalQueue.un(n);
+        const t = n.o?.Gt;
+        if (t && (t.o?.Le === n || t.o?.Qe === n)) GlobalQueue.un(t);
     }
     e.splice(0, n);
 }
 
+/**
+ * A18 supersession (#3331): the node's own source arrived with a value that
+ * differs from its active override. "Knowing otherwise" ends the optimism for
+ * the graph at once: the override stays only as the DISPLAYED value (untracked
+ * reads, the applied frame) until the owning transaction commits, while
+ * tracked readers see the staged truth and re-derive from it as that
+ * transaction's held work — so async downstream restarts now, not at the
+ * revert (no waterfall).
+ *
+ * The lane's job for this node is over: a lane applies an optimistic view
+ * ahead of its transaction, and there is no optimistic view left — the
+ * corrected cascade is plain transaction-held work (staged memos, effect runs
+ * in the stashable queues). Demote the node and every cascade member that
+ * rides this lane; the caller then notifies on the plain channel. Runners the
+ * lane still holds for demoted effects (the optimistic frame that never got to
+ * apply) defer to the regular queue in runEffect. In a lane merged with a
+ * still-optimistic source, members shared with that source lose their lane
+ * too and simply wait for the transaction — less optimistic, never torn.
+ *
+ * A later arrival EQUAL to the override (an earlier action's answer superseded
+ * this one's; now this one's answer confirms it) ends the supersession: the
+ * graph re-derives from the override, which is the truth again. Notifies the
+ * subscribers in both cases. A plain matching confirmation (no supersession
+ * in force) is A17-silent for ordinary subscribers and wakes only an
+ * authoritative-view reader (until()'s predicate, refresh()'s waiter) that
+ * observed this node past its override — "authoritative arrival equal to the
+ * override" is exactly the acknowledgment it waits for (#3164, #3303). The
+ * wake hook is installed by the setters of that bit; optional here because
+ * the bit only implies the optimistic engine was consulted.
+ */ function supersedeOverride(e, n) {
+    const i = !e.ve || !e.ve(n, unwrapOverride(e.o.be));
+    if (!i) {
+        if (!(e.T & CONFIG_OVERRIDE_SUPERSEDED)) {
+            if (e.T & CONFIG_AUTHORITATIVE_OBSERVED) GlobalQueue.Qt?.(e);
+            return;
+        }
+        e.T &= ~CONFIG_OVERRIDE_SUPERSEDED;
+    } else {
+        // Provenance (#3331): an answer brought back by an OLDER action than the
+        // one that wrote this override answers a question the user has since
+        // changed. It is staged like any other landing and reveals if it is
+        // still the truth when the transaction commits, but it does not move the
+        // graph now — a slow source must not leak back in over a newer intent.
+        // 0 is mainline (no action): always the current question.
+        if (origin && origin < e.o.Rt) return;
+        e.T |= CONFIG_OVERRIDE_SUPERSEDED;
+        const n = e.o?.Oe;
+        if (n) {
+            const i = findLane(n);
+            const t = [ e ];
+            while (t.length) {
+                const e = t.pop();
+                const n = e.o?.Oe;
+                if (!n || findLane(n) !== i) continue;
+                e.o.Oe = undefined;
+                i.he.delete(e);
+                for (let n = e.u; n !== null; n = n.Te) t.push(n.Ie);
+            }
+        }
+    }
+    insertSubs(e);
+}
+
+/** read()'s value for a tracked reader of a superseded node: the truth —
+ * staged, or already committed (a mainline landing commits at the head of
+ * its flush, ahead of the heap run, and the override drops only at the
+ * batch's end; in between the graph must not fall back to the override it
+ * has left) — or the displayed override for a stale (render) reader of some
+ * OTHER transaction, the same visibility a foreign transaction's staged
+ * write has. */ function supersededRead(e) {
+    if (stale && e.ge && activeTransition !== e.ge) return unwrapOverride(e.o?.be);
+    return e.Ge !== NOT_PENDING ? e.Ge : e.me;
+}
+
+/**
+ * An authoritative store landing on an override-covered node — a derived
+ * optimistic store's own truth arriving over a tentative edit through the
+ * projection-write channel (setSignal under projectionWriteActive). The
+ * store twin of asyncWrite's override branch: the truth stages for its
+ * transaction's commit whatever its relation to the committed value (a
+ * landing equal to committed still differs from the override), companions
+ * learn of it, and supersedeOverride decides the rest — A18 supersession with
+ * action provenance, or an A17-silent confirmation (#3331). Before this the
+ * landing took setSignal's plain path: a differing truth staged silently
+ * under the override and the graph never moved until the commit.
+ */ function landOnOverride(e, n) {
+    const i = e.Ge === NOT_PENDING ? e.me : e.Ge;
+    if (typeof n === "function") n = n(i);
+    if (e.Ge === NOT_PENDING) queuePendingNode(e);
+    e.Ge = n;
+    GlobalQueue.pe?.(e, n);
+    supersedeOverride(e, n);
+    schedule();
+    return n;
+}
+
 function runQueue(e, n) {
-    for (let t = 0; t < e.length; t++) e[t](n);
+    for (let i = 0; i < e.length; i++) e[i](n | LANE_RUN);
 }
 
 /**
@@ -124,10 +236,10 @@ function runQueue(e, n) {
  */ function runLaneEffects(e) {
     for (const n of activeLanes) {
         if (n.rn || laneHeld(n)) continue;
-        const t = n.tn[e - 1];
-        if (t.length) {
+        const i = n.tn[e - 1];
+        if (i.length) {
             n.tn[e - 1] = [];
-            runQueue(t, e);
+            runQueue(i, e);
         }
     }
     // Optimistic patch applications ride the same visibility slot as lane
@@ -137,14 +249,14 @@ function runQueue(e, n) {
 
 function cleanupCompletedLanes(e) {
     for (const n of activeLanes) {
-        const t = e ? n.Ae === e : !n.Ae;
-        if (!t) continue;
+        const i = e ? n.ge === e : !n.ge;
+        if (!i) continue;
         if (!n.rn) {
             if (n.tn[0].length) runQueue(n.tn[0], EFFECT_RENDER);
             if (n.tn[1].length) runQueue(n.tn[1], EFFECT_USER);
         }
-        if (n.nn.o?.$e === n) if (n.nn.o !== null) n.nn.o.$e = undefined;
-        n.Oe.clear();
+        if (n.nn.o?.Oe === n) if (n.nn.o !== null) n.nn.o.Oe = undefined;
+        n.he.clear();
         n.tn[0].length = 0;
         n.tn[1].length = 0;
         activeLanes.delete(n);
@@ -164,28 +276,40 @@ function cleanupCompletedLanes(e) {
     // Per-lane suspension: only throw if in same lane as pending async
     // AND the node doesn't have an active override (overrides are the visible value,
     // downstream in the lane should read the override, not throw)
-        const n = e.o?.$e;
+        const n = e.o?.Oe;
     if (!n) return false;
     return findLane(n) === findLane(currentOptimisticLane) && !hasActiveOverride(e);
 }
 
+/**
+ * read()'s reveal carve-out asks whether a pending node is routed through a
+ * LIVE lane: a lane-derived flight's inputs are already revealed through the
+ * lane (the override, or latest()'s fresh value), so a stale reader of another
+ * transaction must hold on the flight rather than show the node's committed
+ * value beside them (#3334). Exact, not sticky: `resolveLane` clears a lane
+ * reference the engine has since retired, so a node that was once lane-routed
+ * and is now pending under a plain hold is judged by that hold alone.
+ */ function laneLive(e) {
+    return resolveLane(e) !== undefined;
+}
+
 /**
  * read()'s entanglement gate: a reader recomputing under an optimistic lane
  * that reads a pending mid-transition write sees the committed value; the sub
  * is recorded for replay at commit.
- */ function gatedRead(e, n, t) {
-    if (latestReadActive || e.Re === NOT_PENDING || e.oe || n !== e && !(n.ie & REACTIVE_MANUAL_WRITE)) {
+ */ function gatedRead(e, n, i) {
+    if (latestReadActive || e.Ge === NOT_PENDING || e.oe || n !== e && !(n.ie & REACTIVE_MANUAL_WRITE)) {
         return false;
     }
-    activeTransition.cn.add(t);
+    activeTransition.lt.add(i);
     return true;
 }
 
 /**
  * read()'s value selection under a lane: return the committed `_value` for
  * optimistic/lane-assigned signals, stale-mode reads, and pending owners.
- */ function laneReadsCommitted(e, n, t) {
-    if (e.o?.Pe !== undefined || !!e.o?.$e || !!(n.S & STATUS_PENDING)) {
+ */ function laneReadsCommitted(e, n, i) {
+    if (e.o?.be !== undefined || !!e.o?.Oe || !!(n.S & STATUS_PENDING)) {
         // The committed view hides a staged in-flight value that will promote
         // silently (commitPendingNode never re-notifies). gatedRead records plain
         // signals for replay at commit; async memos are excluded from it by the
@@ -193,11 +317,17 @@ function cleanupCompletedLanes(e) {
         // already settled (laneAsyncSettled keeps _optimisticLane) served its
         // committed value to a reader that never re-ran after the landing, so a
         // pending-gated branch stayed one value behind permanently (#3041
-        // follow-up). Record the reader under the same replay contract.
-        if (e.Re !== NOT_PENDING) (activeTransition ?? globalQueue.m).cn.add(t);
+        // follow-up). Record the reader under the same replay contract — when
+        // the commit will actually change what it read: a staged value equal to
+        // the committed one (a lane recompute already published it, INV-11)
+        // promotes to the same view, and a replay would only re-run effects
+        // against an unchanged frame (#3330). An override-covered node's revert
+        // notifies its own subscribers when the truth differs (resolveOptimistic
+        // Nodes), so the reader is recorded only for the staged-vs-committed gap.
+        if (e.Ge !== NOT_PENDING && e.Ge !== e.me) (activeTransition ?? globalQueue.m).lt.add(i);
         return true;
     }
-    if (n === e && stale && t.o?.St !== e) {
+    if (n === e && stale && i.o?.Gt !== e) {
         // The committed view can hide a staged write (a lane member — even just
         // an isPending companion flip — puts the reader "under a lane"). The
         // staged value commits with no re-delivery (commitPendingNode never
@@ -209,7 +339,7 @@ function cleanupCompletedLanes(e) {
         // into the transaction (#3041 follow-up: a pending-gated branch that
         // first read its async source during the landing flush stayed one value
         // behind permanently); with none, into the ambient batch.
-        if (e.Re !== NOT_PENDING) (activeTransition ?? globalQueue.m).cn.add(t);
+        if (e.Ge !== NOT_PENDING) (activeTransition ?? globalQueue.m).lt.add(i);
         return true;
     }
     return false;
@@ -232,16 +362,16 @@ function cleanupCompletedLanes(e) {
         // recompute() runs plain: the value stages and commits with the flush.
         // (el's own override slot excludes companions themselves; a lane merged
         // into a real optimistic lane resolves to a non-companion source.)
-                if (!globalQueue.fn && !activeTransition && !n.Ae && n.nn.o?.St !== undefined && e.o?.Pe === undefined) {
-            if (e.o !== null) e.o.$e = undefined;
+                if (!globalQueue.sn && !activeTransition && !n.ge && n.nn.o?.Gt !== undefined && e.o?.be === undefined) {
+            if (e.o !== null) e.o.Oe = undefined;
             return false;
         }
         return n;
     }
-    for (let n = e.lt; n; n = n.ot) {
-        const t = n.st;
-        if (t.ie & REACTIVE_OPTIMISTIC_DIRTY) {
-            const n = resolveLane(t);
+    for (let n = e.fe; n; n = n.ae) {
+        const i = n.Se;
+        if (i.ie & REACTIVE_OPTIMISTIC_DIRTY) {
+            const n = resolveLane(i);
             if (n) {
                 e.ie |= REACTIVE_OPTIMISTIC_DIRTY;
                 assignOrMergeLane(e, n);
@@ -258,8 +388,8 @@ function cleanupCompletedLanes(e) {
  * the source's own write/commit/settlement paths keep it current. */ function laneAsyncPending(e) {
     const n = findLane(currentOptimisticLane);
     if (n.nn !== e) {
-        n.Oe.add(e);
-        ext(e).$e = n;
+        n.he.add(e);
+        ext(e).Oe = n;
         e.T |= CONFIG_HAS_LANE;
     }
 }
@@ -267,7 +397,7 @@ function cleanupCompletedLanes(e) {
 /** recompute()'s success path: the node's async settled, clear it from its lane. */ function laneAsyncSettled(e) {
     const n = resolveLane(e);
     if (n) {
-        n.Oe.delete(e);
+        n.he.delete(e);
     }
 }
 
@@ -282,19 +412,23 @@ function trackOptimisticStore(e) {
  * create optimistic state (verdict.ts at module top level, createOptimistic
  * and createOptimisticStore at first call) BEFORE any optimistic node exists.
  */ function installOptimisticEngine() {
-    if (GlobalQueue.yt !== null) return;
-    GlobalQueue.yt = optimisticWrite;
-    GlobalQueue.Tn = resolveOptimisticNodes;
-    GlobalQueue.dn = transitionBlocked;
-    GlobalQueue.In = cleanupCompletedLanes;
-    GlobalQueue.Nn = runLaneEffects;
-    GlobalQueue.Ut = gatedRead;
-    GlobalQueue.kt = laneSuspends;
-    GlobalQueue.xt = laneReadsCommitted;
-    GlobalQueue.Je = recomputeLane;
-    GlobalQueue.tt = laneAsyncPending;
-    GlobalQueue.et = laneAsyncSettled;
-    GlobalQueue._n = trackOptimisticStore;
+    if (GlobalQueue.Bt !== null) return;
+    GlobalQueue.Bt = optimisticWrite;
+    GlobalQueue.fn = resolveOptimisticNodes;
+    GlobalQueue.cn = transitionBlocked;
+    GlobalQueue.dn = cleanupCompletedLanes;
+    GlobalQueue.In = runLaneEffects;
+    GlobalQueue.ye = supersedeOverride;
+    GlobalQueue.Yt = supersededRead;
+    GlobalQueue.zt = landOnOverride;
+    GlobalQueue.Zt = gatedRead;
+    GlobalQueue.qt = laneSuspends;
+    GlobalQueue.Mt = laneLive;
+    GlobalQueue.Kt = laneReadsCommitted;
+    GlobalQueue.nt = recomputeLane;
+    GlobalQueue.ot = laneAsyncPending;
+    GlobalQueue.ut = laneAsyncSettled;
+    GlobalQueue.Nn = trackOptimisticStore;
 }
 
 export { installOptimisticEngine };

package/dist/prod/core/owner.js

@@ -12,7 +12,7 @@ const PENDING_OWNER = {};
 
  // Dummy owner to trigger store's read() path
 function markDisposal(e) {
-    let t = e.Qe;
+    let t = e.Ye;
     while (t) {
         const e = t.ie;
         t.ie = e | REACTIVE_ZOMBIE;
@@ -26,7 +26,7 @@ function markDisposal(e) {
             if (e & REACTIVE_IN_HEAP) insertIntoHeap(t, zombieQueue); else insertIntoHeapHeight(t, zombieQueue);
         }
         markDisposal(t);
-        t = t.We;
+        t = t.Ze;
     }
 }
 
@@ -52,12 +52,12 @@ function disposeChildren(e, t = false, n) {
         // edge). Snap runs after the DISPOSED flag is set so the oracle reads
         // false, and notifies subscribers still watching the companion.
                 const t = e;
-        if (t.o?.ye || t.o?.Ce) GlobalQueue.un(t);
+        if (t.o?.Le || t.o?.Qe) GlobalQueue.un(t);
     }
-    if (t && e.oe && e.o !== null) e.o.Ie = null;
-    let o = n ? e.o?.Ke ?? null : e.Qe;
+    if (t && e.oe && e.o !== null) e.o.Pe = null;
+    let o = n ? e.o?.Xe ?? null : e.Ye;
     while (o) {
-        const e = o.We;
+        const e = o.Ze;
         const t = o;
         // Owner teardown is death regardless of the child's own lifecycle
         // (#3024): strip AUTO_DISPOSE so a post-disposal read freezes at the
@@ -80,34 +80,34 @@ function disposeChildren(e, t = false, n) {
         o = e;
     }
     if (n) {
-        if (e.o !== null) e.o.Ke = null;
+        if (e.o !== null) e.o.Xe = null;
     } else {
-        e.Qe = null;
-        e.je = 0;
+        e.Ye = null;
+        e.$e = 0;
     }
     // O(1) splice out of parent's chain on individual dispose. Skipped during
     // batch dispose (parent already disposed) and zombie disposal (node sits on
     // parent's _pendingFirstChild). We leave node._nextSibling intact so outer
     // walks that already advanced past us still reach later siblings.
-        if (t && !n && !(i & REACTIVE_ZOMBIE) && e.Le !== null && !(e.Le.ie & REACTIVE_DISPOSED)) {
-        const t = e.It;
-        const n = e.We;
-        if (t !== null) t.We = n; else e.Le.Qe = n;
-        if (n !== null) n.It = t;
-        e.It = null;
+        if (t && !n && !(i & REACTIVE_ZOMBIE) && e.qe !== null && !(e.qe.ie & REACTIVE_DISPOSED)) {
+        const t = e.St;
+        const n = e.Ze;
+        if (t !== null) t.Ze = n; else e.qe.Ye = n;
+        if (n !== null) n.St = t;
+        e.St = null;
     }
     runDisposal(e, n);
     // Final effect-returned cleanup fires at true disposal, after `_disposal`
     // to mirror rerun ordering (compute-phase teardown first, cleanup last).
-        if (t && e.Gt) {
-        const t = e.Gt;
-        e.Gt = undefined;
+        if (t && e.Ht) {
+        const t = e.Ht;
+        e.Ht = undefined;
         t();
     }
 }
 
 function runDisposal(e, t) {
-    let n = t ? e.o?.Ze : e.Ge;
+    let n = t ? e.o?.Je : e.we;
     if (!n) return;
     if (Array.isArray(n)) {
         for (let e = 0; e < n.length; e++) {
@@ -118,14 +118,14 @@ function runDisposal(e, t) {
         n.call(n);
     }
     if (t) {
-        if (e.o !== null) e.o.Ze = null;
-    } else e.Ge = null;
+        if (e.o !== null) e.o.Je = null;
+    } else e.we = null;
 }
 
 function childId(e, t) {
     let n = e;
-    while (n.T & CONFIG_TRANSPARENT && n.Le) n = n.Le;
-    if (n.id != null) return formatId(n.id, t ? n.je++ : n.je);
+    while (n.T & CONFIG_TRANSPARENT && n.qe) n = n.qe;
+    if (n.id != null) return formatId(n.id, t ? n.$e++ : n.$e);
     throw new Error("");
 }
 
@@ -206,7 +206,7 @@ function formatId(e, t) {
  * checks. `cleanup()` is the unchecked primitive used by internals.
  */ function cleanup(e) {
     if (!context) return e;
-    if (!context.Ge) context.Ge = e; else if (Array.isArray(context.Ge)) context.Ge.push(e); else context.Ge = [ context.Ge, e ];
+    if (!context.we) context.we = e; else if (Array.isArray(context.we)) context.we.push(e); else context.we = [ context.we, e ];
     return e;
 }
 
@@ -243,30 +243,34 @@ function disposeRootSelf(e = true) {
  */ function createOwner(e) {
     const t = context;
     const n = e?.transparent ?? false;
-    const i = {
+    // Prod and observe boilerplates (see core.ts computed()). The observe
+    // literal carries the `_name` slot the rendering layer fills with the
+    // component label (`owner._name = "<App>"`) — a slot, so labelling a root
+    // is a plain store rather than a shape fork between labelled and plain roots.
+        const i = {
         id: inheritId(e, n, t),
         T: n ? CONFIG_TRANSPARENT : 0,
-        Dt: true,
-        Pt: t?.Dt ? t.Pt : t,
-        Qe: null,
-        We: null,
-        It: null,
-        Ge: null,
+        gt: true,
+        bt: t?.gt ? t.bt : t,
+        Ye: null,
+        Ze: null,
+        St: null,
+        we: null,
         C: t?.C ?? globalQueue,
-        we: t?.we || defaultContext,
-        je: 0,
+        xe: t?.xe || defaultContext,
+        $e: 0,
         o: null,
-        Le: t,
+        qe: t,
         dispose: disposeRootSelf
     };
     if (t) {
-        const e = t.Qe;
+        const e = t.Ye;
         if (e === null) {
-            t.Qe = i;
+            t.Ye = i;
         } else {
-            i.We = e;
-            e.It = i;
-            t.Qe = i;
+            i.Ze = e;
+            e.St = i;
+            t.Ye = i;
         }
     }
     return i;