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

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

@@ -1,6 +1,5 @@
 import type { NOT_PENDING } from "./constants.js";
-import type { OptimisticLane } from "./lanes.js";
-import type { IQueue, Transition } from "./scheduler.js";
+import type { Transaction } from "./scheduler.js";
 export interface Disposable {
     (): void;
 }
@@ -17,7 +16,6 @@ export interface Link {
      * scanning the dep list to answer membership (see `link()`).
      */
     _gen: number;
-    _pendingObserver?: boolean;
 }
 export interface NodeOptions<T> {
     id?: string;
@@ -28,14 +26,21 @@ export interface NodeOptions<T> {
     /** 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. */
+     * not part of public API). Used by refresh() for CONFIG_FRESH_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;
+    /** Observe tiers: a framework scope wide by construction — exempt from
+     * WIDE_SCOPE_DEPS, never from HUGE_FAN_IN (internal — not part of public
+     * API; see CONFIG_WIDE). */
+    _wide?: boolean;
+    /** Observe tiers: a framework async node that supersedes its own flights by
+     * design — exempt from ABANDONED_FLIGHTS (internal — not part of public
+     * API; see CONFIG_SUPERSEDES). */
+    _supersedes?: boolean;
     unobserved?: () => void;
     lazy?: boolean;
     sync?: boolean;
@@ -62,69 +67,53 @@ export interface NodeOptions<T> {
  * 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
-     * _transition is a scheduling affinity that a shared subscriber can merge
-     * across transactions (#2912) — following it would let one action's settle
-     * 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 | 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 — 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). */
+     * `_inFlight` so a superseded stream stops at supersede time. 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;
+    /** L2 — the previous pass's frame, parked for this node's commit: its child
+     * chain and `_disposal` list, still reacting until the commit disposes
+     * them (or the owner's death does). */
     _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;
+    _pendingDisposal: Disposable | Disposable[] | null;
+    /** L2 — the transaction holding this node while CONFIG_HELD is set
+     * (`holdNode`); resolved through merges by `txOf`. */
+    _transaction: Transaction | null;
+    /** L2 — the transaction a first pass that went pending was born into (it
+     * read a held node, or a verdict lane's mount read a staging of the
+     * flush — the born-held arm's conditions): its first answer lands into it
+     * while it is live; the hold never waits for the node's first load (the
+     * direction rule, #3800). Consumed at the landing. */
+    _bornIn: Transaction | null;
+    /** The node's current flight re-asks the same question (a `refresh()`,
+     * A19 exc. 2 / A24): verdict-quiet — `isPending` reads false for it —
+     * through its landing until the commit. */
+    _reask: boolean;
+    /** A28: the staging the last flush left on a held node, kept across an
+     * unflushed rewrite — what `latest()` and a tracked reader see until the
+     * flush that carries the rewrite; valid while `_flushedAt` is the current
+     * clock (that flush advances it). */
+    _flushed: unknown;
+    _flushedAt: number;
+    /** Provenance (A18, #3331): the question this node's guess or latest
+     * flight answers (`scheduler.question`); 0 when unstamped. */
+    _q: number;
+    /** Lanes (plan sec. 28) — the lane's value for this node while CONFIG_OVERRIDE is
+     * set: a written guess, or a lane pass's derivation. `NOT_PENDING` when
+     * none. The screen shows it once the lane has revealed (`_shown`); a
+     * direct read sees it throughout; the committed truth stays `_value`. */
+    _lane: unknown;
+    /** `affects()` marks live on this node (affects.ts): declared in-flight
+     * changes — `isPending` reads true for it and its derivations while any
+     * is live. A count, never a hold. */
+    _marks: number;
 }
 export interface RawSignal<T> {
     _subs: Link | null;
@@ -145,10 +134,6 @@ export interface RawSignal<T> {
     _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
@@ -158,14 +143,7 @@ export interface RawSignal<T> {
     /** 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 type Signal<T> = RawSignal<T>;
 export interface Owner {
     id?: string;
     _config: number;
@@ -176,11 +154,10 @@ export interface Owner {
     _parent: Owner | null;
     _context: Record<symbol | string, unknown>;
     _childCount: number;
-    _queue: IQueue;
     _firstChild: Owner | null;
     _nextSibling: Owner | null;
     _prevSibling: Owner | null;
-    /** Cold extension — see NodeExtension (owners use the zombie-pair slots). */
+    /** Cold extension — see NodeExtension. */
     _x: NodeExtension | null;
     /**
      * Observe-tier label: the `name` option, the node kind (`computed`,
@@ -200,22 +177,11 @@ export interface Computed<T> extends RawSignal<T>, Owner {
     _nextHeap: Computed<any> | undefined;
     _prevHeap: Computed<any>;
     _fn: (prev?: T) => T;
-    /**
-     * 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.
-     */
-    _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`
      * serves that committed value instead of throwing NotReadyError, so first
-     * flights never suspend readers, trip boundaries, or hold transitions.
-     * The window is verdict-quiet: `isPending` stays false, because commit #0
-     * answers the question by declaration (first-load affordances belong to
-     * the value channel). Cleared by the first value landing on any path (sync
+     * flights never suspend readers or trip boundaries. Cleared by the first value landing on any path (sync
      * 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

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

@@ -1,2 +1,5 @@
+/** The windows. `read` dispatches to `verdictValue` while one is open; each
+ * restores the dispatch it found — none inside a memo's pass a window
+ * pulled (`verdictValue`). */
 export declare function latest<T>(fn: () => T): T;
 export declare function isPending(fn: () => any): boolean;

package/dist/types/flatten.d.ts

@@ -0,0 +1,8 @@
+/**
+ * Resolves nested accessors and arrays in a children tree to their rendered
+ * values. See the `children()` helper in solid-js for the memoized form.
+ */
+export declare function flatten(children: any, options?: {
+    skipNonRendered?: boolean;
+    doNotUnwrap?: boolean;
+}): any;

package/dist/types/index.d.ts

@@ -1,4 +1,4 @@
-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";
+export { $REFRESH, action, ContextNotFoundError, NoOwnerError, NotReadyError, TimeoutError, 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
@@ -14,10 +14,12 @@ import { type Dev, type Observe } from "./core/index.js";
 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, 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 { Owner, Context, ContextRecord, IQueue, ExternalSourceFactory, ExternalSource, ExternalSourceConfig, Refreshable, AttributionSlot, ClientErrorContext, ClientErrorHook, ClientErrorsConfig, InteractionRef, NavigationRef, Dev, Observe, ServerObserve, Records, RecordTypes, HostRecordTypes, RecordType, RecordEvent, RecordLive, RecordListener, RecordSubscribeOptions, DevHooks, DiagnosticCapture, DiagnosticCode, DiagnosticEvent, DiagnosticKind, DiagnosticListener, Diagnostics, DiagnosticSeverity, DiagnosticSubject } from "./core/index.js";
+export { createSignal, createOptimistic, createMemo, createEffect, createRenderEffect, createTrackedEffect, createReaction, 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";
-export { createLoadingBoundary, createErrorBoundary, createRevealOrder, flatten, type RevealOrder } from "./boundaries.js";
+export { affects } from "./affects.js";
+export { flatten } from "./flatten.js";
+export { createLoadingBoundary, createErrorBoundary } from "./boundaries.js";
+export { createRevealOrder, type RevealOrder } from "./reveal.js";

package/dist/types/reveal.d.ts

@@ -0,0 +1,19 @@
+export type RevealOrder = "sequential" | "together" | "natural";
+type OrderAccessor = () => RevealOrder;
+type BoolAccessor = () => boolean;
+/**
+ * Lower-level primitive behind `<Reveal>`: coordinates the order in which the
+ * Loading boundaries created directly inside `fn` reveal their content.
+ *
+ * @param fn the subtree; the Loading boundaries it creates directly are the
+ *   group's slots, a nested `createRevealOrder` a composite slot
+ * @param options `order` — `"sequential"` (default: front to back, the
+ *   first unready slot showing its fallback), `"together"` (all at once),
+ *   `"natural"` (each on its own); `collapsed` — in a sequential group, the
+ *   slots behind the frontier render nothing instead of their fallbacks
+ */
+export declare function createRevealOrder<T>(fn: () => T, options?: {
+    order?: OrderAccessor;
+    collapsed?: BoolAccessor;
+}): T;
+export {};

package/dist/types/signals.d.ts

@@ -267,10 +267,11 @@ export type NoInfer<T extends any> = [T][T extends any ? 0 : never];
  * // Writable memo: derives from `fn()` and can be written like a signal.
  * const [user, setUser] = createSignal(() => fetchUser(userId()));
  *
- * // 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`.
+ * // A write lands at once and never re-runs `fn` on its own; when `userId`
+ * // changes, in the same update or later, `fn` re-runs and 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" });
  * ```
  *
@@ -279,6 +280,27 @@ export type NoInfer<T extends any> = [T][T extends any ? 0 : never];
 export declare function createSignal<T>(): Signal<T | undefined>;
 export declare function createSignal<T>(value: Exclude<T, Function>, options?: SignalOptions<T>): Signal<T>;
 export declare function createSignal<T>(fn: ComputeFunction<T>, options?: SignalOptions<T> & MemoOptions<T>): Signal<T>;
+/**
+ * Creates an optimistic signal: a value that can be set optimistically inside
+ * a transition and reverts to the value it covered when the transition ends.
+ *
+ * The write is a guess over the transition of the frame it is made in — the
+ * frame's held writes are its base, and it shows at once while they wait.
+ * Outside such a frame (nothing is held) the write is as if it never
+ * happened. With a function, the memo form: its own recompute is the truth
+ * — equal to the guess it confirms silently, different it corrects at the
+ * transition's commit.
+ *
+ * ```typescript
+ * const [state, setState] = createOptimistic<T>(value, options?: SignalOptions<T>);
+ * const [state, setState] = createOptimistic<T>(fn, options?: SignalOptions<T> & MemoOptions<T>);
+ * ```
+ *
+ * @description https://docs.solidjs.com/reference/basic-reactivity/create-optimistic-signal
+ */
+export declare function createOptimistic<T>(): Signal<T | undefined>;
+export declare function createOptimistic<T>(value: Exclude<T, Function>, options?: SignalOptions<T>): Signal<T>;
+export declare function createOptimistic<T>(fn: ComputeFunction<T>, options?: SignalOptions<T> & MemoOptions<T>): Signal<T>;
 /**
  * Creates a readonly derived reactive memoized signal.
  *
@@ -381,7 +403,7 @@ 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;
+export declare function createEffect<const T>(compute: ComputeFunction<undefined | NoInfer<T>, T>, effectFn: EffectFunction<NoInfer<T>, T> | EffectBundle<NoInfer<T>, T>, options?: EffectOptions): void;
 /**
  * Creates a reactive computation that runs during the render phase as DOM elements
  * are created and updated but not necessarily connected.
@@ -411,7 +433,7 @@ export declare function createEffect<T>(compute: ComputeFunction<undefined | NoI
  *
  * @description https://docs.solidjs.com/reference/secondary-primitives/create-render-effect
  */
-export declare function createRenderEffect<T>(compute: ComputeFunction<undefined | NoInfer<T>, T>, effectFn: EffectFunction<NoInfer<T>, T>, options?: EffectOptions): void;
+export declare function createRenderEffect<const T>(compute: ComputeFunction<undefined | NoInfer<T>, T>, effectFn: EffectFunction<NoInfer<T>, T>, options?: EffectOptions): void;
 /**
  * Creates a tracked reactive effect where dependency tracking and side effects happen
  * in the same scope.
@@ -523,19 +545,10 @@ export declare function resolve<T>(fn: () => T): Promise<T>;
  * 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).
+ * - A failed re-ask rejects with the error.
  * - 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
@@ -551,13 +564,30 @@ export declare function resolve<T>(fn: () => T): Promise<T>;
 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>;
+/**
+ * The global `AbortSignal` when the consumer's libs declare one (DOM,
+ * WebWorker, `@types/node`), else the surface `until` uses — so these
+ * declarations check under neither lib without widening the global type.
+ */
+type GlobalAbortSignal = typeof globalThis extends {
+    AbortSignal: {
+        prototype: infer S;
+    };
+} ? S : {
+    readonly aborted: boolean;
+    readonly reason: any;
+    addEventListener(type: "abort", listener: () => void, options?: {
+        once?: boolean;
+    }): void;
+    removeEventListener(type: "abort", listener: () => void): void;
+};
 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;
+    signal?: GlobalAbortSignal;
 }
 /**
  * Awaits a reactive predicate and resolves the first time it settles *truthy*,
@@ -568,96 +598,27 @@ export interface UntilOptions {
  *
  * 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.
+ * condition".
  *
  * 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 });
- * });
+ * const clientId = crypto.randomUUID();
+ * await socket.send({ clientId, text }); // fire-and-forget transport
+ * // Wait until the live source echoes the write:
+ * await until(() => messages.some(m => m.clientId === clientId), { timeout: 10_000 });
  * ```
  *
- * @param fn a reactive predicate over authoritative state
+ * @param fn a reactive predicate
  * @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.
- *
- * When called with a plain value, creates an optimistic signal with `SignalOptions` (name, equals, ownedWrite, unobserved).
- * When called with a function, creates a writable optimistic memo with `SignalOptions & MemoOptions` (adds id, lazy).
- *
- * ```typescript
- * // Plain optimistic signal
- * const [state, setState] = createOptimistic<T>(value, options?: SignalOptions<T>);
- * // Writable optimistic memo (function overload)
- * const [state, setState] = createOptimistic<T>(fn, options?: SignalOptions<T> & MemoOptions<T>);
- * ```
- * @param value initial value of the signal; if empty, the signal's type will automatically extended with undefined
- * @param options optional object with a name for debugging purposes and equals, a comparator function for the previous and next value to allow fine-grained control over the reactivity
- *
- * @returns `[state: Accessor<T>, setState: Setter<T>]`
- *
- * @example
- * ```ts
- * const [todos, setTodos] = createOptimistic(initialTodos);
- *
- * const addTodo = action(function* (text: string) {
- *   const tempId = crypto.randomUUID();
- *   setTodos(t => [...t, { id: tempId, text, pending: true }]); // optimistic
- *   const saved = yield api.createTodo(text);
- *   setTodos(t => t.map(x => (x.id === tempId ? saved : x)));   // reconcile
- * });
- * ```
- *
- * @description https://docs.solidjs.com/reference/basic-reactivity/create-optimistic-signal
- */
-export declare function createOptimistic<T>(): Signal<T | undefined>;
-export declare function createOptimistic<T>(value: Exclude<T, Function>, options?: SignalOptions<T>): Signal<T>;
-export declare function createOptimistic<T>(fn: ComputeFunction<T>, options?: SignalOptions<T> & MemoOptions<T>): Signal<T>;
 /**
  * Schedules `callback` to run **once** after the reactive graph has fully
  * settled — i.e. once every pending async read inside the current owner has

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

@@ -0,0 +1 @@
+export {};

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

@@ -1,20 +1,40 @@
-export type { Store, StoreReturn, ProjectionStoreReturn, StoreSetter, StoreNode, StoreOptions, ProjectionOptions, NotWrappable, SolidStore } from "./store.js";
+/**
+ * Store — public surface. Plain stores (S1) are live; the derived form
+ * (`createStore(fn, seed)`), projections, optimistic stores and reconcile
+ * return on later steps (plan sec. 31.5).
+ */
+export type { NoFn, NotWrappable, ProjectionOptions, ProjectionStoreReturn, SolidStore, Store, StoreOptions, StoreReturn, StoreSetter } from "./types.js";
+export { $PROXY, $RECORD, $TARGET, $TRACK, isWrappable, markRaw } from "./types.js";
+export { storeIsShallow, storeHasFamily, storeHasOptimisticFamily } from "./store.js";
+export { storePath } from "./storePath.js";
+export type { StorePathRange, PathSetter, Part, CustomPartial, ArrayFilterFn } from "./storePath.js";
+import "./affects.js";
+import { createOptimisticStore } from "./optimistic.js";
+import { createProjection } from "./projection.js";
+import type { NoFn, ProjectionOptions, ProjectionStoreReturn, Store, StoreOptions, StoreReturn } from "./types.js";
+export { createOptimisticStore, createProjection };
+/** The store's internal record behind a proxy (`store[$TARGET]`). Kept
+ * under `next`'s public name; its shape is the L2 target's (plan plan sec. 31–32:
+ * the symbol-keyed legacy record is gone with the representation). */
+export type { StoreTarget as StoreNode } from "./target.js";
 export type { Merge, Omit } from "./utils.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 { mergeSources, mergeView, viewOf, omitView, sourceKeys, sourceHas, sourceGet, hasStaticKeys, isStatic, resolvedTable, OmitView, MergeView, SOURCE_PLAIN, SOURCE_OMIT, SOURCE_PROXY, SOURCE_MEMO, SOURCE_MERGE, sourceOwners, merge, omit } 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 `(initialValue, options?)` and derived writable
- * form `(fn, seed, options?)`. */
-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>];
+/**
+ * Create a reactive store: a proxy over plain data with fine-grained
+ * subscriptions per read path, written through its setter's draft — or, in
+ * the derived form, a projection with a setter.
+ */
+export declare function createStore<T extends object = {}>(initialValue: NoFn<T>, options?: StoreOptions): StoreReturn<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): ProjectionStoreReturn<T>;
+/**
+ * A setter transform that reconciles `value` into the store by key
+ * (`"id"` by default; `null` positional), preserving store identity for
+ * surviving rows.
+ */
 export declare function reconcile<T extends U, U>(value: T, key?: string | ((item: NonNullable<any>) => any) | null): (state: U) => T;
+/** Non-tracking snapshot of a store's current value (source identity for
+ * unmodified subtrees). */
 export declare function snapshot<T>(value: T): T;
+/** Tracking snapshot: subscribes to every reachable record. */
 export declare function deep<T>(value: T): T;
-export { storePath } from "./storePath.js";
-export type { PathSetter, Part, StorePathRange, ArrayFilterFn, CustomPartial } from "./storePath.js";
-export { merge, omit } from "./utils.js";

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

@@ -0,0 +1,23 @@
+import type { Refreshable } from "../core/index.js";
+import { type StoreTarget } from "./target.js";
+import { type NoFn, type ProjectionOptions, type Store, type StoreOptions, type StoreSetter } from "./types.js";
+export declare function notifyOptimisticWrites(t: StoreTarget, pb: Record<PropertyKey, any>): Record<PropertyKey, any> | null;
+export declare function sweepOverlaid(): void;
+/** An untracked `key in store` on an optimistic family: the presence guess
+ * (what its lane shows) when the key carries one; `undefined` when not —
+ * the backing answers. */
+export declare function optimisticHas(t: StoreTarget, key: PropertyKey): boolean | undefined;
+/** A descriptor read of a guessed key: synthesized from the lane's value
+ * (`null`: the guess removed the key; `undefined`: no guess — the backing
+ * describes it). */
+export declare function optimisticOwnDescriptor(t: StoreTarget, key: PropertyKey): PropertyDescriptor | null | undefined;
+/** The truth `src` with the target's lane values over it: each overlaid
+ * leaf's value (`pick`: what the lane shows, or — for `latest` — the lane's
+ * latest), each presence guess as a key added or removed, the array
+ * length. Returns `src` itself when nothing is overlaid. */
+export declare function optimisticView(t: StoreTarget, src: Record<PropertyKey, any>, pick?: (n: any) => unknown, writer?: boolean): Record<PropertyKey, any>;
+/** `latest()`'s view: the lanes' latest values (a landing staged beneath a
+ * guess is what lands). */
+export declare function latestView(t: StoreTarget, src: Record<PropertyKey, any>): Record<PropertyKey, any>;
+export declare function createOptimisticStore<T extends object = {}>(initialValue: NoFn<T> | Store<NoFn<T>>, options?: StoreOptions): [get: Store<T>, set: StoreSetter<T>];
+export declare function createOptimisticStore<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>];

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

@@ -0,0 +1,18 @@
+import type { Computed } from "../core/types.js";
+import type { Refreshable } from "../core/index.js";
+import { type NoFn, type ProjectionOptions, type Store } from "./types.js";
+/** The derive's pass: run `fn` against a draft of the store; commit its
+ * result (sync, or each async landing) through the reconcile channel.
+ * Draft validity is per run (R37): live from here until the NEXT run starts
+ * — a sync derive that subscribes to an external source and pushes into
+ * the draft from the callback (#3585) is the model use. */
+export declare function runProjectionComputed<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>;
+/**
+ * A derived store: `fn` runs in a computed and writes its draft; readers of
+ * the store's keys re-run only when the keys they read change (the
+ * firewall). `fn` may be async or an async iterator; the seed is a draft,
+ * never an observable value, until the first landing (A25).
+ */
+export declare function createProjection<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>>;
+/** `createStore(fn, seed, options)`: a projection with a user setter. */
+export declare function createStoreDerived<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];

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

@@ -0,0 +1,3 @@
+type KeyFn = (item: any) => any;
+export declare function reconcileState(value: any, state: any, key: string | KeyFn | null | undefined, replace?: boolean): void;
+export {};