@solidjs/signals 2.0.0-rc.1 → 2.0.0-rc.11

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

@@ -27,6 +27,15 @@ 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;
+    /** Observe tiers: framework plumbing — no name, no owner-path segment, no
+     * attribution records of its own; its children stay observed (internal —
+     * not part of public API; see CONFIG_PLUMBING). */
+    _plumbing?: boolean;
     unobserved?: () => void;
     lazy?: boolean;
     sync?: boolean;
@@ -41,19 +50,19 @@ export interface NodeOptions<T> {
      */
     loadingValue?: T;
 }
-export interface RawSignal<T> {
-    _subs: Link | null;
-    _subsTail: Link | null;
-    _value: T;
-    _snapshotValue?: any;
-    _name?: string;
-    _equals: false | ((a: T, b: T) => boolean);
-    _config: number;
-    _unobserved?: () => void;
-    _time: number;
-    _transition: Transition | null;
-    _pendingValue: T | typeof NOT_PENDING;
-    _overrideValue?: T | typeof NOT_PENDING;
+/**
+ * Cold node extension (stage-3 §12): optional machinery that most nodes
+ * never touch lives one hop away so the CORE node literal stays under V8's
+ * in-object property boundary (~39 fields measured: past it, every literal
+ * allocation spills to an out-of-object backing store and creation cost
+ * roughly quadruples — the create0to1 cliff). Allocated lazily by `ext()`
+ * on first installer write; ONE shape shared by signals and computeds so
+ * `_x` access stays monomorphic. Presence bits on `_config`
+ * (CONFIG_OPTIMISTIC / HAS_COMPANIONS / HAS_LANE / HAS_SNAPSHOT) remain the
+ * hot-path gates — a bit says "consult _x", never the reverse.
+ */
+export interface NodeExtension {
+    _overrideValue: unknown | typeof NOT_PENDING;
     /**
      * The transaction that owns the active override (stamped at optimistic
      * write, cleared at settle). Ownership must live on the node: a lane's
@@ -62,25 +71,99 @@ export interface RawSignal<T> {
      * revert another action's live override. Node-level sibling of the store
      * layer's STORE_OPTIMISTIC_OWNERS stamps (#2899). `null` = ambient write.
      */
-    _overrideOwner?: Transition | null;
-    _optimisticLane?: OptimisticLane;
-    _pendingSignal?: Signal<boolean>;
-    _latestValueComputed?: Computed<T>;
-    _parentSource?: Signal<any> | Computed<any>;
+    _overrideOwner: Transition | null | undefined;
+    /** `clock` at the active override's write. A sync recompute in the same
+     * tick derives from inputs that predate the override and does not
+     * supersede it (A18 supersession ordering, #3331). */
+    _overrideTime: number;
+    /** A28: the staged value the last flush left on a HELD node that has since
+     * been rewritten (latest() keeps answering with it); NOT_PENDING otherwise. */
+    _flushedStaged: unknown;
+    /** Provenance of the active override's write: the scheduler's `origin` (the
+     * asking action's invocation sequence; 0 = mainline). An arriving answer
+     * whose flight an older action issued asked a question the override has
+     * since changed: it holds to commit instead of superseding (A18
+     * supersession provenance, #3331). */
+    _overrideStamp: number;
+    _optimisticLane: OptimisticLane | undefined;
+    _pendingSignal: Signal<boolean> | undefined;
+    _latestValueComputed: Computed<any> | undefined;
+    _parentSource: Signal<any> | Computed<any> | undefined;
     /**
      * Live `affects()` marks on this node (refcount). Non-zero is declared
-     * motion: the node — and, via the verdict layer's dep-graph coverage walk,
-     * everything derived from it — reads pending regardless of graph state,
-     * until every declaring transaction settles/reverts and releases its mark.
-     * This count is the mark's ONLY graph state: the dedicated channel stores
-     * nothing downstream and never touches status flags, errors, or pending
-     * sources.
+     * motion — see affects(); the count is the mark's only graph state.
+     */
+    _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;
+    _notifyStatus: ((status?: number, error?: any) => void) | undefined;
+    /** Question-scoped re-ask classification of the current pending window
+     * (see the former Computed._x?._reask doc): set by recompute from
+     * REACTIVE_REASK, cleared on landing; meaningless while not pending. */
+    _reask: boolean;
+    _child: FirewallSignal<any> | null;
+    _unobserved: (() => void) | undefined;
+    _snapshotValue: any;
+    /** Zombie staging (staged disposal): a recompute of an owner that HAS
+     * children/disposal parks them here until the flush commits (or a
+     * transition reverts). Childless nodes — the common case — never write
+     * these. */
+    _pendingDisposal: Disposable | Disposable[] | null;
+    _pendingFirstChild: Owner | null;
+    /** #3038: the firewall children that actually carry isPending()/latest()
+     * companions. The post-recompute companion snap iterates THIS set —
+     * O(companions asked for) — never the full `_child` chain (one entry per
+     * materialized leaf). Populated at companion creation; entries live as
+     * long as their companions (which are permanent once created). */
+    _companionChildren: Set<FirewallSignal<any>> | undefined;
+}
+export interface RawSignal<T> {
+    _subs: Link | null;
+    _subsTail: Link | null;
+    _value: T;
+    /**
+     * Observe-tier label (`name` option, or the node kind: `signal`,
+     * `computed`, `effect`…). A slot in the observe/dev literals — never a
+     * post-construction write — and absent from the prod literals entirely.
      */
-    _affectsCount?: number;
+    _name?: string;
+    /**
+     * Observe-tier: the owner in scope when a user-facing signal was created
+     * (`registerGraph`), so diagnostics about the signal get an owner path.
+     * A slot in the observe/dev `signal()` literal; absent from prod.
+     */
+    _owner?: Owner | null;
+    _equals: false | ((a: T, b: T) => boolean);
+    _config: number;
+    _time: number;
+    /** IN CORE, not the extension (stage-3 §12c): consulted on EVERY write
+     * (setSignal's transition-init check) and on recompute scheduling — the
+     * per-write extension chase measurably taxed propagation chains. */
+    _transition: Transition | null;
+    /** Notify-epoch stamp of the last subscriber walk (§12d). A re-write to an
+     * already-staged node whose stamp still equals the global epoch skips the
+     * whole walk — marking is idempotent, and the epoch bumps on every
+     * recompute and new subscriber edge (either can invalidate the skip). */
+    _notifiedAt: number;
+    _pendingValue: T | typeof NOT_PENDING;
+    /** Cold extension — see NodeExtension. */
+    _x: NodeExtension | null;
 }
 export interface FirewallSignal<T> extends RawSignal<T> {
     _firewall: Computed<any>;
+    /** Doubly-linked child chain on the firewall's extension (`_x._child` is
+     * the head): released leaves unlink in O(1) (#3351). */
     _nextChild: FirewallSignal<unknown> | null;
+    _prevChild: FirewallSignal<unknown> | null;
 }
 export type Signal<T> = RawSignal<T> | FirewallSignal<T>;
 export interface Owner {
@@ -97,8 +180,14 @@ export interface Owner {
     _firstChild: Owner | null;
     _nextSibling: Owner | null;
     _prevSibling: Owner | null;
-    _pendingDisposal: Disposable | Disposable[] | null;
-    _pendingFirstChild: Owner | null;
+    /** Cold extension — see NodeExtension (owners use the zombie-pair slots). */
+    _x: NodeExtension | null;
+    /**
+     * Observe-tier label: the `name` option, the node kind (`computed`,
+     * `effect`…), or the component label the rendering layer writes on a root
+     * (`<App>`). A slot in the observe/dev literals; absent from prod.
+     */
+    _name?: string;
 }
 export interface Computed<T> extends RawSignal<T>, Owner {
     _deps: Link | null;
@@ -106,26 +195,19 @@ export interface Computed<T> extends RawSignal<T>, Owner {
     /** Recompute-pass counter; bumped when dep revalidation starts. */
     _depGen: number;
     _flags: number;
-    _blocked?: boolean;
-    _pendingSources?: Set<Computed<any>>;
-    _error?: unknown;
     _statusFlags: number;
     _height: number;
     _nextHeap: Computed<any> | undefined;
     _prevHeap: Computed<any>;
     _fn: (prev?: T) => T;
-    _inFlight: PromiseLike<T> | AsyncIterable<T> | null;
-    _child: FirewallSignal<any> | null;
-    _notifyStatus?: (status?: number, error?: any) => void;
     /**
-     * Question-scoped pending classification of the node's CURRENT pending
-     * window: `true` means the in-flight recompute is a re-ask of the same
-     * question (refresh/poll/confirm — no tracked input changed value), so the
-     * shown answer still answers the question and the node reads NOT pending.
-     * Set by `recompute` from `REACTIVE_REASK`, cleared on landing
-     * (`clearStatus`). Meaningless while not STATUS_PENDING.
+     * Clock tick at which REACTIVE_MANUAL_WRITE was last applied
+     * (`suppressComputedRecompute`). Lets `refresh()` distinguish a same-tick
+     * manual write (which wins over the refresh, #2692) from a mask carried
+     * across ticks by a transaction (which an explicit refresh lifts, #3026).
+     * Only meaningful while REACTIVE_MANUAL_WRITE is set.
      */
-    _reask: boolean;
+    _manualWriteTime?: number;
     /**
      * True while a `loadingValue` node's first real answer hasn't landed: the
      * node was born committed (commit #0 = the loading value) and `handleAsync`
@@ -137,7 +219,8 @@ export interface Computed<T> extends RawSignal<T>, Owner {
      * return, sync-resolved promise, first iterator yield, async settle); a
      * real error leaves it set — errors answer reads but don't enter the value
      * lineage, so a retry serves the loading value again. Once cleared, normal
-     * pending/refetch semantics apply forever.
+     * pending/refetch semantics apply forever. (Stays in CORE: written
+     * unconditionally by recompute and every commit.)
      */
     _loading: boolean;
 }

package/dist/types/index.d.ts

@@ -1,9 +1,22 @@
-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";
-import { type Dev } 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, configureClientErrors, ROOT_ERROR_HOOK } from "./core/index.js";
+/**
+ * @internal The dev console footer seam — registered by `solid-js`, which
+ * owns the repair skill the footer points at. Not part of `DEV`; a no-op
+ * outside dev builds.
+ */
+export { setConsoleFooter } from "./core/index.js";
+import { type Dev, type Observe } from "./core/index.js";
+/**
+ * Observe tier (diagnostics channel, attribution hook slot + interaction
+ * frame): dev and observe builds. The attribution engine itself is the
+ * `@solidjs/signals/attribution` entry.
+ */
+export declare const OBSERVE: Observe | undefined;
+/** Dev tier (devtools hooks, graph traversal, console reporting): dev builds only. */
 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 type { Owner, Context, ContextRecord, IQueue, ExternalSourceFactory, ExternalSource, ExternalSourceConfig, Refreshable, AttributionSlot, ClientErrorContext, ClientErrorHook, ClientErrorsConfig, InteractionRef, NavigationRef, Dev, Observe, ServerObserve, Records, RecordTypes, HostRecordTypes, RecordType, RecordEvent, RecordLive, RecordListener, DevHooks, DiagnosticCapture, DiagnosticCode, DiagnosticEvent, DiagnosticKind, DiagnosticListener, Diagnostics, DiagnosticSeverity, DiagnosticSubject } from "./core/index.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";

package/dist/types/map.d.ts

@@ -47,6 +47,8 @@ export declare function mapArray<Item, MappedItem>(list: Accessor<Maybe<readonly
     fallback?: Accessor<any>;
     name?: string;
 }): Accessor<MappedItem[]>;
+/** @internal */
+export declare function __smallMoveHits(): number;
 /**
  * Reactively renders a callback `count` times, reusing previously-rendered
  * entries when only the count changes. Underlying helper for `<Repeat>`.

package/dist/types/signals.d.ts

@@ -26,6 +26,12 @@ import type { Disposable, Refreshable } from "./core/index.js";
  * Cannot be used inside `createTrackedEffect` or `onSettled` — return a
  * cleanup function from the callback body instead.
  *
+ * Cleanups run in unwind order: an owner's children are disposed before its
+ * own cleanups, and within one owner later registrations run before earlier
+ * ones. In production a component body shares its enclosing owner, so
+ * register cleanup before creating children when the order between them
+ * matters.
+ *
  * @example
  * ```ts
  * // Library shape: thread a resource's disposal into a *captured* owner
@@ -169,6 +175,13 @@ export interface MemoOptions<T> {
      * the full semantics. No-op outside hydration.
      */
     transparent?: boolean;
+    /**
+     * @internal Framework plumbing (the `solid-js/refresh` HMR memo): in the
+     * observe tiers the memo has no name, is no owner-path segment, and the
+     * attribution engine records nothing about it, while what it owns stays
+     * observed. Not part of the public API.
+     */
+    _plumbing?: boolean;
     /**
      * Custom equality function, or `false` to always notify subscribers.
      * Defaults to reference equality (`isEqual`). Pass a comparator (e.g.
@@ -251,10 +264,14 @@ export type NoInfer<T extends any> = [T][T extends any ? 0 : never];
  *
  * @example
  * ```ts
- * // Writable memo: starts as `fn()`, can be locally overwritten by setter.
+ * // Writable memo: derives from `fn()` and can be written like a signal.
  * const [user, setUser] = createSignal(() => fetchUser(userId()));
  *
- * setUser({ ...user(), name: "Alice" }); // optimistic local edit
+ * // Within the frame the write wins over a same-tick recompute; the next
+ * // change to `userId` re-derives (the compute receives the written value
+ * // as `prev`). While a transaction holds a re-derived value, a write from
+ * // outside it does not replace that derivation — it becomes its `prev`.
+ * setUser({ ...user(), name: "Alice" });
  * ```
  *
  * @description https://docs.solidjs.com/reference/basic-reactivity/create-signal
@@ -365,17 +382,6 @@ export declare function createMemo<T>(compute: ComputeFunction<undefined | NoInf
  * @description https://docs.solidjs.com/reference/basic-reactivity/create-effect
  */
 export declare function createEffect<T>(compute: ComputeFunction<undefined | NoInfer<T>, T>, effectFn: EffectFunction<NoInfer<T>, T> | EffectBundle<NoInfer<T>, T>, options?: EffectOptions): void;
-/**
- * @deprecated `createEffect(compute)` (single argument) is no longer supported.
- * Pass a separate effect function as the second argument:
- * `createEffect(compute, effect)`. See [MISSING_EFFECT_FN].
- *
- * - For a side effect that reacts to changes, split the work:
- *   `createEffect(() => signal(), value => doWork(value))`.
- * - For a derived value, use `createMemo(() => signal())`.
- * - For a one-shot side effect at construction time, just call the function.
- */
-export declare function createEffect<T>(compute: ComputeFunction<undefined | NoInfer<T>, T>): never;
 /**
  * Creates a reactive computation that runs during the render phase as DOM elements
  * are created and updated but not necessarily connected.
@@ -410,6 +416,16 @@ export declare function createRenderEffect<T>(compute: ComputeFunction<undefined
  * Creates a tracked reactive effect where dependency tracking and side effects happen
  * in the same scope.
  *
+ * @deprecated Do not use in new code. For a side effect that follows reactive
+ * state, use `createEffect(compute, effect)` — it separates tracking from the
+ * side effect, knows its dependencies before it runs, and participates in
+ * async and transitions. For one-time DOM work after render (measuring,
+ * attaching third-party widgets to a ref), use `onSettled`. Tracking from
+ * inside the effect phase — the only thing this primitive adds — is retained
+ * solely to ease 1.x migration: it runs beside user-effect callbacks after
+ * values commit, never holds a transition, and cannot observe a write staged
+ * earlier in the same flush by a signal it has not read yet.
+ *
  * WARNING: Because tracking and effects happen in the same scope, this primitive
  * may run multiple times for a single change or show tearing (reading inconsistent
  * state). Use only when dynamic subscription patterns require same-scope tracking.
@@ -491,6 +507,122 @@ export declare function createReaction(effectFn: EffectFunction<undefined> | Eff
  * @param fn a reactive expression to resolve
  */
 export declare function resolve<T>(fn: () => T): Promise<T>;
+/**
+ * Invalidates one reactive source, forcing it to re-execute even if its inputs
+ * haven't changed, and returns a promise for the target's NEXT QUIESCENT
+ * STATE — the re-ask (and anything that supersedes it) has settled.
+ *
+ * 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 that resolves immediately.
+ *
+ * The returned promise is safe to ignore (fire-and-forget refresh is
+ * unchanged, and a failed refetch will not surface an unhandled rejection).
+ * Awaiting it gives imperative flows the settle point without a reactive
+ * read:
+ * - Accessor targets resolve with the settled value; store targets resolve
+ *   with the store node passed (reads through it are fresh after the await).
+ * - A failed re-ask rejects with the error (inside an action's generator,
+ *   `yield refresh(x)` throws back at the yield point and the action reverts
+ *   like any other failure).
+ * - Semantics are quiescence, not flight identity: if another refresh (or
+ *   any invalidation) supersedes this one mid-flight, the promise waits for
+ *   — and delivers — whatever finally lands.
+ * - Inside an action, truth landing into the held transaction is STAGED;
+ *   the promise still settles then (matching `resolve()`/`until()`, #2930)
+ *   and delivers the staged value — the caller's own optimistic override is
+ *   never the delivered value.
+ * - The re-ask itself stays verdict-quiet exactly as before: `isPending`
+ *   does not flip for a bare refresh (pair with `affects()` for a visible
+ *   pending window).
+ *
+ * @example
+ * ```ts
+ * const user = createMemo(async () => fetch(`/users/${id()}`).then(r => r.json()));
+ *
+ * // Fire-and-forget re-fetch
+ * <button onClick={() => refresh(user)}>Reload</button>;
+ *
+ * // Imperative settle point
+ * const fresh = await refresh(user);
+ * ```
+ */
+export declare function refresh<T>(target: Refreshable<T>): Promise<T extends (...args: any) => infer V ? V : T>;
+/** Falsy values a truthy predicate result is narrowed against. */
+export type Truthy<T> = Exclude<T, false | 0 | 0n | "" | null | undefined>;
+export interface UntilOptions {
+    /** Reject with `TimeoutError` if the predicate has not turned truthy within
+     * this many milliseconds. Strongly recommended when the confirming truth
+     * arrives over a transport that can drop (sockets, subscriptions). */
+    timeout?: number;
+    /** Reject with `signal.reason` on abort. */
+    signal?: AbortSignal;
+}
+/**
+ * Awaits a reactive predicate and resolves the first time it settles *truthy*,
+ * with that (narrowed) value. Falsy results and pending async reads both mean
+ * "not yet": the subscription stays live and re-evaluates as sources change.
+ * If the predicate settles with an error — a throw, or an async source that
+ * rejects — the promise rejects with it, as do timeout and abort.
+ *
+ * Where {@link resolve} answers "what is this value" (first settled value,
+ * whatever it is), `until` answers "when does the world confirm this
+ * condition". The difference matters inside an `action()`: `yield until(...)`
+ * holds the action's transaction — and any optimistic state riding it — open
+ * until the condition is independently true.
+ *
+ * To make that sound, `until`'s predicate reads the AUTHORITATIVE view — and
+ * this is the one read-semantics difference from `resolve`, which reads the
+ * normal (transaction's own) view where overrides are visible:
+ *
+ * - **Optimistic overrides are invisible** to the predicate. Your own
+ *   tentative write can never satisfy your own ack, even on the
+ *   single-primitive shape where the optimistic store IS the live-fed store.
+ *   (Derived computeds serve their normal cached values — express the
+ *   condition over sources of truth, not derived views of the overlay.)
+ * - **Everything else reads normally, including uncommitted transition-staged
+ *   data.** Real data is real wherever it currently lives. This is
+ *   load-bearing, not a loophole: truth that arrives *into* the open
+ *   transaction (a `refresh()` this action issued, an entangled landing)
+ *   stages and cannot commit until the hold releases — a predicate that
+ *   refused staged reads would deadlock on the very data it is waiting for.
+ *
+ * This is the acknowledgment mechanism for mutations confirmed on a live data
+ * channel (sockets, subscriptions, live queries) rather than by the mutation's
+ * own response: correlate by a client-generated id or version in the predicate,
+ * and let truth arrive however it arrives — push, refetch, or another tab.
+ *
+ * Failure composes with action semantics: a rejection is thrown back into the
+ * generator at the `yield` point — catchable there, or the action fails and
+ * its optimistic state reverts.
+ *
+ * Must be called *outside* a tracking scope.
+ *
+ * Inside an action, call it from a step: after an `await`, put a bare `yield`
+ * before `yield until(...)`. The runtime cannot hook an async generator's
+ * `await` continuation, so the `until(...)` expression — which CREATES the
+ * predicate's reader — would otherwise run outside the transaction; created
+ * there it is born held (A29) and replays only at the commit its own promise
+ * holds open (#3482). See {@link action}.
+ *
+ * @example
+ * ```ts
+ * const send = action(async function* (text: string) {
+ *   const clientId = crypto.randomUUID();
+ *   setMessages(m => { m.push({ clientId, text, pending: true }); }); // optimistic
+ *   await socket.send({ clientId, text }); // fire-and-forget transport
+ *   yield; // re-enter the transaction after the await
+ *   // Hold until the live source echoes the write (authoritative view —
+ *   // the optimistic row above cannot satisfy this):
+ *   yield until(() => messages.some(m => m.clientId === clientId), { timeout: 10_000 });
+ * });
+ * ```
+ *
+ * @param fn a reactive predicate over authoritative state
+ * @param options optional `timeout` (ms) and abort `signal`
+ */
+export declare function until<T>(fn: () => T, options?: UntilOptions): Promise<Truthy<T>>;
 /**
  * Creates an optimistic signal that can be used to optimistically update a value
  * and then revert it back to the previous value at end of transition.

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

@@ -1,16 +1,17 @@
 export type { Store, StoreReturn, ProjectionStoreReturn, StoreSetter, StoreNode, StoreOptions, ProjectionOptions, NotWrappable, SolidStore } from "./store.js";
 export type { Merge, Omit } from "./utils.js";
-export { isWrappable, $TRACK, $PROXY, $TARGET } from "./store.js";
+export { isWrappable, $TRACK, $PROXY, $TARGET, $RECORD } from "./store.js";
+export { mergeSources, mergeView, viewOf, omitView, sourceKeys, sourceHas, sourceGet, hasStaticKeys, isStatic, resolvedTable, OmitView, MergeView, SOURCE_PLAIN, SOURCE_OMIT, SOURCE_PROXY, SOURCE_MEMO, SOURCE_MERGE, sourceOwners } from "./utils.js";
+export type { SourceKind } from "./utils.js";
 import type { NoFn, ProjectionOptions, Store, StoreOptions, StoreSetter } from "./store.js";
 import type { Refreshable } from "../core/index.js";
 export { createProjectionNext as createProjection } from "./next/projection.js";
+export { storeIsShallow, storeHasFamily, storeHasOptimisticFamily } from "./next/store.js";
 export { createOptimisticStoreNext as createOptimisticStore } from "./next/optimistic.js";
-/** Public createStore: plain form `(init, options?)` and derived writable
+/** Public createStore: plain form `(initialValue, options?)` and derived writable
  * form `(fn, seed, options?)`. */
-export declare function createStore<T extends object = {}>(store: NoFn<T> | Store<NoFn<T>>, options?: StoreOptions & {
-    shallow?: boolean;
-}): [get: Store<T>, set: StoreSetter<T>];
-export declare function createStore<T extends object = {}>(fn: (store: T) => void | T | Promise<void | T> | AsyncIterable<void | T>, store: Partial<T> | Store<NoFn<T>>, options?: ProjectionOptions): [get: Refreshable<Store<T>>, set: StoreSetter<T>];
+export declare function createStore<T extends object = {}>(initialValue: NoFn<T> | Store<NoFn<T>>, options?: StoreOptions): [get: Store<T>, set: StoreSetter<T>];
+export declare function createStore<T extends object = {}>(fn: (draft: T) => void | T | Promise<void | T> | AsyncIterable<void | T>, seed: Partial<T> | Store<NoFn<T>>, options?: ProjectionOptions): [get: Refreshable<Store<T>>, set: StoreSetter<T>];
 export declare function reconcile<T extends U, U>(value: T, key?: string | ((item: NonNullable<any>) => any) | null): (state: U) => T;
 export declare function snapshot<T>(value: T): T;
 export declare function deep<T>(value: T): T;

package/dist/types/store/next/optimistic.d.ts

@@ -1,20 +1,25 @@
-import { type NoFn, type ProjectionOptions, type Store, type StoreSetter } from "../store.js";
-import type { StoreNextFamily, StoreNextTarget } from "./target.js";
-export declare function createOptimisticStoreNext<T extends object = {}>(first: T | ((store: T) => void | T | Promise<void | T> | AsyncIterable<void | T>), second?: NoFn<T> | Store<NoFn<T>>, options?: ProjectionOptions): [get: Store<T>, set: StoreSetter<T>];
+import { type Refreshable } from "../../core/index.js";
+import { type Transition } from "../../core/scheduler.js";
+import { type NoFn, type ProjectionOptions, type Store, type StoreOptions, type StoreSetter } from "../store.js";
+import type { StoreNextTarget } from "./target.js";
+/** #3164 fold: a stamped truth is HELD (masked from ordinary readers until
+ * the reveal) only while its transition is live AND retaining optimism —
+ * overrides are what make partial-coverage composition a tear. A plain
+ * async transition carries no overrides, so downstream computes must see
+ * staged values to converge (normal speculation). Resolves merges first:
+ * merge unions optimistic nodes/stores into the target. */
+export declare function transitionHoldsOptimism(transition: Transition): boolean;
+export declare function createOptimisticStoreNext<T extends object = {}>(initialValue: NoFn<T> | Store<NoFn<T>>, options?: StoreOptions): [get: Store<T>, set: StoreSetter<T>];
+export declare function createOptimisticStoreNext<T extends object = {}>(fn: (draft: T) => void | T | Promise<void | T> | AsyncIterable<void | T>, seed: Partial<T> | Store<NoFn<T>>, options?: ProjectionOptions): [get: Refreshable<Store<T>>, set: StoreSetter<T>];
 /** Diff the draft against the current OPTIMISTIC VIEW (committed + active
  * overrides — the same view the draft was seeded from) and emit engine writes
  * for exactly the changed keys. Visible-view diffing keeps no-op writes from
  * entangling lanes (RUL-10 / opt R38). */
 export declare function notifyOptimisticWrites(t: StoreNextTarget, pb: Record<PropertyKey, any>): void;
-/**
- * Landing consumption (RUL-2): fresh authoritative data supersedes every
- * tentative override in the family. Mirrors legacy clearProjectionOverride —
- * drop the override, clear lane/ownership, notify subscribers whose visible
- * value changes (reversion effects go to regular queues via the projection
- * write posture the caller holds).
- */
-export declare function consumeOverridesNext(fam: StoreNextFamily): void;
 /** Optimistic-view composition for snapshot/deep (O1: snapshot is the CURRENT
  * view, lane values included; a fresh copy per call during pending windows —
- * RUL-12). Returns `src` untouched when no override is active on `t`. */
-export declare function optimisticView(t: StoreNextTarget, src: Record<PropertyKey, any>): Record<PropertyKey, any>;
+ * RUL-12). Returns `src` untouched when no override is active on `t`.
+ * Authoritative-view reads (until()'s predicate) skip composition entirely:
+ * the predicate observes authoritative truth, never the caller's tentative
+ * overlay. (Write-side emission callers never run under such a compute.) */
+export declare function optimisticView(t: StoreNextTarget, src: Record<PropertyKey, any>, draft?: boolean): Record<PropertyKey, any>;

package/dist/types/store/next/projection.d.ts

@@ -19,6 +19,9 @@ import { type NoFn, type ProjectionOptions, type Store } from "../store.js";
 export declare function createProjectionNext<T extends object = {}>(fn: (draft: T) => void | T | Promise<void | T> | AsyncIterable<void | T>, seed: Partial<T> | Store<NoFn<T>>, options?: ProjectionOptions): Refreshable<Store<T>>;
 /** Derived writable store (legacy parity): a projection whose public setter
  * masks the recompute for the tick (core R31 — the manual write wins over a
- * same-flush dependency change). */
+ * same-flush dependency change). Across a hold the write is not a proposal:
+ * a leaf another transaction holds as the fold's result re-runs the fold
+ * under it, the write being the draft's prior state (A34 amendment, #3612;
+ * core derivedWrite). */
 export declare function createStoreDerivedNext<T extends object = {}>(fn: (draft: T) => void | T | Promise<void | T> | AsyncIterable<void | T>, seed: Partial<T> | Store<NoFn<T>>, options?: ProjectionOptions): [Refreshable<Store<T>>, (f: (draft: T) => T | void) => void];
-export declare function runProjectionComputedNext<T extends object>(wrappedStore: Store<T>, fn: (draft: T) => void | T | Promise<void | T> | AsyncIterable<void | T>, key: string | ((item: NonNullable<any>) => any) | null, wrapCommit?: (write: () => void) => void, onDraftWrite?: () => void): Computed<void | T>;
+export declare function runProjectionComputedNext<T extends object>(wrappedStore: Store<T>, fn: (draft: T) => void | T | Promise<void | T> | AsyncIterable<void | T>, key: string | ((item: NonNullable<any>) => any) | null, wrapCommit?: (write: () => void, value: T) => void, aroundDraftWrite?: (op: () => void) => void): Computed<void | T>;

package/dist/types/store/next/reconcile.d.ts

@@ -1,3 +1,10 @@
 type KeyFn = (item: any) => any;
 export declare function reconcileNextState(value: any, state: any, key: string | KeyFn | null | undefined, replace?: boolean): void;
+/** Setter-channel row ops (the fold site calls this for array targets with
+ * ops consumers): structural mutation through the setter — push/splice/index
+/** Key equality for EVERY key comparison in this module (re-audit 2, P1-5):
+ * SameValueZero, matching the adoption window's Map-based matcher — NaN keys
+ * are equal to themselves, so aligned NaN rows stay aligned in the prefix
+ * walk instead of forever misaligning. */
+export declare function sameKey(a: any, b: any): boolean;
 export {};