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

package/dist/prod/core/effect.js

@@ -1,4 +1,4 @@
-import { REACTIVE_DISPOSED, STATUS_ERROR, EFFECT_USER, CONFIG_AUTO_DISPOSE, CONFIG_CHILDREN_FORBIDDEN, EFFECT_TRACKED, EFFECT_RENDER, STATUS_PENDING } from "./constants.js";
+import { REACTIVE_DISPOSED, LANE_RUN, STATUS_ERROR, EFFECT_USER, CONFIG_AUTO_DISPOSE, CONFIG_CHILDREN_FORBIDDEN, EFFECT_TRACKED, EFFECT_RENDER, STATUS_PENDING } from "./constants.js";
 
 import { setEffectStatusNotify, ext, createEffectNode, recompute, computed, staleValues } from "./core.js";
 
@@ -6,26 +6,26 @@ import { unwrapStatusError, StatusError } from "./error.js";
 
 import { enqueueSub } from "./heap.js";
 
-import { GlobalQueue, haltReactivity, schedule } from "./scheduler.js";
+import { GlobalQueue, currentTransition, activeTransition, haltReactivity, schedule } from "./scheduler.js";
 
 /**
  * Effects are the leaf nodes of our reactive graph. When their sources change, they are
  * automatically added to the queue of effects to re-execute, which will cause them to fetch their
  * sources and recompute
- */ function effect(t, e, E, f) {
-    const r = !!f?.user;
-    const n = createEffectNode(t, e, E, r ? EFFECT_USER : EFFECT_RENDER, f);
-    recompute(n, true);
-    !f?.defer && (n.ge === EFFECT_USER || f?.schedule ? n.C.enqueue(n.ge, runEffect.bind(null, n)) : runEffect(n));
+ */ function effect(t, e, E, r) {
+    const n = !!r?.user;
+    const f = createEffectNode(t, e, E, n ? EFFECT_USER : EFFECT_RENDER, r);
+    recompute(f, true);
+    !r?.defer && (f.Ce === EFFECT_USER || r?.schedule ? f.C.enqueue(f.Ce, runEffect.bind(null, f)) : runEffect(f, LANE_RUN));
 }
 
 function notifyEffectStatus(t, e) {
     // Use passed values if provided, otherwise read from node
     const E = t !== undefined ? t : this.S;
-    const f = e !== undefined ? e : this.o?._;
+    const r = e !== undefined ? e : this.o?._;
     if (E & STATUS_ERROR) {
         this.C.notify(this, STATUS_PENDING, 0);
-        if (this.ge === EFFECT_USER) {
+        if (this.Ce === EFFECT_USER) {
             // The error handler is the error arm of the effect phase (#2840 ruling):
             // queue it like the effect function. It runs in the same imperative,
             // writable scope, throws escalate the same way, and a held transition
@@ -37,21 +37,41 @@ function notifyEffectStatus(t, e) {
             // re-propagates unblocked at commit.
             if (this.S & STATUS_ERROR) {
                 this.He = true;
-                this.C.enqueue(this.ge, this.it ??= runEffect.bind(null, this));
+                this.C.enqueue(this.Ce, this.rt ??= runEffect.bind(null, this));
             }
             return;
         }
         if (!this.C.notify(this, STATUS_ERROR, STATUS_ERROR)) {
-            haltReactivity(unwrapStatusError(f));
-            throw f;
+            haltReactivity(unwrapStatusError(r));
+            throw r;
         }
-    } else if (this.ge === EFFECT_RENDER) {
-        this.C.notify(this, STATUS_PENDING | STATUS_ERROR, E, f);
+    } else if (this.Ce === EFFECT_RENDER) {
+        this.C.notify(this, STATUS_PENDING | STATUS_ERROR, E, r);
     }
 }
 
-function runEffect(t) {
+function runEffect(t, e) {
     if (!t.He || t.ie & REACTIVE_DISPOSED) return;
+    // Ownership (#3319): a value computed under a transaction is applied by that
+    // transaction's commit. The ordinary effect phase runs with a transaction
+    // active only when the flush's finalize ENTERED one (every other path parks
+    // or settles first): leave a run owned by a still-held transaction queued —
+    // `_modified` stays set — and the next gate stashes it with the owner.
+    // Mainline-owned runs (null) apply now. Lanes are exempt by design (they
+    // apply their own effects ahead of their transaction — the optimistic view)
+    // and mark their runs with LANE_RUN.
+    
+    // Lane exemption has one exception (#3331): a lane runner for an effect that
+    // no longer rides a lane — its optimistic source was superseded, so the lane
+    // has no optimistic view left to apply, and the value this effect now
+    // carries (or will, once its plain recompute lands) belongs to the still-held
+    // transaction. Hand the run to the regular queue, where the transaction's
+    // gate stashes it with the owner. Lane-less runners with no live owner
+    // (reverts, wake-only lanes) apply now.
+        if (t._t !== null && !currentTransition(t._t).ft && (e & LANE_RUN ? !t.o?.Oe : activeTransition !== null)) {
+        t.C.enqueue(t.Ce, t.rt);
+        return;
+    }
     // Error arm (#2840), user effects only: a compute-phase error that is still
     // the node's settled state at effect time runs the bundle's error handler in
     // this same imperative, writable scope. Unwrap the StatusError used for
@@ -62,14 +82,14 @@ function runEffect(t) {
     // Render effects bypass: their errors route to boundaries synchronously in
     // notifyEffectStatus, and a runner queued by an earlier valueChanged in the
     // same flush must not be hijacked by a later-arriving error status.
-        if (t.S & STATUS_ERROR && t.ge === EFFECT_USER) {
+        if (t.S & STATUS_ERROR && t.Ce === EFFECT_USER) {
         const e = unwrapStatusError(t.o?._);
-        t.Ot = t.be;
+        t.Ft = t.me;
         t.He = false;
         try {
-            t.Rt ? t.Rt(e, () => {
-                const e = t.Gt;
-                t.Gt = undefined;
+            t.vt ? t.vt(e, () => {
+                const e = t.Ht;
+                t.Ht = undefined;
                 e?.();
             }) : console.error(e);
         } catch (e) {
@@ -80,14 +100,14 @@ function runEffect(t) {
         }
         return;
     }
-    const e = t.Gt;
-    t.Gt = undefined;
+    const E = t.Ht;
+    t.Ht = undefined;
     try {
-        e?.();
-        const E = t.Ct(t.be, t.Ot);
-        if (false && E !== undefined && typeof E !== "function") ;
+        E?.();
+        const e = t.ht(t.me, t.Ft);
+        if (false && e !== undefined && typeof e !== "function") ;
         // The final cleanup is invoked by disposeChildren at true disposal.
-                t.Gt = E;
+                t.Ht = e;
     } catch (e) {
         ext(t)._ = new StatusError(t, e);
         t.S |= STATUS_ERROR;
@@ -96,12 +116,12 @@ function runEffect(t) {
             throw e;
         }
     } finally {
-        t.Ot = t.be;
+        t.Ft = t.me;
         t.He = false;
     }
 }
 
-GlobalQueue.ut = runEffect;
+GlobalQueue.ct = runEffect;
 
 /**
  * Internal tracked effect - bypasses heap, goes directly to effect queue.
@@ -119,19 +139,19 @@ GlobalQueue.ut = runEffect;
         } finally {}
     };
     const E = computed(() => {
-        const e = E.Gt;
-        E.Gt = undefined;
+        const e = E.Ht;
+        E.Ht = undefined;
         e?.();
-        const f = staleValues(t);
-        E.Gt = f;
+        const r = staleValues(t);
+        E.Ht = r;
     }, {
         ...e,
         lazy: true
     });
-    E.Gt = undefined;
+    E.Ht = undefined;
     E.T = E.T & ~CONFIG_AUTO_DISPOSE | CONFIG_CHILDREN_FORBIDDEN;
     E.He = true;
-    E.ge = EFFECT_TRACKED;
+    E.Ce = EFFECT_TRACKED;
     // Status dispatch rides the SHARED notifier (statusNotifierOf keys off
     // _type): its error arm is behavior-identical to the closure that used to
     // live here, without the per-node NodeExtension allocation.

package/dist/prod/core/external.js

@@ -64,8 +64,8 @@ function externalUntrack(e) {
 // removed on reset) so core's null checks stay equivalent to the old
 // `externalSourceConfig` truthiness checks.
 function syncExternalHooks() {
-    GlobalQueue.Ft = externalSourceConfig ? wireExternalSource : null;
-    GlobalQueue.gt = externalSourceConfig ? externalUntrack : null;
+    GlobalQueue.kt = externalSourceConfig ? wireExternalSource : null;
+    GlobalQueue.Lt = externalSourceConfig ? externalUntrack : null;
 }
 
 function enableExternalSource(e) {

package/dist/prod/core/graph.js

@@ -10,17 +10,17 @@ import { bumpNotifyEpoch } from "./scheduler.js";
 
 // https://github.com/stackblitz/alien-signals/blob/v2.0.3/src/system.ts#L100
 function unlinkSubs(e) {
-    const n = e.st;
-    const l = e.ot;
-    const o = e.ae;
+    const n = e.Se;
+    const l = e.ae;
+    const o = e.Te;
     const s = e.en;
-    if (o !== null) o.en = s; else n.ft = s;
-    if (s !== null) s.ae = o; else {
+    if (o !== null) o.en = s; else n.dt = s;
+    if (s !== null) s.Te = o; else {
         n.u = o;
         if (o === null) {
             // Slot nodes (store leaves) dispatch to the ONE shared hook — no
             // per-node unobserved closure, no NodeExtension to hold it.
-            if (n.T & CONFIG_SLOT_NODE) slotUnobservedHook(n); else n.o?.Nt?.();
+            if (n.T & CONFIG_SLOT_NODE) slotUnobservedHook(n); else n.o?.Ct?.();
             // No more subscribers; only tear down if CONFIG_AUTO_DISPOSE is set.
             // A pending node is exempt: its in-flight async work (or the
             // transition holding it) is an observer — tearing down would orphan
@@ -35,13 +35,13 @@ function unlinkSubs(e) {
 }
 
 function trimStaleDeps(e) {
-    const n = e.Be;
-    let l = n !== null ? n.ot : e.lt;
+    const n = e.et;
+    let l = n !== null ? n.ae : e.fe;
     if (l !== null) {
         do {
             l = unlinkSubs(l);
         } while (l !== null);
-        if (n !== null) n.ot = null; else e.lt = null;
+        if (n !== null) n.ae = null; else e.fe = null;
     }
 }
 
@@ -50,13 +50,13 @@ function trimStaleDeps(e) {
 // and skipping early also avoids adding one (hidden-class churn) via the
 // null-out below.
 function clearDeps(e) {
-    let n = e.lt;
+    let n = e.fe;
     if (!n) return;
     do {
         n = unlinkSubs(n);
     } while (n !== null);
-    e.lt = null;
-    e.Be = null;
+    e.fe = null;
+    e.et = null;
 }
 
 function unobserved(e) {
@@ -108,20 +108,20 @@ function link(e, n, l = false) {
     // not relabel the value dependency as probe-only — the value read is what
     // real-error propagation and affects() coverage key off, regardless of
     // read order within the computation.
-    const o = n.Be;
-    if (o !== null && o.st === e) {
-        o.ve &&= l;
+    const o = n.et;
+    if (o !== null && o.Se === e) {
+        o.je &&= l;
         return;
     }
     let s = null;
     const t = n.ie & REACTIVE_RECOMPUTING_DEPS;
     if (t) {
-        s = o !== null ? o.ot : n.lt;
-        if (s !== null && s.st === e) {
-            s.vt = n.ze;
-            n.Be = s;
+        s = o !== null ? o.ae : n.fe;
+        if (s !== null && s.Se === e) {
+            s.yt = n.tt;
+            n.et = s;
             // First touch of this pass: the previous pass's label is stale.
-                        s.ve = l;
+                        s.je = l;
             return;
         }
     }
@@ -130,24 +130,24 @@ function link(e, n, l = false) {
     // [deps.._depsTail] prefix — the O(1) equivalent of scanning the dep list
     // (the old alien-signals `isValidLink` walk, O(n²) when a computation
     // re-reads earlier deps non-consecutively, e.g. store leaf reads).
-        const r = e.ft;
-    if (r !== null && r.ce === n && (!t || r.vt === n.ze)) {
+        const r = e.dt;
+    if (r !== null && r.Ie === n && (!t || r.yt === n.tt)) {
         // Gen-matched during a recompute = repeat touch this pass (AND); outside
         // a recompute there is no pass boundary, so the latest read labels it.
-        if (t) r.ve &&= l; else r.ve = l;
+        if (t) r.je &&= l; else r.je = l;
         return;
     }
-    const u = n.Be = e.ft = {
-        st: e,
-        ce: n,
-        ot: s,
+    const u = n.et = e.dt = {
+        Se: e,
+        Ie: n,
+        ae: s,
         en: r,
-        ae: null,
-        vt: n.ze,
-        ve: l
+        Te: null,
+        yt: n.tt,
+        je: l
     };
-    if (o !== null) o.ot = u; else n.lt = u;
-    if (r !== null) r.ae = u; else e.u = u;
+    if (o !== null) o.ae = u; else n.fe = u;
+    if (r !== null) r.Te = u; else e.u = u;
     // New subscriber edge: staged-rewrite skips (§12d) must not miss it.
         bumpNotifyEpoch();
 }

package/dist/prod/core/heap.js

@@ -16,22 +16,22 @@ import { zombieQueue, dirtyQueue } from "./scheduler.js";
  * (see GlobalQueue._update, #3291).
  */ function enqueueSub(e) {
     const E = queueFor(e);
-    if (E.Me > e.qe) E.Me = e.qe;
+    if (E.Ke > e.Be) E.Ke = e.Be;
     insertIntoHeap(e, E);
 }
 
 function actualInsertIntoHeap(e, E) {
-    const t = (e.Le?.Dt ? e.Le.Pt?.qe : e.Le?.qe) ?? -1;
-    if (t >= e.qe) e.qe = t + 1;
-    const I = e.qe;
-    const n = E.eE[I];
-    if (n === undefined) E.eE[I] = e; else {
-        const E = n.ct;
-        E._t = e;
-        e.ct = E;
-        n.ct = e;
+    const t = (e.qe?.gt ? e.qe.bt?.Be : e.qe?.Be) ?? -1;
+    if (t >= e.Be) e.Be = t + 1;
+    const n = e.Be;
+    const I = E.eE[n];
+    if (I === undefined) E.eE[n] = e; else {
+        const E = I.Tt;
+        E.Nt = e;
+        e.Tt = E;
+        I.Tt = e;
     }
-    if (I > E.EE) E.EE = I;
+    if (n > E.EE) E.EE = n;
 }
 
 function insertIntoHeap(e, E) {
@@ -44,12 +44,17 @@ function insertIntoHeap(e, E) {
         e.ie = t & -4 | REACTIVE_DIRTY | REACTIVE_IN_HEAP;
     } else {
         e.ie = t | REACTIVE_IN_HEAP;
-        // An unmarked node entering a marked heap invalidates the markHeap memo:
-        // `_marked` is only reset by runHeap, so a write between two mid-tick
-        // pulls (read-time markHeap + updateIfNecessary) would otherwise leave
-        // this node unmarked and every downstream pull stale until the next
-        // flush (#2922: the second `latest()` returned the first write's value).
-                if (E.tE && !(t & REACTIVE_DIRTY)) E.tE = false;
+        // An unmarked node entering an already-marked heap is marked on the
+        // spot, keeping the markHeap memo valid. `_marked` is only reset by
+        // runHeap, so a write between two mid-tick pulls (read-time markHeap +
+        // updateIfNecessary) would otherwise leave this node unmarked and every
+        // downstream pull stale until the next flush (#2922: the second
+        // `latest()` returned the first write's value). Invalidating the memo
+        // instead re-walked the WHOLE heap on the next pull — with N effects
+        // parked in the heap for a synchronous mount (each row writing a ref
+        // signal its effect subscribes to), mounting N rows was O(N²) (#3350).
+        // markNode's own guard skips an already-DIRTY node.
+                if (E.tE) markNode(e);
     }
     if (!(t & REACTIVE_IN_HEAP_HEIGHT)) actualInsertIntoHeap(e, E);
 }
@@ -65,23 +70,23 @@ function deleteFromHeap(e, E) {
     const t = e.ie;
     if (!(t & (REACTIVE_IN_HEAP | REACTIVE_IN_HEAP_HEIGHT))) return;
     e.ie = t & -25;
-    const I = e.qe;
-    if (e.ct === e) E.eE[I] = undefined; else {
-        const t = e._t;
-        const n = E.eE[I];
-        const o = t ?? n;
-        if (e === n) E.eE[I] = t; else e.ct._t = t;
-        o.ct = e.ct;
+    const n = e.Be;
+    if (e.Tt === e) E.eE[n] = undefined; else {
+        const t = e.Nt;
+        const I = E.eE[n];
+        const o = t ?? I;
+        if (e === I) E.eE[n] = t; else e.Tt.Nt = t;
+        o.Tt = e.Tt;
     }
-    e.ct = e;
-    e._t = undefined;
+    e.Tt = e;
+    e.Nt = undefined;
 }
 
 function markHeap(e) {
     if (e.tE) return;
     e.tE = true;
     for (let E = 0; E <= e.EE; E++) {
-        for (let t = e.eE[E]; t !== undefined; t = t._t) {
+        for (let t = e.eE[E]; t !== undefined; t = t.Nt) {
             if (t.ie & REACTIVE_IN_HEAP) markNode(t);
         }
     }
@@ -91,16 +96,16 @@ function markNode(e, E = REACTIVE_DIRTY) {
     const t = e.ie;
     if ((t & (REACTIVE_CHECK | REACTIVE_DIRTY)) >= E) return;
     e.ie = t & -4 | E;
-    for (let E = e.u; E !== null; E = E.ae) {
-        markNode(E.ce, REACTIVE_CHECK);
+    for (let E = e.u; E !== null; E = E.Te) {
+        markNode(E.Ie, REACTIVE_CHECK);
     }
     // Firewall children (projection machinery only): gate the cold-extension
     // deref on the config bit — markNode runs per sub edge per write, and an
     // unconditional _x chase here taxed every propagation (diamond -22%).
         if (e.T & CONFIG_FW_CHILDREN) {
-        for (let E = e.o.i; E !== null; E = E.Se) {
-            for (let e = E.u; e !== null; e = e.ae) {
-                markNode(e.ce, REACTIVE_CHECK);
+        for (let E = e.o.i; E !== null; E = E.Ee) {
+            for (let e = E.u; e !== null; e = e.Te) {
+                markNode(e.Ie, REACTIVE_CHECK);
             }
         }
     }
@@ -108,11 +113,11 @@ function markNode(e, E = REACTIVE_DIRTY) {
 
 function runHeap(e, E) {
     e.tE = false;
-    for (e.Me = 0; e.Me <= e.EE; e.Me++) {
-        let t = e.eE[e.Me];
+    for (e.Ke = 0; e.Ke <= e.EE; e.Ke++) {
+        let t = e.eE[e.Ke];
         while (t !== undefined) {
             if (t.ie & REACTIVE_IN_HEAP) E(t); else adjustHeight(t, e);
-            t = e.eE[e.Me];
+            t = e.eE[e.Ke];
         }
     }
     e.EE = 0;
@@ -120,21 +125,21 @@ function runHeap(e, E) {
 
 function adjustHeight(e, E) {
     deleteFromHeap(e, E);
-    let t = e.qe;
-    for (let E = e.lt; E; E = E.ot) {
-        const e = E.st;
-        const I = e.rt || e;
-        if (I.oe && I.qe >= t) t = I.qe + 1;
+    let t = e.Be;
+    for (let E = e.fe; E; E = E.ae) {
+        const e = E.Se;
+        const n = e.ce || e;
+        if (n.oe && n.Be >= t) t = n.Be + 1;
     }
-    if (e.qe !== t) {
-        e.qe = t;
-        for (let E = e.u; E !== null; E = E.ae) {
+    if (e.Be !== t) {
+        e.Be = t;
+        for (let E = e.u; E !== null; E = E.Te) {
             // Route each subscriber by its own zombie flag, mirroring the
             // post-recompute height-adjust path. Inserting into the running `heap`
             // unconditionally can park a zombie in `dirtyQueue` (or a live node in
             // `zombieQueue`), breaking the flag/queue invariant `deleteFromHeap`
             // relies on — the same corruption class as #2759.
-            insertIntoHeapHeight(E.ce, queueFor(E.ce));
+            insertIntoHeapHeight(E.Ie, queueFor(E.Ie));
         }
     }
 }

package/dist/prod/core/lanes.js

@@ -2,7 +2,7 @@ import { CONFIG_HAS_LANE, NOT_PENDING } from "./constants.js";
 
 import { ext } from "./core.js";
 
-import { currentTransition, activeTransition } from "./scheduler.js";
+import { currentTransition, waitingTransition, activeTransition } from "./scheduler.js";
 
 // Map from optimistic signal to its lane (reused for multiple writes to same signal)
 const signalLanes = new WeakMap;
@@ -20,15 +20,15 @@ const activeLanes = new Set;
     }
     // Detect parent lane: _parentSource chains from pendingSignal → pendingValueComputed → original.
     // The child lane should not merge with the parent lane.
-        const t = n.o?.St;
-    const i = t?.o?.$e;
-    const r = i ? findLane(i) : null;
+        const i = n.o?.Gt;
+    const t = i?.o?.Oe;
+    const r = t ? findLane(t) : null;
     e = {
         nn: n,
-        Oe: new Set,
+        he: new Set,
         tn: [ [], [] ],
         rn: null,
-        Ae: activeTransition,
+        ge: activeTransition,
         an: r
     };
     signalLanes.set(n, e);
@@ -39,19 +39,19 @@ const activeLanes = new Set;
     // parent-child is a property of the nodes, not of write order — otherwise
     // the owner's write merges the companion's subscribers into this lane and
     // their effects wait on its async instead of flushing immediately.
-        adoptCompanionLane(n.o?.ye, e);
-    adoptCompanionLane(n.o?.Ce, e);
+        adoptCompanionLane(n.o?.Le, e);
+    adoptCompanionLane(n.o?.Qe, e);
     return e;
 }
 
 function adoptCompanionLane(n, e) {
     if (!n) return;
-    const t = signalLanes.get(n);
-    if (!t) return;
-    const i = findLane(t);
+    const i = signalLanes.get(n);
+    if (!i) return;
+    const t = findLane(i);
     // Only the companion's own unmerged root is safely re-parentable: a root
     // that absorbed other lanes carries work that is not a child of this owner.
-        if (i !== e && i.nn === n && !i.an) i.an = e;
+        if (t !== e && t.nn === n && !t.an) t.an = e;
 }
 
 /**
@@ -63,15 +63,22 @@ function adoptCompanionLane(n, e) {
 
 /**
  * Is the lane held? `_pendingAsync` records the async the lane OWNS (derived
- * under it); the transaction's reporter map records the async a render effect
+ * under it); a transaction's reporter map records the async a render effect
  * OBSERVED pending with no boundary taking it (INV-3, the one registration
  * site). A hold needs both — the same rule the transaction itself uses, so a
  * memo nobody renders, or one a fallback-showing boundary caught, cannot tear
  * a frame and holds nothing (#3289). An orphan lane has no observation record
  * and never holds.
+ *
+ * The observation is looked up per NODE, in whichever live transaction
+ * recorded it — not in this lane's transaction. Lanes merge across
+ * transactions (#2912: ownership never travels through lanes), so after a
+ * merge the root's transaction holds the observations of only one member;
+ * the async the other member's transaction observed must hold the merged
+ * reveal just the same (A15 for lanes, #3335).
  */ function laneHeld(n) {
-    const e = n.Ae;
-    if (e) for (const t of n.Oe) if (currentTransition(e)._e.has(t)) return true;
+    if (!n.ge) return false;
+    for (const e of n.he) if (waitingTransition(e) !== null) return true;
     return false;
 }
 
@@ -85,8 +92,8 @@ function adoptCompanionLane(n, e) {
     // Move (not copy) the merged lane's work: after the merge all routing goes
     // through findLane() to the root, so anything left behind here is dead —
     // and anything *added* here later is a routing bug (INV-5).
-        for (const t of e.Oe) n.Oe.add(t);
-    e.Oe.clear();
+        for (const i of e.he) n.he.add(i);
+    e.he.clear();
     n.tn[0].push(...e.tn[0]);
     n.tn[1].push(...e.tn[1]);
     e.tn[0].length = 0;
@@ -97,11 +104,11 @@ function adoptCompanionLane(n, e) {
 /**
  * Resolve a node's lane: follow union-find chain, verify active, clear if stale.
  */ function resolveLane(n) {
-    const e = n.o?.$e;
+    const e = n.o?.Oe;
     if (!e) return undefined;
-    const t = findLane(e);
-    if (activeLanes.has(t)) return t;
-    if (n.o !== null) n.o.$e = undefined;
+    const i = findLane(e);
+    if (activeLanes.has(i)) return i;
+    if (n.o !== null) n.o.Oe = undefined;
     return undefined;
 }
 
@@ -111,50 +118,50 @@ function resolveTransition(n) {
     // transactions (#2912) — the merged root's _transition would hand this
     // node's override to whichever action wrote last through the shared
     // reader. Chase merge chains; a dead owner settled through another path.
-    if (hasActiveOverride(n) && n.o?.Tt) {
-        const e = ext(n).Tt = currentTransition(n.o?.Tt);
-        if (e.sn !== true) return e;
-        if (n.o !== null) n.o.Tt = null;
+    if (hasActiveOverride(n) && n.o?.Ot) {
+        const e = ext(n).Ot = currentTransition(n.o?.Ot);
+        if (e.ft !== true) return e;
+        if (n.o !== null) n.o.Ot = null;
     }
-    return resolveLane(n)?.Ae ?? n.Ae;
+    return resolveLane(n)?.ge ?? n.ge;
 }
 
 /**
  * Check if a node has an active optimistic override.
  */ function hasActiveOverride(n) {
     const e = n.o;
-    return e !== null && e.Pe !== undefined && e.Pe !== NOT_PENDING;
+    return e !== null && e.be !== undefined && e.be !== NOT_PENDING;
 }
 
 /**
  * Assign or merge a lane onto a node. At convergence points (node already has
  * a different active lane), merge unless the node has an active override.
  */ function assignOrMergeLane(n, e) {
-    const t = findLane(e);
-    const i = n.o?.$e;
-    if (i) {
+    const i = findLane(e);
+    const t = n.o?.Oe;
+    if (t) {
         // If the subscriber's lane was merged into another lane, it's stale —
         // replace it with the new source lane instead of following the merge chain
         // (which would incorrectly merge the new lane into the old group)
-        if (i.rn) {
-            ext(n).$e = e;
+        if (t.rn) {
+            ext(n).Oe = e;
             n.T |= CONFIG_HAS_LANE;
             return;
         }
-        const r = findLane(i);
+        const r = findLane(t);
         if (activeLanes.has(r)) {
-            if (r !== t && !hasActiveOverride(n)) {
+            if (r !== i && !hasActiveOverride(n)) {
                 // Parent-child lanes stay independent so isPending resolves without
                 // waiting for the parent's async. The child keeps ownership.
-                if (t.an && findLane(t.an) === r) {
-                    ext(n).$e = e;
+                if (i.an && findLane(i.an) === r) {
+                    ext(n).Oe = e;
                     n.T |= CONFIG_HAS_LANE;
-                } else if (r.an && findLane(r.an) === t) ; else mergeLanes(t, r);
+                } else if (r.an && findLane(r.an) === i) ; else mergeLanes(i, r);
             }
             return;
         }
     }
-    ext(n).$e = e;
+    ext(n).Oe = e;
     n.T |= CONFIG_HAS_LANE;
 }