@solidjs/signals 2.0.0-rc.2 → 2.0.0-rc.4

package/dist/prod/core/scheduler.js

@@ -6,6 +6,8 @@ import { DEV } from "./dev.js";
 
 import { NotReadyError } from "./error.js";
 
+import { sweepDormant } from "./graph.js";
+
 import { runHeap, deleteFromHeap, enqueueSub } from "./heap.js";
 
 import { activeLanes, assignOrMergeLane, findLane } from "./lanes.js";
@@ -60,8 +62,8 @@ let projectionWriteActive = false;
 const transientStoreNodes = new Set;
 
 function canUseSimpleSyncFlush(e) {
-    const t = e.k;
-    return transitions.size === 0 && activeLanes.size === 0 && e.Qt.length === 0 && t.Ke.length === 0 && t.m.length === 0 && t.cn.size === 0 && transientStoreNodes.size === 0;
+    const t = e.m;
+    return transitions.size === 0 && activeLanes.size === 0 && e.Qt.length === 0 && t.Ke.length === 0 && t.A.length === 0 && t.Tn.size === 0 && transientStoreNodes.size === 0;
 }
 
 function sweepTransientStoreNodes() {
@@ -109,21 +111,21 @@ function setProjectionWriteActive(e) {
         yt: [],
         Ne: new Map,
         Ke: [],
-        m: [],
-        cn: new Set,
-        oe: [],
+        A: [],
+        Tn: new Set,
+        ue: [],
         bt: {
             Lt: [ [], [] ],
             Qt: []
         },
-        an: false,
-        ln: new Set
+        fn: false,
+        cn: new Set
     };
 }
 
 function mergeTransitionState(e, t) {
-    t.an = e;
-    e.oe.push(...t.oe);
+    t.fn = e;
+    e.ue.push(...t.ue);
     for (const i of activeLanes) if (i._e === t) i._e = e;
     if (t.Ke.length) {
         // Move (don't copy): the global queue's batch may still be the outgoing
@@ -132,20 +134,40 @@ function mergeTransitionState(e, t) {
         e.Ke.push(...t.Ke);
         t.Ke.length = 0;
     }
-    if (t.m.length) {
+    if (t.A.length) {
         // Move (don't copy): the global queue's batch may still be the outgoing
         // transition, and the adoption pass in initTransition would re-push its
         // contents into the target — double-releasing every mark.
-        e.m.push(...t.m);
-        t.m.length = 0;
+        e.A.push(...t.A);
+        t.A.length = 0;
+    }
+    for (const i of t.Tn) e.Tn.add(i);
+    // Patch-channel stash (store/next/patch.ts): entries held for the outgoing
+    // transition must ride the merge like every other per-transition
+    // collection — releaseBatch only reads the COMMITTING transition's stash,
+    // so a stranded sidecar would silently drop its patches. Move (don't
+    // copy), same aliasing rule as the collections above. The field is an
+    // expando so this module stays free of patch imports (pay-for-use).
+        const i = t.Mt;
+    if (i !== undefined) {
+        t.Mt = undefined;
+        let n = e.Mt;
+        if (n !== undefined) n.push(...i); else n = e.Mt = i;
+        // Retarget the entries' coalescing stamps to the surviving stash
+        // (opaque backref contract with store/next/patch.ts): without this a
+        // post-merge emission misses the stamp and pushes a SECOND entry —
+        // the record's patch applies twice at commit (re-audit 5, P1-2).
+                for (let e = 0; e < i.length; e++) {
+            const t = i[e].pc;
+            if (t !== undefined && t.qe === i[e]) t.qa = n;
+        }
     }
-    for (const i of t.cn) e.cn.add(i);
     for (const [i, n] of t.Ne) {
         let t = e.Ne.get(i);
         if (!t) e.Ne.set(i, t = new Set);
         for (const e of n) t.add(e);
     }
-    for (const i of t.ln) e.ln.add(i);
+    for (const i of t.cn) e.cn.add(i);
 }
 
 function schedule() {
@@ -155,7 +177,7 @@ function schedule() {
     }
     if (scheduled) return;
     scheduled = true;
-    if (!syncDepth && !globalQueue.sn && !projectionWriteActive) queueMicrotask(flush);
+    if (!syncDepth && !globalQueue.En && !projectionWriteActive) queueMicrotask(flush);
 }
 
 /**
@@ -189,24 +211,24 @@ function notifyHalted() {
 let queueRunToken = 0;
 
 class Queue {
-    ve=null;
+    ke=null;
     Lt=[ [], [] ];
     Qt=[];
-    Mt=0;
+    Vt=0;
     created=clock;
     addChild(e) {
         this.Qt.push(e);
-        e.ve = this;
+        e.ke = this;
     }
     removeChild(e) {
         const t = this.Qt.indexOf(e);
         if (t >= 0) {
             this.Qt.splice(t, 1);
-            e.ve = null;
+            e.ke = null;
         }
     }
     notify(e, t, i, n) {
-        if (this.ve) return this.ve.notify(e, t, i, n);
+        if (this.ke) return this.ke.notify(e, t, i, n);
         return false;
     }
     run(e) {
@@ -226,8 +248,8 @@ class Queue {
         const i = ++queueRunToken;
         for (let n = 0; n < t.length; ) {
             const s = t[n];
-            if (s.Mt !== i) {
-                s.Mt = i;
+            if (s.Vt !== i) {
+                s.Vt = i;
                 s.run?.(e);
                 if (t[n] !== s) {
                     n = 0;
@@ -242,7 +264,7 @@ class Queue {
             // Route to lane's effect queue if we're in an optimistic recomputation
             if (currentOptimisticLane) {
                 const i = findLane(currentOptimisticLane);
-                i.en[e - 1].push(t);
+                i.rn[e - 1].push(t);
             } else {
                 this.Lt[e - 1].push(t);
             }
@@ -278,25 +300,25 @@ class Queue {
 }
 
 class GlobalQueue extends Queue {
-    sn=false;
+    En=false;
     // The current transaction-shaped batch: a plain ambient batch while no
     // transition is active, the active transition itself after initTransition.
-    k=createBatch();
+    m=createBatch();
     static Ce;
     static Fe;
     static tt;
-    static Vt=null;
+    static Bt=null;
     // Store-side hook: drops a keyless affects() mark's identity scope when the
     // carrier node's last registration releases (wired by store.ts, mirroring
     // _clearOptimisticStore).
-    static G=null;
+    static p=null;
     // affects()-side hooks (wired by affects.ts, mirroring _update): the mark
     // engine — count/register/release — lives with the feature. Every call site
     // is gated by state only that module creates, so `!` invocations are safe
     // once the gate holds.
+    static G=null;
     static M=null;
-    static h=null;
-    static j=null;
+    static N=null;
     // External-source bridge (wired by enableExternalSource(); null while no
     // config is active — including after _resetExternalSourceConfig()).
     static Rt=null;
@@ -315,11 +337,11 @@ class GlobalQueue extends Queue {
     static Dt=null;
     static Ht=null;
     static Je=null;
-    static p=null;
-    static Bt=null;
+    static k=null;
+    static wt=null;
     // Re-asks probes whose verdict was provisionally suppressed by a fresh read
     // of a held value, once the transaction gains an async blocker (#3028).
-    static wt=null;
+    static jt=null;
     // Optimistic-engine hooks (wired by core/optimistic.ts via
     // installOptimisticEngine(), called from verdict.ts / createOptimistic /
     // createOptimisticStore — every module that can create optimistic state).
@@ -327,39 +349,51 @@ class GlobalQueue extends Queue {
     // `_overrideValue` slot, a lane in `activeLanes`, an `_optimisticNodes`
     // entry, or a non-null `currentOptimisticLane`, so `!` invocations are safe
     // once the gate holds.
-    static vt=null;
-    static fn=null;
+    static kt=null;
     static dn=null;
-    static En=null;
-    static Tn=null;
+    static In=null;
+    static Nn=null;
+    static _n=null;
+    /** Patch-channel optimistic drain (next/patch.ts): optimistic emissions
+     * apply at lane-effect timing — visible in flight, unlike the regular
+     * effect queues an action stashes. Injected; null when unused. */
+    static ln=null;
     static Ft=null;
     static ht=null;
     static gt=null;
     static je=null;
     static $e=null;
     static ze=null;
-    static Nn=null;
+    static An=null;
     flush() {
-        if (this.sn) return;
+        if (this.En) return;
         // Fast drain: nothing in flight but plain pending commits — no dirty
         // computeds, no queued effects, no child queues, no transitions/lanes/
         // optimistic state. Commit and go; anything a commit hook schedules
         // (companion snaps, store folds notifying subs) re-arms `scheduled`
         // below and the outer drain loop takes the full spine next round.
                 if (activeTransition === null && dirtyQueue.EE < dirtyQueue.xe && this.Lt[0].length === 0 && this.Lt[1].length === 0 && this.Qt.length === 0 && canUseSimpleSyncFlush(this)) {
-            this.sn = true;
+            this.En = true;
             try {
+                // Sweep first: unobserved() pulls swept nodes out of the dirty heap,
+                // so a dormant memo dirtied in the same tick is reclaimed instead of
+                // recomputed (matching the old inline dispose-on-read counts).
+                sweepDormant();
                 commitPendingNodes();
             } finally {
-                this.sn = false;
+                this.En = false;
             }
             clock++;
-            scheduled = dirtyQueue.EE >= dirtyQueue.xe || this.Lt[0].length !== 0 || this.Lt[1].length !== 0 || this.k.yt.length !== 0;
+            scheduled = dirtyQueue.EE >= dirtyQueue.xe || this.Lt[0].length !== 0 || this.Lt[1].length !== 0 || this.m.yt.length !== 0;
             return;
         }
-        this.sn = true;
+        this.En = true;
         try {
             if (false) ;
+            // Before runHeap for the same reason as the fast drain above; late
+            // subscribers (an effect reading a swept memo this flush) revive it,
+            // which is the pay-for-use contract.
+                        sweepDormant();
             runHeap(dirtyQueue, GlobalQueue.Ce);
             if (activeTransition) {
                 const e = transitionComplete(activeTransition);
@@ -373,32 +407,32 @@ class GlobalQueue extends Queue {
                     // zombies here. Height-adjust entries still process normally: a
                     // dirtied one keeps its height flag and falls through to runHeap's
                     // adjustHeight path on the next pass of the bucket.
-                                        runHeap(zombieQueue, this.k === e ? cancelZombieRecompute : GlobalQueue.Ce);
+                                        runHeap(zombieQueue, this.m === e ? cancelZombieRecompute : GlobalQueue.Ce);
                     // Detach: the stashed transition keeps its batch; ambient work that
                     // follows lands in a fresh one. If the batch is already a separate
                     // ambient one — action done() restored activeTransition without
                     // adopting the batch, and an ordinary write landed there before
                     // the scheduled flush (#2916) — keep it: replacing it would strand
                     // its queued pending nodes with held _pendingValues forever.
-                                        if (this.k === e) currentBatch = this.k = createBatch();
+                                        if (this.m === e) currentBatch = this.m = createBatch();
                     // Run lane effects immediately (before stashing) - lanes with no pending async
                                         if (activeLanes.size) {
-                        GlobalQueue.Tn(EFFECT_RENDER);
-                        GlobalQueue.Tn(EFFECT_USER);
+                        GlobalQueue._n(EFFECT_RENDER);
+                        GlobalQueue._n(EFFECT_USER);
                     }
                     this.stashQueues(e.bt);
                     clock++;
                     // A kept ambient batch may hold pending nodes (#2916): stay
                     // scheduled so the outer drain loop commits them via the plain
                     // flush path instead of leaving them until the next natural flush.
-                                        scheduled = dirtyQueue.EE >= dirtyQueue.xe || this.k.yt.length > 0;
+                                        scheduled = dirtyQueue.EE >= dirtyQueue.xe || this.m.yt.length > 0;
                     reassignPendingTransition(e.yt);
                     activeTransition = null;
                     finalizePureQueue(null, true);
                     return;
                 }
                 const t = activeTransition;
-                const i = this.k;
+                const i = this.m;
                 i !== t && i.yt.push(...t.yt);
                 this.restoreQueues(t.bt);
                 transitions.delete(t);
@@ -412,9 +446,9 @@ class GlobalQueue extends Queue {
                     const e = createBatch();
                     e.yt = i.yt;
                     e.Ke = i.Ke;
-                    e.m = i.m;
-                    e.cn = i.cn;
-                    currentBatch = this.k = e;
+                    e.A = i.A;
+                    e.Tn = i.Tn;
+                    currentBatch = this.m = e;
                 }
             } else {
                 if (canUseSimpleSyncFlush(this)) {
@@ -432,15 +466,15 @@ class GlobalQueue extends Queue {
             // Check if finalization added items to the heap (from optimistic reversion)
                         scheduled = dirtyQueue.EE >= dirtyQueue.xe;
             // Run lane effects first (for ready lanes), then regular effects
-                        activeLanes.size && GlobalQueue.Tn(EFFECT_RENDER);
+                        activeLanes.size && GlobalQueue._n(EFFECT_RENDER);
             this.run(EFFECT_RENDER);
-            activeLanes.size && GlobalQueue.Tn(EFFECT_USER);
+            activeLanes.size && GlobalQueue._n(EFFECT_USER);
             this.run(EFFECT_USER);
             if (false) ;
             if (false && !scheduled && !activeTransition && transitions.size === 0 && activeLanes.size === 0) ;
             if (false) ;
         } finally {
-            this.sn = false;
+            this.En = false;
         }
     }
     notify(e, t, i, n) {
@@ -452,7 +486,7 @@ class GlobalQueue extends Queue {
                 // channel) updates display state on its way up but must be invisible
                 // to completion accounting BY CONSTRUCTION: it never registers a
                 // reporter and never counts toward the loading-boundary diagnostic.
-                                if (t?.i) return true;
+                                if (t?.l) return true;
                 if (activeTransition && t) {
                     const i = t.source;
                     let n = activeTransition.Ne.get(i);
@@ -461,7 +495,7 @@ class GlobalQueue extends Queue {
                     n.add(e);
                     if (n.size !== s) {
                         schedule();
-                        GlobalQueue.wt?.(activeTransition);
+                        GlobalQueue.jt?.(activeTransition);
                     }
                 }
             }
@@ -483,7 +517,7 @@ class GlobalQueue extends Queue {
         }
         transitions.add(activeTransition);
         activeTransition.Te = clock;
-        const t = this.k;
+        const t = this.m;
         if (t !== activeTransition) {
             // Adopt the ambient batch into the transaction, then make the
             // transaction the batch so later registrations land there directly.
@@ -502,15 +536,15 @@ class GlobalQueue extends Queue {
                 i._e = activeTransition;
                 activeTransition.Ke.push(i);
             }
-            if (t.m.length) activeTransition.m.push(...t.m);
-            for (const e of t.cn) activeTransition.cn.add(e);
+            if (t.A.length) activeTransition.A.push(...t.A);
+            for (const e of t.Tn) activeTransition.Tn.add(e);
             // Gated readers recorded against the ambient batch move with it: their
             // replay-at-commit now happens at the transaction's completion.
-                        if (t.ln.size) {
-                for (const e of t.ln) activeTransition.ln.add(e);
-                t.ln.clear();
+                        if (t.cn.size) {
+                for (const e of t.cn) activeTransition.cn.add(e);
+                t.cn.clear();
             }
-            currentBatch = this.k = activeTransition;
+            currentBatch = this.m = activeTransition;
         }
         for (const e of activeLanes) {
             if (!e._e) e._e = activeTransition;
@@ -554,8 +588,8 @@ function insertSubs(e, t = false) {
     const n = (i & CONFIG_HAS_LANE ? e.o?.Be : undefined) || currentOptimisticLane;
     const s = (i & CONFIG_HAS_SNAPSHOT) !== 0 && e.o?.Qe !== undefined;
     const o = reaskArmed;
-    for (let i = e.u; i !== null; i = i.fe) {
-        const e = i.ae;
+    for (let i = e.u; i !== null; i = i.ae) {
+        const e = i.ce;
         // A value-change notification is a new question for the subscriber: any
         // pending re-ask mark (refresh) it carried is superseded.
                 if (o) e.ie &= ~REACTIVE_REASK;
@@ -567,7 +601,7 @@ function insertSubs(e, t = false) {
         // pass either re-reads them fresh or trims them), and neither does the
         // tail link: it is the read IN FLIGHT — read() links before it pulls, so
         // this very commit is what that read returns.
-                if (e.ie & REACTIVE_RECOMPUTING_DEPS && i.ll === e.Ze && i !== e.Ye) e.ie |= REACTIVE_MISSED_WAKE;
+                if (e.ie & REACTIVE_RECOMPUTING_DEPS && i.nn === e.Ze && i !== e.Ye) e.ie |= REACTIVE_MISSED_WAKE;
         if (s && e.T & CONFIG_IN_SNAPSHOT_SCOPE) {
             e.ie |= REACTIVE_SNAPSHOT_STALE;
             continue;
@@ -586,7 +620,7 @@ function insertSubs(e, t = false) {
 
 function commitPendingNode(e) {
     const t = e;
-    if (!t.Se) {
+    if (!t.oe) {
         if (e.Pe !== NOT_PENDING) {
             e.be = e.Pe;
             e.Pe = NOT_PENDING;
@@ -621,6 +655,17 @@ function setStoreCommitHook(e) {
     storeCommitHook = e;
 }
 
+/** Patch-channel release hook (next/patch.ts): transition-stamped patch
+ * emissions are released when THEIR batch commits. Transitions never
+ * abort: failed actions still commit (only optimistic overrides revert),
+ * and merged-away transitions hand their stash to the survivor
+ * (mergeTransitionState) — every stash drains exactly once. Injected like
+ * storeCommitHook to stay tree-shakeable. */ let patchCommitHook = null;
+
+function setPatchCommitHook(e) {
+    patchCommitHook = e;
+}
+
 function commitPendingNodes() {
     const e = currentBatch.yt;
     for (let t = 0; t < e.length; t++) {
@@ -628,6 +673,7 @@ function commitPendingNodes() {
     }
     e.length = 0;
     storeCommitHook?.();
+    patchCommitHook?.(currentBatch);
 }
 
 function finalizePureQueue(e = null, t = false) {
@@ -641,20 +687,20 @@ function finalizePureQueue(e = null, t = false) {
     if (i) {
         if (n) commitPendingNodes();
         // The settling batch: the completing transaction's, or the ambient one.
-                const t = e ?? globalQueue.k;
+                const t = e ?? globalQueue.m;
         // Optimistic reversion: a non-empty batch means _optimisticWrite ran,
         // which installed the engine's hooks.
-                if (t.Ke.length) GlobalQueue.fn(t.Ke);
+                if (t.Ke.length) GlobalQueue.dn(t.Ke);
         // Replay entanglement: subs recorded by the read-time gate get rescheduled
         // so they re-run with the now-committed values visible. The ambient batch
         // replays too — laneReadsCommitted records readers whose committed-view
         // read hid a same-tick plain write that just committed above (#2963).
-                if (t.ln.size) {
-            for (const e of t.ln) {
+                if (t.cn.size) {
+            for (const e of t.cn) {
                 if (e.ie & REACTIVE_DISPOSED) continue;
                 enqueueSub(e);
             }
-            t.ln.clear();
+            t.cn.clear();
             // A completing transition keeps the outer flush loop alive by itself;
             // the ambient batch needs the re-arm or the replay sits in the heap
             // until the next unrelated write.
@@ -666,18 +712,18 @@ function finalizePureQueue(e = null, t = false) {
         // held boundary display state through the visual channel, and their
         // release is the display-state update point — re-run the boundary sweep
         // (the earlier sweep above ran while the marks were still live).
-                if (t.m.length) {
-            GlobalQueue.M(t.m);
+                if (t.A.length) {
+            GlobalQueue.G(t.A);
             if (globalQueue.Qt.length) checkBoundaryChildren(globalQueue);
         }
         // A non-empty set means trackOptimisticStore ran, which installed the
         // hook; the hook iterates, clears, and schedules (keeping the loop out of
         // core lets esbuild shake it — rollup already folds the null guard). The
         // completing transition scopes the clear to its own layer keys (#2899).
-                if (t.cn.size) GlobalQueue.Vt(t.cn, e);
+                if (t.Tn.size) GlobalQueue.Bt(t.Tn, e);
         sweepTransientStoreNodes();
         // Lanes only enter activeLanes through the engine's getOrCreateLane.
-                if (activeLanes.size) GlobalQueue.En(e);
+                if (activeLanes.size) GlobalQueue.Nn(e);
     }
 }
 
@@ -717,7 +763,7 @@ const globalQueue = new GlobalQueue;
 // property hop through `_batch` was a measured instruction-count regression
 // (CodSpeed update1to1, PR #2905). The field stays authoritative for
 // cross-module readers; every `_batch` assignment updates both.
-let currentBatch = globalQueue.k;
+let currentBatch = globalQueue.m;
 
 function flush(e) {
     if (e) {
@@ -734,7 +780,7 @@ function flush(e) {
             }
         }
     }
-    if (globalQueue.sn) {
+    if (globalQueue.En) {
         return;
     }
     if (halted) return;
@@ -756,15 +802,15 @@ function reporterBlocksSource(e, t) {
         let e = i.ut;
         while (e) {
             if (e === t || e.lt === t) return true;
-            e = e.o?.It;
+            e = e.o?.Et;
         }
     }
     return !!(e.S & STATUS_PENDING && e.o?._ instanceof NotReadyError && e.o?._.source === t);
 }
 
 function transitionComplete(e) {
-    if (e.an) return true;
-    if (e.oe.length) return false;
+    if (e.fn) return true;
+    if (e.ue.length) return false;
     let t = true;
     for (const [i, n] of e.Ne) {
         let s = false;
@@ -783,13 +829,13 @@ function transitionComplete(e) {
     // Override blockage lives with the engine (absent hook = "no optimistic
     // blockage"); the hook's loops over _optimisticNodes/_optimisticStores are
     // no-ops when the transition holds neither, so no pre-check is needed.
-        if (t && GlobalQueue.dn?.(e)) t = false;
-    t && (e.an = true);
+        if (t && GlobalQueue.In?.(e)) t = false;
+    t && (e.fn = true);
     return t;
 }
 
 function currentTransition(e) {
-    while (e.an && typeof e.an === "object") e = e.an;
+    while (e.fn && typeof e.fn === "object") e = e.fn;
     return e;
 }
 
@@ -803,4 +849,4 @@ function runInTransition(e, t) {
     }
 }
 
-export { GlobalQueue, Queue, activeAffectsMarks, activeLanes, activeTransition, armReaskClear, assignOrMergeLane, bumpNotifyEpoch, clock, currentTransition, dirtyQueue, enforceLoadingBoundary, finalizePureQueue, findLane, flush, globalQueue, haltReactivity, insertSubs, notifyEpoch, projectionWriteActive, queuePendingNode, reaskArmed, resetErrorHalt, runInTransition, schedule, setProjectionWriteActive, setStoreCommitHook, shiftAffectsMarks, storeCommitHook, zombieQueue };
+export { GlobalQueue, Queue, activeAffectsMarks, activeLanes, activeTransition, armReaskClear, assignOrMergeLane, bumpNotifyEpoch, clock, currentTransition, dirtyQueue, enforceLoadingBoundary, finalizePureQueue, findLane, flush, globalQueue, haltReactivity, insertSubs, notifyEpoch, patchCommitHook, projectionWriteActive, queuePendingNode, reaskArmed, resetErrorHalt, runInTransition, schedule, setPatchCommitHook, setProjectionWriteActive, setStoreCommitHook, shiftAffectsMarks, storeCommitHook, zombieQueue };

package/dist/prod/core/verdict.js

@@ -50,7 +50,7 @@ let pendingProbe = null;
     const t = e.lt;
     if (!t) return;
     t.T |= CONFIG_CHILD_COMPANIONS;
-    (ext(t).Nt ??= new Set).add(e);
+    (ext(t).It ??= new Set).add(e);
 }
 
 function getPendingSignal(e) {
@@ -63,7 +63,7 @@ function getPendingSignal(e) {
         ext(e).Ge = t;
         e.T |= CONFIG_HAS_COMPANIONS;
         markFirewallChildCompanions(e);
-        ext(t).It = e;
+        ext(t).Et = e;
         if (computePendingState(e)) setSignal(t, true);
     }
     return t;
@@ -153,8 +153,8 @@ function computePendingState(e) {
     // so the one walk covers direct marks, derivation, and companion chains.
         if (markCovered(e)) return true;
     const n = e.lt;
-    if (e.o?.It) {
-        const t = e.o?.It;
+    if (e.o?.Et) {
+        const t = e.o?.Et;
         const n = t.lt || t;
         return newQuestionInFlight(n);
     }
@@ -185,7 +185,7 @@ function updatePendingSignal(e) {
 }
 
 function updateChildCompanions(e) {
-    const t = e.o?.Nt;
+    const t = e.o?.It;
     if (t === undefined) return;
     for (const e of t) updatePendingSignal(e);
 }
@@ -205,8 +205,8 @@ function updateChildCompanions(e) {
         if (i.has(e)) return;
         i.add(e);
         if (e.o?.Ge || e.o?.ge) n(e);
-        for (let t = e.u; t !== null; t = t.fe) visit(t.ae);
-        for (let t = e.o?.l ?? null; t !== null; t = t.ce) {
+        for (let t = e.u; t !== null; t = t.ae) visit(t.ce);
+        for (let t = e.o?.i ?? null; t !== null; t = t.Se) {
             visit(t);
         }
     };
@@ -273,6 +273,13 @@ function snapCompanionsToState(e) {
 
 function getLatestValueComputed(e) {
     let t = e.o?.ge;
+    // A shadow disposed while unobserved (its gated reader unmounted at a
+    // landing) is a corpse: sync writes into it equality-swallow against its
+    // frozen _value, and a later read revives it via recompute — clearing
+    // DISPOSED and re-deriving from the committed view, so the banner showed
+    // the previous transition's target (#3041 follow-up). Treat it as absent;
+    // recreation backfills from the in-flight write below.
+        if (t && t.ie & REACTIVE_DISPOSED) t = undefined;
     if (!t) {
         const n = latestReadActive;
         setLatestReadActive(false);
@@ -285,7 +292,7 @@ function getLatestValueComputed(e) {
         ext(e).ge = t;
         e.T |= CONFIG_HAS_COMPANIONS;
         markFirewallChildCompanions(e);
-        ext(t).It = e;
+        ext(t).Et = e;
  // Parent-child lane relationship
         // Backfill an in-flight write (mirrors getPendingSignal): the companion is
         // created lazily, possibly after the write was processed — syncCompanions
@@ -341,7 +348,7 @@ function getLatestValueComputed(e) {
 
 /** The isPending()-probe read path, installed as GlobalQueue._pendingCheck. */ function pendingCheckRead(e, t, n, i) {
     setPendingCheckActive(false);
-    if (typeof e.Se === "function") prepareComputed(e, true);
+    if (typeof e.oe === "function") prepareComputed(e, true);
     const r = n.S;
     if (t && r & STATUS_PENDING && r & STATUS_UNINITIALIZED) {
         if (tracking && e !== t) link(e, t);
@@ -362,8 +369,22 @@ function getLatestValueComputed(e) {
  * (#3028).
  */ function heldAwaitingAsync(e) {
     const t = e._e;
-    const n = t ? currentTransition(t) : null;
-    if (!n || n.an) return false;
+    const n = t ? currentTransition(t) : activeTransition;
+    if (!n || n.fn) return false;
+    // A plain staged write (a signal/store leaf — no _fn) held while an action
+    // is still running is an INPUT to a computation still in flight (#3078):
+    // the pairing rule must not suppress the verdict, or a memo recomputing
+    // mid-action reads the staged value, gets told "not pending", and
+    // disagrees with a direct isPending() probe for the whole action window.
+    // A computed's staged value is the opposite case — a LANDED answer
+    // awaiting reveal — where the pairing rule stands even inside an open
+    // action (#2831: a reader that saw the new value must not also see
+    // pending); still-computing answers are covered by the reporter scan.
+        if (n.ue.length && !e.oe) return true;
+    // A node not yet stamped with a transition only qualifies through the
+    // action check above; the reporter scan below is for transition-held
+    // writes whose source async is still computing.
+        if (!t) return false;
     for (const [e, t] of n.Ne) {
         if (t.size && e.S & STATUS_PENDING && e.o?._?.source === e) return true;
     }
@@ -422,7 +443,7 @@ function isPending(e) {
         // this flush (a downstream async pends and holds it), the suppression was
         // wrong and the wrapper must re-ask (#3028). Remember who to wake — the
         // async registration (GlobalQueue.notify) triggers wakeSuppressedProbes.
-                if (!i.found && i.suppressed.length && context && typeof context.Se === "function") {
+                if (!i.found && i.suppressed.length && context && typeof context.oe === "function") {
             for (const e of i.suppressed) {
                 let t = suppressedProbes.get(e);
                 if (!t) suppressedProbes.set(e, t = new Set);
@@ -467,10 +488,10 @@ GlobalQueue.Ht = recordFreshRead;
 
 GlobalQueue.Je = applyReask;
 
-GlobalQueue.p = repollDownstreamVerdicts;
+GlobalQueue.k = repollDownstreamVerdicts;
 
-GlobalQueue.Bt = witnessAffects;
+GlobalQueue.wt = witnessAffects;
 
-GlobalQueue.wt = wakeSuppressedProbes;
+GlobalQueue.jt = wakeSuppressedProbes;
 
 export { isPending, latest };

package/dist/prod/index.js

@@ -38,6 +38,10 @@ export { createProjectionNext as createProjection } from "./store/next/projectio
 
 export { merge, omit } from "./store/utils.js";
 
+export { patchableRaw, registerPatch, registerRowOps, registerSlotPatchNext as registerSlotPatch } from "./store/next/patch.js";
+
+export { storeHasFamily, storeHasOptimisticFamily, storeIsShallow } from "./store/next/store.js";
+
 export { storePath } from "./store/storePath.js";
 
 const DEV = undefined;