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

package/dist/prod/store/next/store.js

@@ -1,6 +1,6 @@
-import { unwrapOverride, $REFRESH, CONFIG_OWNED_WRITE, NOT_PENDING, CONFIG_OPTIMISTIC, STATUS_UNINITIALIZED, STATUS_ERROR, CONFIG_CHILDREN_FORBIDDEN } from "../../core/constants.js";
+import { unwrapOverride, $REFRESH, CONFIG_OWNED_WRITE, NOT_PENDING, CONFIG_OPTIMISTIC, CONFIG_HELD_TRUTH, STATUS_UNINITIALIZED, STATUS_ERROR, CONFIG_CHILDREN_FORBIDDEN, CONFIG_AUTHORITATIVE_READ } from "../../core/constants.js";
 
-import { setSignal, isEqual, read, pendingCheckActive, latestReadActive, readNodeFast, READ_SLOW, signal, ext, setLatestReadActive, prepareComputed } from "../../core/core.js";
+import { setSignal, isEqual, read, pendingCheckActive, latestReadActive, readNodeFast, READ_SLOW, signal, ext, setLatestReadActive, prepareComputed, context } from "../../core/core.js";
 
 import { projectionWriteActive, setProjectionWriteActive, activeTransition, schedule, currentTransition, setStoreCommitHook } from "../../core/scheduler.js";
 
@@ -193,7 +193,7 @@ function getNode(e, t, n) {
         // Optimistic families: arm the override slot — setSignal routes armed
         // nodes through the core engine (lanes, ownership, reverts all native).
                 if (e.fam?.opt) {
-            ext(o).De = NOT_PENDING;
+            ext(o).Oe = NOT_PENDING;
             o.T |= CONFIG_OPTIMISTIC;
         }
         // A node born inside a live mark's identity scope inherits the mark
@@ -226,7 +226,7 @@ function getHasNode(e, t, n) {
         }, e.fam?.node ?? undefined);
         o.T |= CONFIG_OWNED_WRITE;
         if (e.fam?.opt) {
-            ext(o).De = NOT_PENDING;
+            ext(o).Oe = NOT_PENDING;
             o.T |= CONFIG_OPTIMISTIC;
         }
         if (affectsScopesLive()) inheritAffectsMarks(o, e.v, t);
@@ -247,7 +247,7 @@ function getKeySetNode(e) {
         }, e.fam?.node ?? undefined);
         n.T |= CONFIG_OWNED_WRITE;
         if (e.fam?.opt) {
-            ext(n).De = NOT_PENDING;
+            ext(n).Oe = NOT_PENDING;
             n.T |= CONFIG_OPTIMISTIC;
         }
         e.k = t;
@@ -267,7 +267,7 @@ function getDeepNode(e) {
         }, e.fam?.node ?? undefined);
         n.T |= CONFIG_OWNED_WRITE;
         if (e.fam?.opt) {
-            ext(n).De = NOT_PENDING;
+            ext(n).Oe = NOT_PENDING;
             n.T |= CONFIG_OPTIMISTIC;
         }
         if (affectsScopesLive()) inheritAffectsMarks(n, e.v, $TRACK);
@@ -350,8 +350,22 @@ function cloneRaw(e, t) {
 }
 
 function ensurePB(e) {
-    if (activeTransition !== null) foldBatches.set(e, activeTransition);
     let t = e.pb;
+    // Truth-staged backing hand-off (#3164 fold): a TENTATIVE draft opening on
+    // a target whose pending backing is truth-staged (a landing folded into a
+    // retaining transaction — it carries a foldBatches stamp) must not share
+    // the container. Tentative writes would pollute staged truth, and the
+    // tentative discard (notifyOptimisticWrites nulls pb) would destroy the
+    // landing. Park the staged backing and open a fresh draft seeded from the
+    // optimistic view below; the tentative discard restores it. The
+    // tentativePBs guard scopes this to draft OPEN: the draft's own backing
+    // (foldBatches-stamped by its first write when an action's transition is
+    // ambient) must not be parked by its own later writes.
+        if (t !== null && !tentativePBs.has(t) && e.fam?.opt === true && !projectionWriteActive && !getWriteOverride() && foldBatches.has(e)) {
+        stagedTruthPB.set(e, t);
+        t = e.pb = null;
+    }
+    if (activeTransition !== null) foldBatches.set(e, activeTransition);
     if (t === null) {
         // Prototype-chain overlay (#3044): plain-data non-array containers
         // outside projection/optimistic families open drafts in O(1) — own keys
@@ -369,18 +383,19 @@ function ensurePB(e) {
         // seed from committed truth — seeding overrides there would fold a lane
         // value into the committed home ("authority wins at reveal" would break).
                 if (e.fam?.opt && !projectionWriteActive && !getWriteOverride()) {
+            tentativePBs.add(t);
             const n = e.n;
             if (n !== null) {
                 for (const e of Reflect.ownKeys(n)) {
                     const r = n[e];
-                    if (hasActiveOverride(r)) t[e] = unwrapOverride(r.o?.De);
+                    if (hasActiveOverride(r)) t[e] = unwrapOverride(r.o?.Oe);
                 }
             }
             const r = e.h;
             if (r !== null) {
                 for (const e of Reflect.ownKeys(r)) {
                     const n = r[e];
-                    if (hasActiveOverride(n) && !unwrapOverride(n.o?.De)) delete t[e];
+                    if (hasActiveOverride(n) && !unwrapOverride(n.o?.Oe)) delete t[e];
                 }
             }
         }
@@ -406,7 +421,7 @@ function ensurePB(e) {
  * foldHeld's node stamps). */ function heldMaskView(e) {
     const t = e.ht;
     if (t === null) return null;
-    if (t !== PLAIN_HOLD && currentTransition(t)?.fn === true) return e.ht = e.hv = null;
+    if (t !== PLAIN_HOLD && currentTransition(t)?.sn === true) return e.ht = e.hv = null;
     return e.hv;
 }
 
@@ -491,6 +506,17 @@ function queueFold(e) {
  * Refreshed on every write; resolved through currentTransition at drain
  * (transitions merge — same rule as heldMaskView). */ const foldBatches = new WeakMap;
 
+/** Parked truth-staged pending backings (#3164 fold): a tentative draft that
+ * opens while a folded landing's backing is live moves the staged container
+ * here (see ensurePB); the tentative discard in notifyOptimisticWrites
+ * restores it in place of the usual null. */ const stagedTruthPB = new WeakMap;
+
+/** Backings opened by TENTATIVE drafts (optimistic user setters): ensurePB's
+ * truth-park must not fire against the draft's own container on its second
+ * and later writes (the first write stamps foldBatches whenever an action's
+ * transition is ambient). Entries die with their draft — tentative backings
+ * are consumed at setter exit. */ const tentativePBs = new WeakSet;
+
 /** Committed-time privatization for parent-chain slot updates (path copying). */ function privatizeCommitted(e) {
     if (ownedRaw.has(e.v)) return;
     const t = cloneRaw(e.v, e);
@@ -525,7 +551,7 @@ function drainFolds() {
             // keys; observed keys also hit the pending-node held check below).
             const e = foldBatches.get(t);
             if (e !== undefined) {
-                if (currentTransition(e).fn === false) {
+                if (currentTransition(e).sn === false) {
                     foldOlds.set(t, n);
                     continue;
                 }
@@ -781,7 +807,13 @@ function drainFolds() {
     //   IMMEDIATE — landed truth shows to untracked readers even while a
     //   downstream consumer's own async still holds the effect-level reveal
     //   (spec-async "verdicts never inherit consumers' in-flight state").
-        if (e.fam !== null && e.pb !== null && getWriteOverride()) {
+    //   EXCEPT under an active transaction (#3164 fold): a landing riding a
+    //   retaining transaction (the optimistic module's aroundWrite binds it)
+    //   stages instead — ensurePB stamped foldBatches, so the backing commits
+    //   with the transaction and the reveal is atomic at settle. The pinned
+    //   immediate-commit contract is stated over the no-transaction microtask
+    //   posture, which `activeTransition === null` is exactly.
+        if (e.fam !== null && e.pb !== null && getWriteOverride() && activeTransition === null) {
         // Landed truth (post-await write-override): immediately visible to every
         // reader — any staged held view is superseded.
         if (e.ht !== null) e.ht = e.hv = null;
@@ -976,7 +1008,7 @@ const UNSAFE_KEYS = new Set([ "__proto__", "prototype", "constructor" ]);
  * / onSettled callbacks) get COMMITTED visibility (#3006), same as core. */ function inOwnerContext() {
     const e = getOwner();
     if (e === null) return false;
-    const t = e.Ct ? e.Ot : e;
+    const t = e.Gt ? e.Dt : e;
     return t != null && !(t.T & CONFIG_CHILDREN_FORBIDDEN);
 }
 
@@ -987,7 +1019,7 @@ const UNSAFE_KEYS = new Set([ "__proto__", "prototype", "constructor" ]);
  * committed to them regardless of staged writes. */ function inForbiddenScope() {
     const e = getOwner();
     if (e === null) return false;
-    const t = e.Ct ? e.Ot : e;
+    const t = e.Gt ? e.Dt : e;
     return t != null && !!(t.T & CONFIG_CHILDREN_FORBIDDEN);
 }
 
@@ -998,7 +1030,7 @@ const UNSAFE_KEYS = new Set([ "__proto__", "prototype", "constructor" ]);
     if (t === null) return false;
     for (const e of Reflect.ownKeys(t)) {
         const n = t[e];
-        if (n.Pe !== NOT_PENDING && n._e != null && n._e.fn !== true) return true;
+        if (n.Pe !== NOT_PENDING && n.Ae != null && n.Ae.sn !== true) return true;
     }
     return false;
 }
@@ -1018,16 +1050,37 @@ function readSource(e) {
     // servable). Drafts (setter window OR projection write-override) and
     // owner-context reads see the pending backing; context-free reads see
     // committed. Node reads apply the same rule, so both homes agree.
-        if (e.pb !== null && (inDraft(e) || getWriteOverride() || inOwnerContext() || 
+        if (e.pb !== null && (inDraft(e) || getWriteOverride() || 
+    // Owner-context readers see the pending backing — EXCEPT held truth
+    // on an optimistic family (#3164 fold): a live pb on an opt family
+    // outside the draft/write-override windows is a staged landing
+    // (tentative drafts never outlive their setter), and only the
+    // authoritative postures and latest() see it (the backing-level twin
+    // of core read()'s A17-for-held-truth arm; ordinary readers keep
+    // committed until the transaction's reveal).
+    inOwnerContext() && !heldTruthMasked(e) || 
     // A projection's pending backing is authoritative-elect: serve it to
     // context-free readers too UNLESS a transition is holding the node
     // commits (downstream async hold — stale committed is the contract)
     // or the reader is a CHILDREN_FORBIDDEN scope, which never observes
     // its own unsettled write (#3082, signal parity per #3006).
-    e.fam !== null && !foldHeld(e) && !inForbiddenScope())) return e.pb;
+    e.fam !== null && !heldTruthMasked(e) && !foldHeld(e) && !inForbiddenScope())) return e.pb;
     return e.v;
 }
 
+/** #3164 fold: HELD truth on an optimistic family — a pending backing
+ * stamped by a live transition that retains optimism — is masked from
+ * ordinary readers (they keep committed until the transaction's reveal);
+ * the authoritative postures and latest() tunnel through. Un-stamped
+ * backings and optimism-free transitions keep ordinary mid-batch/
+ * speculation visibility. */ function heldTruthMasked(e) {
+    if (e.fam?.opt !== true || latestReadActive || authoritativeServe()) return false;
+    const t = foldBatches.get(e);
+    // opt families are only created by createOptimisticStore, whose module
+    // install populates optHooks — the assertion holds by construction.
+        return t !== undefined && optHooks.retainsOptimism(t);
+}
+
 const hasOwn = Object.prototype.hasOwnProperty;
 
 // Allocation-free own-accessor probe (replaces eager descriptor scans — the
@@ -1057,7 +1110,27 @@ function isOwnAccessor(e, t) {
 
 /** Active optimistic override on an armed node (armed slot idles at
  * NOT_PENDING; undefined = unarmed plain node). */ function hasActiveOverride(e) {
-    return e.o?.De !== undefined && e.o?.De !== NOT_PENDING;
+    return e.o?.Oe !== undefined && e.o?.Oe !== NOT_PENDING;
+}
+
+/** The reading computation is until()'s authoritative-view predicate — same
+ * source of truth as core read()'s A17 carve-out (`context`, which persists
+ * under untrack). optimisticView()'s composition gate consults exactly this:
+ * write-side machinery (patch emission, tentative re-application) must keep
+ * composing even when it runs inside an authoritative-write bracket. */ function authoritativeRead() {
+    const e = context;
+    return e !== null && (e.T & CONFIG_AUTHORITATIVE_READ) !== 0;
+}
+
+/** Serve-side authoritative gate: until()'s predicate PLUS truth authors —
+ * the projection derive's draft (wrapDraft trap brackets, runAuthoritative;
+ * the same posture pair ensurePB classifies drafts by). A source computing
+ * the next truth must never read its callers' tentative overlays: a derive
+ * continuation's `store.push` computing its index from an action's
+ * optimistic row landed truth in the wrong slot and corrupted committed
+ * state (#3108). Trap-level overlay serves gate on this so values, length,
+ * membership, and keys leave the authoritative view together. */ function authoritativeServe() {
+    return projectionWriteActive || getWriteOverride() || authoritativeRead();
 }
 
 /** Context-aware node view for reads outside tracking: active override >
@@ -1069,7 +1142,17 @@ function isOwnAccessor(e, t) {
  * keys, which are served by the trap, not the node). */ function nodeValue(e, t) {
     // latest() sees the in-flight parked value like an owner-context reader
     // does (#3075) — signal/memo parity for store-node-backed keys.
-    const n = hasActiveOverride(e) ? unwrapOverride(e.o?.De) : e.Pe !== NOT_PENDING && (latestReadActive || inOwnerContext()) ? e.Pe : t;
+    // Authoritative-view reads (until()'s predicate) skip the override arm
+    // only: staged pending values are authoritative, overrides are the
+    // caller's optimism.
+    const n = !authoritativeServe() && hasActiveOverride(e) ? unwrapOverride(e.o?.Oe) : e.Pe !== NOT_PENDING && (latestReadActive || 
+    // Owner-context pending visibility — except HELD truth (#3164,
+    // see CONFIG_HELD_TRUTH: fold-staged or entangle-stolen
+    // confirming truth), which only authoritative/latest readers
+    // see (core read()'s A17-for-held-truth twin; ordinary readers
+    // keep committed until the transaction's reveal — latest() is
+    // exempted by the leading arm above).
+    (inOwnerContext() || authoritativeServe()) && !(e.T & CONFIG_HELD_TRUTH && !authoritativeServe())) ? e.Pe : t;
     return n === FORCE ? t : n;
 }
 
@@ -1094,15 +1177,20 @@ function isOwnAccessor(e, t) {
                 read(getNode(e, t, n));
             }
         }
-        return optHooks.optimisticView(e, r).length;
+        // Truth authors read the backing's own length — an optimistic row from
+        // the caller's transaction must not shift where the author's next write
+        // lands (#3108).
+                return (authoritativeServe() ? r : optHooks.optimisticView(e, r)).length;
     }
     if (inDraft(e)) {
         // Optimistic drafts before their first write have no pending backing yet;
         // reads must still see the live optimistic view (compose, not clobber —
         // #2951). Once ensurePB runs, the seeded clone carries the view.
-        if (e.fam?.opt && e.pb === null) {
+        // AUTHORITATIVE drafts (projection derive) never overlay — ensurePB's
+        // seeding rule, applied to the read side (#3108).
+        if (e.fam?.opt && e.pb === null && !authoritativeServe()) {
             const n = e.n?.[t];
-            if (n !== undefined && hasActiveOverride(n)) f = unwrapOverride(n.o?.De);
+            if (n !== undefined && hasActiveOverride(n)) f = unwrapOverride(n.o?.Oe);
         }
     } else {
         if (i !== undefined) {
@@ -1285,9 +1373,12 @@ const traps = {
                     if (e.s) return serveShallow(e, t, r);
                     return isWrappable(r) ? draftServe(e, wrapNext(r, e, t)) : r;
                 }
-            } else if (f === undefined && inDraft(e) && e.fam?.opt && e.pb === null) {
+            } else if (f === undefined && inDraft(e) && e.fam?.opt && e.pb === null && 
+            // AUTHORITATIVE drafts (landing folds) never seed from overrides —
+            // the caller's optimism is not truth (has-trap twin below).
+            !authoritativeServe()) {
                 const n = e.n?.[t];
-                if (n !== undefined && hasActiveOverride(n)) f = unwrapOverride(n.o?.De);
+                if (n !== undefined && hasActiveOverride(n)) f = unwrapOverride(n.o?.Oe);
             }
             if (e.s) return serveShallow(e, t, f);
             return isWrappable(f) ? draftServe(e, wrapNext(f, e, t)) : f;
@@ -1307,15 +1398,17 @@ const traps = {
         if (!inDraft(e)) {
             if (getObserver() !== null) {
                 const n = getHasNode(e, t, r);
-                const i = read(n);
+                // Authoritative-view readers get the right answer for free: core read()
+                // skips the override arm for them, so nv is authoritative presence.
+                                const i = read(n);
                 if (hasActiveOverride(n)) r = !!i;
-            } else {
+            } else if (!authoritativeServe()) {
                 const n = e.h?.[t];
-                if (n !== undefined && hasActiveOverride(n)) r = !!unwrapOverride(n.o?.De);
+                if (n !== undefined && hasActiveOverride(n)) r = !!unwrapOverride(n.o?.Oe);
             }
-        } else if (e.fam?.opt && e.pb === null) {
+        } else if (e.fam?.opt && e.pb === null && !authoritativeServe()) {
             const n = e.h?.[t];
-            if (n !== undefined && hasActiveOverride(n)) r = !!unwrapOverride(n.o?.De);
+            if (n !== undefined && hasActiveOverride(n)) r = !!unwrapOverride(n.o?.Oe);
         }
         return r;
     },
@@ -1338,14 +1431,15 @@ const traps = {
         // Optimistic membership overlay: presence-node overrides add/remove keys
         // (per-transaction lifecycle rides the nodes — §6, FINDING-2's fix).
         // Draft reads before the first write overlay too (pb, once created, is
-        // seeded with the view).
-                if (e.fam?.opt && e.h !== null && (!inDraft(e) || e.pb === null)) {
+        // seeded with the view). Authoritative-view reads (until()'s predicate,
+        // truth-author drafts) skip the overlay.
+                if (!authoritativeServe() && e.fam?.opt && e.h !== null && (!inDraft(e) || e.pb === null)) {
             let t = null;
             for (const r of Reflect.ownKeys(e.h)) {
                 const i = e.h[r];
                 if (!hasActiveOverride(i)) continue;
                 t ??= new Set(n);
-                if (unwrapOverride(i.o?.De)) t.add(r); else t.delete(r);
+                if (unwrapOverride(i.o?.Oe)) t.add(r); else t.delete(r);
             }
             if (t !== null) return [ ...t ];
         }
@@ -1360,10 +1454,10 @@ const traps = {
             if (e.del !== null && e.del.has(t)) return undefined;
             if (r === undefined) r = Object.getOwnPropertyDescriptor(e.v, t);
         }
-        if (e.fam?.opt && !inDraft(e)) {
+        if (!authoritativeServe() && e.fam?.opt && !inDraft(e)) {
             const n = e.h?.[t];
             if (n !== undefined && hasActiveOverride(n)) {
-                if (!unwrapOverride(n.o?.De)) return undefined;
+                if (!unwrapOverride(n.o?.Oe)) return undefined;
  // opt delete
                                 if (r === undefined) {
                     const n = e.n?.[t];
@@ -1725,4 +1819,4 @@ function snapshotWalk(e, t, n) {
     return f ?? r;
 }
 
-export { adoptPB, bumpDeep, createStoreNext, deepNext, getHasNode, getKeySetNode, getNode, hasAccessorFlag, hasActiveOverride, materializePB, notifyFold, notifyFoldTail, notifyKeyDiff, notifyKeyValue, pcOf, runAuthoritative, snapshotNext, storeHasFamily, storeHasOptimisticFamily, storeIsShallow, storeSetterNext, targetIsPlain, targetsEqual, unwrapValue, wrapNext };
+export { adoptPB, arrayStructureChanged, authoritativeRead, authoritativeServe, bumpDeep, createStoreNext, deepNext, getHasNode, getKeySetNode, getNode, hasAccessorFlag, hasActiveOverride, materializePB, membershipChanged, notifyFold, notifyFoldTail, notifyKeyDiff, notifyKeyValue, pcOf, runAuthoritative, snapshotNext, stagedTruthPB, storeHasFamily, storeHasOptimisticFamily, storeIsShallow, storeSetterNext, targetIsPlain, targetsEqual, unwrapValue, wrapNext };

package/dist/prod/store/store.js

@@ -252,7 +252,7 @@ s) {
     // Callers guard on `pendingCheckActive`, which only flips inside
     // isPending() — the verdict layer is loaded and its hook installed.
     const o = e[STORE_NODE]?.[$AFFECTS];
-    if (o?.o?.t) GlobalQueue.wt(o);
+    if (o?.o?.t) GlobalQueue.Wt(o);
     if (affectsScopes.size) {
         // Chained backings (§7b): a wrapper's STORE_VALUE can be another store's
         // proxy — marks cover by identity of the BASE raw, so resolve the chain
@@ -263,7 +263,7 @@ s) {
                 let t = r;
                 for (;;) {
                     if (s.scope.has(t)) {
-                        GlobalQueue.wt(e);
+                        GlobalQueue.Wt(e);
                         break;
                     }
                     const o = t?.[$TARGET];

package/dist/types/core/async.d.ts

@@ -16,6 +16,8 @@ export declare function releaseSettledDependents(el: Computed<any>): void;
 export declare function settleErroredDependents(el: Computed<any>, error: any): void;
 export declare function settlePendingSource(el: Computed<any>): void;
 export declare function isThenable<T>(value: T | PromiseLike<T>): value is PromiseLike<T>;
+/** Fire and clear a node's iterator-flight cancellation hook (#3122). */
+export declare function releaseFlightTeardown(el: Computed<any>): void;
 export declare function handleAsync<T>(el: Computed<T>, result: T | PromiseLike<T> | AsyncIterable<T>, setter?: (value: T) => void): T;
 export declare function clearStatus(el: Computed<any>, clearUninitialized?: boolean): void;
 export declare function notifyStatus(el: Computed<any>, status: number, error: any, blockStatus?: boolean, lane?: OptimisticLane): void;

package/dist/types/core/attribution.d.ts

@@ -60,11 +60,16 @@ export interface RerunEvent {
     /** Wall time of this run including nested recomputes (ms). */
     totalMs: number;
     /**
-     * Whether the run committed a changed value. A PLAIN memo run with
+     * Whether the run produced a changed value. A PLAIN memo run with
      * `changed: false` was pure waste — the equality cutoff stopped it from
-     * notifying anyone; an effect run with `changed: false` computed without
-     * firing its effect phase. Summed as `wastedMs` in costs() (plain,
-     * non-held runs only — see `phase`).
+     * notifying anyone. Effects run with `_equals: false` in core (their
+     * effect phase re-fires on every recompute), so the engine derives this
+     * fact itself: an effect run whose compute output is identical to the
+     * previous run's reports `changed: false` — the phase re-fired with the
+     * same input, pure waste. Side-effect-only computes (`undefined` output)
+     * are exempt: identity of `undefined` proves nothing about their work.
+     * Summed as `wastedMs` in costs() (plain, non-held runs only — see
+     * `phase`).
      */
     changed: boolean;
     /**

package/dist/types/core/constants.d.ts

@@ -51,6 +51,60 @@ export declare const CONFIG_CHILD_COMPANIONS: number;
  * moved into the cold extension (§12), and an unconditional `_x` deref per
  * marked node measurably taxed the propagation hot path (diamond -22%). */
 export declare const CONFIG_FW_CHILDREN: number;
+/** Authoritative-view reader (`until()`): while this node computes, reads
+ * dodge active optimistic OVERRIDES only — the predicate must observe
+ * arriving truth, never the caller's own tentative writes (which would
+ * trivially satisfy it). Everything else reads normally, INCLUDING
+ * transition-staged `_pendingValue`: staged data is authoritative (optimism
+ * lives only in override slots), and a hold that refused staged reads would
+ * deadlock on data the open transaction itself is holding (a refresh the
+ * action issued lands staged and cannot commit until the hold releases).
+ * read() checks the bit on the reading computation (`context`) directly — no
+ * ambient flag — so a shared computed the predicate pulls recomputes as
+ * itself (no bit) under the normal view, and its cache never forks. */
+export declare const CONFIG_AUTHORITATIVE_READ: number;
+/** Sticky mark: an authoritative-view reader read this node PAST an active
+ * override. The ack shape — an authoritative arrival EQUAL to the override —
+ * rides paths that are deliberately silent under A17 (every ordinary reader
+ * sees the override, so an equal landing changes nothing for them). A marked
+ * node notifies those readers on such paths anyway, so the landed truth is
+ * seen without re-firing ordinary subscribers. Never cleared — only nodes an
+ * until() predicate observed mid-override pay. */
+export declare const CONFIG_AUTHORITATIVE_OBSERVED: number;
+/** Promise-delivery effect (resolve()/until()): commits its computed value
+ * directly even when recomputing under its own held transition. These
+ * effects deliver applies on a microtask (#2930) instead of the stashed
+ * effect queues, so the value must ride the same immediate schedule — a
+ * staged value with an immediate apply delivers stale state (resolve) or
+ * deadlocks the hold (until). Safe because the node is a private leaf: no
+ * subscriber reads an effect's value, only its own apply does. */
+export declare const CONFIG_DIRECT_COMMIT: number;
+/** Fresh-pull reader (awaitable `refresh()`'s waiter effect): a read of a
+ * dirty source recomputes it inline even when the height gate defers to the
+ * flush. Closes the same-flush ordering race where a waiter created
+ * alongside a refresh() mark read the PRE-re-ask value as settled and
+ * delivered stale; with the pull, the waiter either parks on the re-ask's
+ * pending window (async — woken by the settle walk, which runs on every
+ * landing including equal-value ones) or serves its sync answer. resolve()
+ * deliberately keeps that race — its contract is "first settled value"
+ * (#2930), not "next quiescent state". */
+export declare const CONFIG_FRESH_READ: number;
+/** HELD truth (#3164): this node's staged `_pendingValue` is confirming
+ * truth riding a transaction that retains optimism, revealed only at that
+ * transaction's settle. Two arming sites, one meaning: the store fold
+ * (a landing staged into the retaining transaction) and until()'s
+ * flip-entanglement (a foreign carrier's staged write, stolen when it
+ * flipped the awaited predicate truthy). Until the reveal, ordinary
+ * readers — lane and speculative recomputes included — keep committed:
+ * the staging notified subscribers as a plain write, so without the mask
+ * a mid-hold recompute composes live optimism with the confirming truth,
+ * a frame no timeline contains (GabbeV's union tear). Authoritative
+ * readers (until()'s predicate) and latest() tunnel through — the
+ * exemption that keeps holds deadlock-free. Override-covered nodes never
+ * arm: the override is their display and its revert their notification
+ * (A17). Cleared at commit (the commit IS the reveal); subscribers masked
+ * during the hold are woken by finalizePureQueue's post-revert pass. */
+export declare const CONFIG_HELD_TRUTH: number;
 export declare const STATUS_NONE = 0;
 export declare const STATUS_PENDING: number;
 export declare const STATUS_ERROR: number;

package/dist/types/core/core.d.ts

@@ -1,4 +1,3 @@
-import { type Refreshable } from "./constants.js";
 import { type OptimisticLane } from "./lanes.js";
 import type { Computed, FirewallSignal, NodeExtension, NodeOptions, Owner, Signal } from "./types.js";
 export declare const PRIMITIVE_IN_FORBIDDEN_SCOPE_MESSAGE = "[PRIMITIVE_IN_FORBIDDEN_SCOPE] Cannot create reactive primitives inside createTrackedEffect or owner-backed onSettled";
@@ -107,6 +106,19 @@ export declare const READ_SLOW: unique symbol;
  * snapshot / transition / lane / dev-strictRead state all take the full
  * resolution. Anything slow returns READ_SLOW; the caller then calls read().
  */
+/**
+ * Wake only authoritative-view readers (until() predicates) subscribed to `el`.
+ * The A17-silent ack paths — an authoritative arrival equal to the active
+ * override — use this so the predicate re-evaluates without re-firing
+ * ordinary subscribers whose visible (override) value did not change.
+ * Pay-for-use: reached through GlobalQueue._notifyAuthoritativeObservers,
+ * installed at first until() call — apps that never use until() shake it.
+ */
+export declare function notifyAuthoritativeObservers(el: Signal<any> | Computed<any>): void;
+/** Installs the until() machinery hook. Idempotent; called by until() before
+ * any authoritative-view read happens (same late-binding contract as the
+ * optimistic engine). */
+export declare function installAuthoritativeRead(): void;
 export declare function readNodeFast<T>(el: Signal<T>): T | typeof READ_SLOW;
 export declare function read<T>(el: Signal<T> | Computed<T>): T;
 /**
@@ -155,23 +167,10 @@ export declare function setMemo<T>(el: Computed<T>, v: T | ((prev: T) => T)): T;
 export declare function runWithOwner<T>(owner: Owner | null, fn: () => T): T;
 export declare function staleValues<T>(fn: () => T, set?: boolean): T;
 /**
- * Invalidates one reactive source, forcing it to re-execute even if its inputs
- * haven't changed.
- *
- * Pass either a Solid-created accessor or a projected store created from
- * `createStore(fn, ...)` / `createProjection(...)`. `refresh()` is a
- * write-like invalidation operation: it does not read the target's value, and
- * refreshing a plain signal accessor is a no-op.
- *
- * Use it to invalidate cached async values (e.g. force a re-fetch) without
- * tearing the consumer down.
- *
- * @example
- * ```ts
- * const user = createMemo(async () => fetch(`/users/${id()}`).then(r => r.json()));
- *
- * // Re-fetch on demand
- * <button onClick={() => refresh(user)}>Reload</button>
- * ```
+ * Core marking half of `refresh()` (the public wrapper lives in signals.ts —
+ * it validates the target, marks through here, then builds the quiescence
+ * promise on the resolve()/until() effect machinery). Flags the node's next
+ * recompute as a quiet re-ask and schedules it; no-ops for non-derived or
+ * disposed targets and for same-tick manual writes.
  */
-export declare function refresh<T>(target: Refreshable<T>): void;
+export declare function markRefresh(node: Computed<any>): void;

package/dist/types/core/error.d.ts

@@ -39,6 +39,15 @@ export declare class StatusError extends Error {
 }
 /** Return the user's error from an internal status wrapper. */
 export declare function unwrapStatusError(error: unknown): unknown;
+/**
+ * Rejection value of `until(fn, { timeout })` when the predicate does not turn
+ * truthy within the window. Inside an `action()`, the rejection is thrown back
+ * in at the `yield` point — catchable there, or the action fails and its
+ * optimistic state reverts.
+ */
+export declare class TimeoutError extends Error {
+    constructor(message?: string);
+}
 export declare class NoOwnerError extends Error {
     constructor();
 }

package/dist/types/core/index.d.ts

@@ -1,5 +1,5 @@
-export { ContextNotFoundError, NoOwnerError, NotReadyError } from "./error.js";
-export { isEqual, untrack, runWithOwner, computed, signal, read, setSignal, setMemo, suppressComputedRecompute, optimisticSignal, optimisticComputed, refresh, staleValues, setSnapshotCapture, markSnapshotScope, releaseSnapshotScope, clearSnapshots } from "./core.js";
+export { ContextNotFoundError, NoOwnerError, NotReadyError, TimeoutError } from "./error.js";
+export { isEqual, untrack, runWithOwner, computed, signal, read, setSignal, setMemo, suppressComputedRecompute, optimisticSignal, optimisticComputed, installAuthoritativeRead, markRefresh, staleValues, setSnapshotCapture, markSnapshotScope, releaseSnapshotScope, clearSnapshots } from "./core.js";
 export { enableExternalSource, _resetExternalSourceConfig, type ExternalSourceFactory, type ExternalSource, type ExternalSourceConfig } from "./external.js";
 export { createOwner, createRoot, dispose, getNextChildId, getObserver, getOwner, isDisposed, cleanup, peekNextChildId } from "./owner.js";
 export { createContext, getContext, setContext, type Context, type ContextRecord } from "./context.js";

package/dist/types/core/scheduler.d.ts

@@ -40,6 +40,24 @@ export interface Transition {
     _done: boolean | Transition;
     _gatedSubs: Set<Computed<any>>;
 }
+/**
+ * Flip-entanglement (#3164 follow-up): `until()` is a declaration of
+ * relatedness — the predicate names the condition that confirms the awaiting
+ * transaction. When the predicate settles truthy, every live foreign
+ * transition whose staged write it read IS the confirming event by the
+ * user's own definition, so it merges into the awaiting transaction and
+ * reveals at the joint settle — the cross-primitive twin of the family fold
+ * (a landing on an optimism-carrying family joins the retaining
+ * transaction). Non-flipping updates never pass through here: falsy
+ * evaluations don't entangle, so unrelated traffic on the watched sources
+ * reveals freely on its own schedule.
+ *
+ * Runs inside the predicate's compute (pure phase) — the confirming
+ * transition's stamps are still live and its commit decision hasn't run, so
+ * the merge lands before any reveal. Only the tree-shaken graphs that call
+ * `until()` retain this.
+ */
+export declare function entangleConfirmingTransitions(obs: Computed<any>, target: Transition): void;
 export declare function schedule(): void;
 /**
  * Permanently halts the reactive system. Called when a user error escapes
@@ -112,6 +130,10 @@ export declare class GlobalQueue extends Queue {
     static _laneReadsCommitted: ((el: OptimisticNode, owner: OptimisticNode, c: Computed<any>) => boolean) | null;
     static _recomputeLane: ((el: Computed<any>, own: boolean) => OptimisticLane | null | false) | null;
     static _laneAsyncPending: ((el: Computed<any>) => void) | null;
+    /** Authoritative-view reader wakeup (until()): installed at first until() call.
+     * Call sites are gated by CONFIG_AUTHORITATIVE_OBSERVED, which only until()'s
+     * carve-out read can set, so `!` invocations are safe once the gate holds. */
+    static _notifyAuthoritativeObservers: ((el: Signal<any> | Computed<any>) => void) | null;
     static _laneAsyncSettled: ((el: Computed<any>) => void) | null;
     static _trackOptimisticStore: ((store: any) => void) | null;
     flush(): void;
@@ -190,3 +212,15 @@ export declare function flush<T>(fn: () => T): T;
 export declare function currentTransition(transition: Transition): Transition;
 export declare function setActiveTransition(transition: Transition | null): void;
 export declare function runInTransition<T>(transition: Transition, fn: () => T): T;
+/** Run `fn` with `transition` as BOTH the ambient transaction and the
+ * registration batch, restoring both after. runInTransition alone is not
+ * enough for code that WRITES on behalf of a transaction from inside someone
+ * else's window (optimistic replay re-arming a still-open action's edits
+ * during a landing commit, #3123): registrations route through the queue's
+ * batch pointer, and a bare activeTransition swap leaves them in the ambient
+ * batch — a plain batch "completes" at the next flush and reverts optimistic
+ * registrations that were supposed to live with the transaction.
+ * initTransition is the wrong tool here: it MERGES the currently ambient
+ * transaction into the target, entangling whatever the interrupted window
+ * belonged to. */
+export declare function runAsTransitionBatch<T>(transition: Transition, fn: () => T): T;

package/dist/types/core/types.d.ts

@@ -27,6 +27,11 @@ export interface NodeOptions<T> {
     ownedWrite?: boolean;
     /** Exclude this signal from snapshot capture (internal — not part of public API) */
     _noSnapshot?: boolean;
+    /** Extra CONFIG_* bits OR'd into the node's config at creation (internal —
+     * not part of public API). Used by resolve()/until() for
+     * CONFIG_DIRECT_COMMIT / CONFIG_AUTHORITATIVE_READ, keeping the per-flag
+     * option arms out of the core creation path. */
+    _extraConfig?: number;
     unobserved?: () => void;
     lazy?: boolean;
     sync?: boolean;
@@ -73,6 +78,13 @@ export interface NodeExtension {
      */
     _affectsCount: number;
     _inFlight: PromiseLike<any> | AsyncIterable<any> | null;
+    /** Cancellation for the CURRENT iterator flight (#3122): closes the
+     * iterator (`it.return()`), idempotent. Fired at the sites that release
+     * `_inFlight` so a superseded stream stops at supersede time — its owner
+     * cleanup registration may ride the zombie-disposal channel, which a held
+     * transition defers until the SUPERSEDING flight settles. Null for plain
+     * promise flights (no cancellation hook exists). */
+    _flightTeardown: (() => void) | null;
     _error: unknown;
     _blocked: boolean | undefined;
     _pendingSources: Set<Computed<any>> | undefined;

package/dist/types/index.d.ts

@@ -1,9 +1,9 @@
-export { $REFRESH, ContextNotFoundError, NoOwnerError, NotReadyError, action, createContext, createOwner, createRoot, runWithOwner, flush, getNextChildId, peekNextChildId, getContext, setContext, getOwner, isDisposed, getObserver, isEqual, untrack, isPending, latest, refresh, SUPPORTS_PROXY, setSnapshotCapture, markSnapshotScope, releaseSnapshotScope, clearSnapshots, enforceLoadingBoundary, enableExternalSource, resetErrorHalt } from "./core/index.js";
+export { $REFRESH, ContextNotFoundError, NoOwnerError, NotReadyError, TimeoutError, action, createContext, createOwner, createRoot, runWithOwner, flush, getNextChildId, peekNextChildId, getContext, setContext, getOwner, isDisposed, getObserver, isEqual, untrack, isPending, latest, SUPPORTS_PROXY, setSnapshotCapture, markSnapshotScope, releaseSnapshotScope, clearSnapshots, enforceLoadingBoundary, enableExternalSource, resetErrorHalt } from "./core/index.js";
 import { type Dev } from "./core/index.js";
 export declare const DEV: Dev | undefined;
 export type { Owner, Context, ContextRecord, IQueue, ExternalSourceFactory, ExternalSource, ExternalSourceConfig, Refreshable, Dev, DevHooks, DiagnosticCapture, DiagnosticCode, DiagnosticEvent, DiagnosticKind, Diagnostics, DiagnosticSeverity } from "./core/index.js";
-export { createSignal, createMemo, createEffect, createRenderEffect, createTrackedEffect, createReaction, createOptimistic, resolve, onSettled, onCleanup } from "./signals.js";
-export type { Accessor, SourceAccessor, Setter, Signal, ComputeFunction, EffectFunction, EffectBundle, EffectOptions, SignalOptions, MemoOptions, NoInfer } from "./signals.js";
+export { createSignal, createMemo, createEffect, createRenderEffect, createTrackedEffect, createReaction, createOptimistic, refresh, resolve, until, onSettled, onCleanup } from "./signals.js";
+export type { Truthy, UntilOptions, Accessor, SourceAccessor, Setter, Signal, ComputeFunction, EffectFunction, EffectBundle, EffectOptions, SignalOptions, MemoOptions, NoInfer } from "./signals.js";
 export { affects } from "./affects.js";
 export { mapArray, repeat, type Maybe } from "./map.js";
 export * from "./store/index.js";