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

package/dist/types/boundaries.d.ts

@@ -5,18 +5,29 @@ export interface BoundaryComputed<T> extends Computed<T> {
 }
 type RevealSlot = CollectionQueue | RevealController;
 type BoolAccessor = () => boolean;
+export type RevealOrder = "sequential" | "together" | "natural";
+type OrderAccessor = () => RevealOrder;
 export declare class RevealController {
-    _togetherAccessor: BoolAccessor;
+    _orderAccessor: OrderAccessor;
     _collapsedAccessor: BoolAccessor;
     _slots: RevealSlot[];
     _parentController?: RevealController;
     _disabled: Signal<boolean>;
     _collapsed: Signal<boolean>;
     _ready: boolean;
+    _minimallyReady: boolean;
     _evaluating: boolean;
-    constructor(together: BoolAccessor, collapsed: BoolAccessor);
+    constructor(order: OrderAccessor, collapsed: BoolAccessor);
     _forEachOwnedSlot(fn: (slot: RevealSlot) => boolean | void): boolean;
     isReady(): boolean;
+    /**
+     * "Minimally ready" = this group has something visible to show under its own policy.
+     * Used by an enclosing `together` group to decide when it can release.
+     * - `together`: fully ready (atomic).
+     * - `sequential`: the first owned slot is minimally ready (frontier can advance).
+     * - `natural`: any owned slot is minimally ready.
+     */
+    isMinimallyReady(): boolean;
     register(slot: RevealSlot): void;
     unregister(slot: RevealSlot): void;
     evaluate(disabledOverride?: boolean, collapsedOverride?: boolean): void;
@@ -41,8 +52,38 @@ export declare function createLoadingBoundary(fn: () => any, fallback: () => any
     on?: () => any;
 }): import("./signals.js").Accessor<unknown>;
 export declare function createErrorBoundary<U>(fn: () => any, fallback: (error: unknown, reset: () => void) => U): import("./signals.js").Accessor<unknown>;
+/**
+ * Coordinate the reveal timing of sibling loading boundaries.
+ *
+ * Accepts reactive accessors:
+ * - `order`: `"sequential"` (default) | `"together"` | `"natural"`.
+ *   - `"sequential"` — classic frontier reveal: siblings reveal in registration order
+ *     as each resolves; later siblings stay hidden until earlier ones complete.
+ *   - `"together"` — every direct slot stays on its fallback until the whole group
+ *     is "minimally ready" (each direct slot has produced its own first visible
+ *     content under its own order), then the whole group releases at once.
+ *   - `"natural"` — children reveal independently (as each resolves). At the top
+ *     level this is a no-op compared to not using `createRevealOrder`; the mode
+ *     exists for nesting, where the group registers as a single composite slot to
+ *     any enclosing `createRevealOrder`.
+ * - `collapsed`: only meaningful when `order === "sequential"`. When set, tail siblings
+ *   past the frontier suppress their own fallback output. Ignored under `"together"`
+ *   and `"natural"` — those orders have no frontier.
+ *
+ * Nested `createRevealOrder` groups compose: the inner controller registers as a
+ * single slot in the outer controller and is held on its fallbacks until the outer
+ * releases that slot. Once released, the inner controller runs its own order locally
+ * over anything still pending. There is no opt-out from an outer hold.
+ *
+ * "Minimally ready" is what an order considers its first visible content:
+ * - `sequential` — frontier-0 is minimally ready (leaf: on resolve; nested: via its
+ *   own minimal signal).
+ * - `together` — every direct slot is minimally ready.
+ * - `natural` — any direct slot has visible content (leaves on resolve; nested
+ *   composites when fully ready, since natural treats composites as atomic).
+ */
 export declare function createRevealOrder<T>(fn: () => T, options?: {
-    together?: BoolAccessor;
+    order?: OrderAccessor;
     collapsed?: BoolAccessor;
 }): T;
 export declare function flatten(children: any, options?: {

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

@@ -17,11 +17,11 @@ export declare function releaseSnapshotScope(owner: Owner): void;
 export declare function clearSnapshots(): void;
 export declare function recompute(el: Computed<any>, create?: boolean): void;
 export declare function computed<T>(fn: (prev?: T) => T | PromiseLike<T> | AsyncIterable<T>): Computed<T>;
-export declare function computed<T>(fn: (prev: T) => T | PromiseLike<T> | AsyncIterable<T>, initialValue?: T, options?: NodeOptions<T>): Computed<T>;
+export declare function computed<T>(fn: (prev: T) => T | PromiseLike<T> | AsyncIterable<T>, options?: NodeOptions<T>): Computed<T>;
 export declare function signal<T>(v: T, options?: NodeOptions<T>): Signal<T>;
 export declare function signal<T>(v: T, options?: NodeOptions<T>, firewall?: Computed<any>): FirewallSignal<T>;
 export declare function optimisticSignal<T>(v: T, options?: NodeOptions<T>): Signal<T>;
-export declare function optimisticComputed<T>(fn: (prev?: T) => T | PromiseLike<T> | AsyncIterable<T>, initialValue?: T, options?: NodeOptions<T>): Computed<T>;
+export declare function optimisticComputed<T>(fn: (prev?: T) => T | PromiseLike<T> | AsyncIterable<T>, options?: NodeOptions<T>): Computed<T>;
 export declare function isEqual<T>(a: T, b: T): boolean;
 /**
  * When set to a component name string, any reactive read that is not inside a nested tracking

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

@@ -12,9 +12,10 @@ export interface Effect<T> extends Computed<T>, Owner {
  * automatically added to the queue of effects to re-execute, which will cause them to fetch their
  * sources and recompute
  */
-export declare function effect<T>(compute: (prev: T | undefined) => T, effect: (val: T, prev: T | undefined) => void | (() => void), error?: (err: unknown, cleanup: () => void) => void | (() => void), initialValue?: T, options?: NodeOptions<any> & {
-    render?: boolean;
+export declare function effect<T>(compute: (prev: T | undefined) => T, effect: (val: T, prev: T | undefined) => void | (() => void), error?: (err: unknown, cleanup: () => void) => void | (() => void), options?: NodeOptions<any> & {
+    user?: boolean;
     defer?: boolean;
+    schedule?: boolean;
 }): void;
 export interface TrackedEffect extends Computed<void> {
     _cleanup?: () => void;

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

@@ -9,6 +9,7 @@ export declare let clock: number;
 export declare let activeTransition: Transition | null;
 export declare let projectionWriteActive: boolean;
 export declare let _hitUnhandledAsync: boolean;
+export declare function registerTransientStoreNode(node: Signal<any>): void;
 export declare function resetUnhandledAsync(): void;
 export declare function enforceLoadingBoundary(enabled: boolean): void;
 export declare function shouldReadStashedOptimisticValue(node: Signal<any>): boolean;

package/dist/types/index.d.ts

@@ -6,4 +6,4 @@ export { createSignal, createMemo, createEffect, createRenderEffect, createTrack
 export type { Accessor, Setter, Signal, ComputeFunction, EffectFunction, EffectBundle, EffectOptions, SignalOptions, MemoOptions, NoInfer } from "./signals.js";
 export { mapArray, repeat, type Maybe } from "./map.js";
 export * from "./store/index.js";
-export { createLoadingBoundary, createErrorBoundary, createRevealOrder, flatten } from "./boundaries.js";
+export { createLoadingBoundary, createErrorBoundary, createRevealOrder, flatten, type RevealOrder } from "./boundaries.js";

package/dist/types/signals.d.ts

@@ -15,12 +15,25 @@ export type EffectBundle<Prev, Next extends Prev = Prev> = {
     effect: EffectFunction<Prev, Next>;
     error: (err: unknown, cleanup: () => void) => void;
 };
-/** Options for effect primitives (`createEffect`, `createRenderEffect`, `createTrackedEffect`, `createReaction`). */
-export interface EffectOptions {
+/** Options shared by every effect primitive. */
+interface BaseEffectOptions {
     /** Debug name (dev mode only) */
     name?: string;
+}
+/** Options for effect primitives that support deferring/scheduling their initial run (`createEffect`, `createRenderEffect`, `createReaction`). */
+export interface EffectOptions extends BaseEffectOptions {
     /** When true, defers the initial effect execution until the next change */
     defer?: boolean;
+    /**
+     * When true, enqueues the initial effect callback through the effect queue instead of running
+     * it synchronously at creation. Lets the initial run participate in transitions -- if any
+     * source throws `NotReadyError` during the compute phase, the callback is held until the
+     * transition settles.
+     *
+     * Primarily for render effects that need transition-aware initial mounts (e.g. the root
+     * `insert()` in `render()`).
+     */
+    schedule?: boolean;
 }
 /** Options for plain signals created with `createSignal(value)` or `createOptimistic(value)`. */
 export interface SignalOptions<T> {
@@ -123,14 +136,14 @@ export declare function createRenderEffect<T>(compute: ComputeFunction<undefined
  * state). Use only when dynamic subscription patterns require same-scope tracking.
  *
  * ```typescript
- * createTrackedEffect(compute, options?: EffectOptions);
+ * createTrackedEffect(compute, options?: { name?: string });
  * ```
  * @param compute a function that contains reactive reads to track and returns an optional cleanup function to run on disposal or before next execution
- * @param options `EffectOptions` -- name, defer
+ * @param options -- name
  *
  * @description https://docs.solidjs.com/reference/secondary-primitives/create-tracked-effect
  */
-export declare function createTrackedEffect(compute: () => void | (() => void), options?: EffectOptions): void;
+export declare function createTrackedEffect(compute: () => void | (() => void), options?: BaseEffectOptions): void;
 /**
  * Creates a reactive computation that runs after the render phase with flexible tracking.
  *
@@ -184,3 +197,4 @@ export declare function createOptimistic<T>(fn: ComputeFunction<T>, options?: Si
  * @param callback Function to run, may return a cleanup function
  */
 export declare function onSettled(callback: () => void | (() => void)): void;
+export {};

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

@@ -5,7 +5,7 @@ import { type NoFn, type ProjectionOptions, type Store, type StoreSetter } from
  * and then revert it back to the previous value at end of transition.
  *
  * When called with a plain value, creates an optimistic store.
- * When called with a function, creates a derived optimistic store with `ProjectionOptions` (name, key, all).
+ * When called with a function, creates a derived optimistic store with `ProjectionOptions` (name, key).
  *
  * @param fn a function that receives the current store and can be used to mutate it directly inside a transition
  * @param store The plain store value, or the backing seed when using the derived-store form.

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

@@ -15,12 +15,26 @@ export declare function createProjectionInternal<T extends object = {}>(fn: (dra
  * ```
  * @param fn a function that receives the current draft and mutates it or returns new data
  * @param seed the backing store host value to wrap and reconcile into
- * @param options `ProjectionOptions` -- name, key, all
+ * @param options `ProjectionOptions` -- name, key
  *
  * @see {@link https://github.com/solidjs/x-reactivity#createprojection}
  */
 export declare function createProjection<T extends object = {}>(fn: (draft: T) => void | T | Promise<void | T> | AsyncIterable<void | T>, seed: Partial<T>, options?: ProjectionOptions): Store<T> & {
     [$REFRESH]: any;
 };
+/**
+ * Shared projection computed body used by both `createProjection` and the derived
+ * form of `createOptimisticStore`. Encapsulates the write-trap draft, `storeSetter`
+ * wrapping, the `handleAsync` subscription with a setter callback, and the commit
+ * path (which must always go through `storeSetter` so the `writeOnly` guard is
+ * engaged during `reconcile`'s property reads).
+ *
+ * `wrapCommit` is invoked for every commit (sync return and each async yield) and
+ * lets callers layer extra context around the write — e.g. the optimistic store
+ * re-enters `setProjectionWriteActive` so reconciles target `STORE_OVERRIDE`
+ * instead of `STORE_OPTIMISTIC_OVERRIDE` even when an async yield fires outside
+ * the outer `setProjectionWriteActive` scope.
+ */
+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), wrapCommit?: (write: () => void) => void): Computed<void | T>;
 export declare function createWriteTraps(isActive?: () => boolean): ProxyHandler<any>;
 export declare const writeTraps: ProxyHandler<any>;

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

@@ -48,7 +48,7 @@ export declare function storeSetter<T extends object>(store: Store<T>, fn: (draf
  * Creates a deeply reactive store with proxy-based tracking.
  *
  * When called with a plain value, wraps it in a reactive proxy.
- * When called with a function, creates a derived projection store with `ProjectionOptions` (name, key, all).
+ * When called with a function, creates a derived projection store with `ProjectionOptions` (name, key).
  *
  * ```typescript
  * // Plain store
@@ -57,7 +57,7 @@ export declare function storeSetter<T extends object>(store: Store<T>, fn: (draf
  * const [store, setStore] = createStore<T>(fn, seed, options?: ProjectionOptions);
  * ```
  * @param store initial value to wrap in a reactive proxy, or a derive function
- * @param options `ProjectionOptions` -- name, key, all (only for derived stores)
+ * @param options `ProjectionOptions` -- name, key (only for derived stores)
  *
  * @returns `[store: Store<T>, setStore: StoreSetter<T>]`
  */

package/dist/types-cjs/boundaries.d.cts

@@ -5,18 +5,29 @@ export interface BoundaryComputed<T> extends Computed<T> {
 }
 type RevealSlot = CollectionQueue | RevealController;
 type BoolAccessor = () => boolean;
+export type RevealOrder = "sequential" | "together" | "natural";
+type OrderAccessor = () => RevealOrder;
 export declare class RevealController {
-    _togetherAccessor: BoolAccessor;
+    _orderAccessor: OrderAccessor;
     _collapsedAccessor: BoolAccessor;
     _slots: RevealSlot[];
     _parentController?: RevealController;
     _disabled: Signal<boolean>;
     _collapsed: Signal<boolean>;
     _ready: boolean;
+    _minimallyReady: boolean;
     _evaluating: boolean;
-    constructor(together: BoolAccessor, collapsed: BoolAccessor);
+    constructor(order: OrderAccessor, collapsed: BoolAccessor);
     _forEachOwnedSlot(fn: (slot: RevealSlot) => boolean | void): boolean;
     isReady(): boolean;
+    /**
+     * "Minimally ready" = this group has something visible to show under its own policy.
+     * Used by an enclosing `together` group to decide when it can release.
+     * - `together`: fully ready (atomic).
+     * - `sequential`: the first owned slot is minimally ready (frontier can advance).
+     * - `natural`: any owned slot is minimally ready.
+     */
+    isMinimallyReady(): boolean;
     register(slot: RevealSlot): void;
     unregister(slot: RevealSlot): void;
     evaluate(disabledOverride?: boolean, collapsedOverride?: boolean): void;
@@ -41,8 +52,38 @@ export declare function createLoadingBoundary(fn: () => any, fallback: () => any
     on?: () => any;
 }): import("./signals.cjs").Accessor<unknown>;
 export declare function createErrorBoundary<U>(fn: () => any, fallback: (error: unknown, reset: () => void) => U): import("./signals.cjs").Accessor<unknown>;
+/**
+ * Coordinate the reveal timing of sibling loading boundaries.
+ *
+ * Accepts reactive accessors:
+ * - `order`: `"sequential"` (default) | `"together"` | `"natural"`.
+ *   - `"sequential"` — classic frontier reveal: siblings reveal in registration order
+ *     as each resolves; later siblings stay hidden until earlier ones complete.
+ *   - `"together"` — every direct slot stays on its fallback until the whole group
+ *     is "minimally ready" (each direct slot has produced its own first visible
+ *     content under its own order), then the whole group releases at once.
+ *   - `"natural"` — children reveal independently (as each resolves). At the top
+ *     level this is a no-op compared to not using `createRevealOrder`; the mode
+ *     exists for nesting, where the group registers as a single composite slot to
+ *     any enclosing `createRevealOrder`.
+ * - `collapsed`: only meaningful when `order === "sequential"`. When set, tail siblings
+ *   past the frontier suppress their own fallback output. Ignored under `"together"`
+ *   and `"natural"` — those orders have no frontier.
+ *
+ * Nested `createRevealOrder` groups compose: the inner controller registers as a
+ * single slot in the outer controller and is held on its fallbacks until the outer
+ * releases that slot. Once released, the inner controller runs its own order locally
+ * over anything still pending. There is no opt-out from an outer hold.
+ *
+ * "Minimally ready" is what an order considers its first visible content:
+ * - `sequential` — frontier-0 is minimally ready (leaf: on resolve; nested: via its
+ *   own minimal signal).
+ * - `together` — every direct slot is minimally ready.
+ * - `natural` — any direct slot has visible content (leaves on resolve; nested
+ *   composites when fully ready, since natural treats composites as atomic).
+ */
 export declare function createRevealOrder<T>(fn: () => T, options?: {
-    together?: BoolAccessor;
+    order?: OrderAccessor;
     collapsed?: BoolAccessor;
 }): T;
 export declare function flatten(children: any, options?: {

package/dist/types-cjs/core/core.d.cts

@@ -17,11 +17,11 @@ export declare function releaseSnapshotScope(owner: Owner): void;
 export declare function clearSnapshots(): void;
 export declare function recompute(el: Computed<any>, create?: boolean): void;
 export declare function computed<T>(fn: (prev?: T) => T | PromiseLike<T> | AsyncIterable<T>): Computed<T>;
-export declare function computed<T>(fn: (prev: T) => T | PromiseLike<T> | AsyncIterable<T>, initialValue?: T, options?: NodeOptions<T>): Computed<T>;
+export declare function computed<T>(fn: (prev: T) => T | PromiseLike<T> | AsyncIterable<T>, options?: NodeOptions<T>): Computed<T>;
 export declare function signal<T>(v: T, options?: NodeOptions<T>): Signal<T>;
 export declare function signal<T>(v: T, options?: NodeOptions<T>, firewall?: Computed<any>): FirewallSignal<T>;
 export declare function optimisticSignal<T>(v: T, options?: NodeOptions<T>): Signal<T>;
-export declare function optimisticComputed<T>(fn: (prev?: T) => T | PromiseLike<T> | AsyncIterable<T>, initialValue?: T, options?: NodeOptions<T>): Computed<T>;
+export declare function optimisticComputed<T>(fn: (prev?: T) => T | PromiseLike<T> | AsyncIterable<T>, options?: NodeOptions<T>): Computed<T>;
 export declare function isEqual<T>(a: T, b: T): boolean;
 /**
  * When set to a component name string, any reactive read that is not inside a nested tracking

package/dist/types-cjs/core/effect.d.cts

@@ -12,9 +12,10 @@ export interface Effect<T> extends Computed<T>, Owner {
  * automatically added to the queue of effects to re-execute, which will cause them to fetch their
  * sources and recompute
  */
-export declare function effect<T>(compute: (prev: T | undefined) => T, effect: (val: T, prev: T | undefined) => void | (() => void), error?: (err: unknown, cleanup: () => void) => void | (() => void), initialValue?: T, options?: NodeOptions<any> & {
-    render?: boolean;
+export declare function effect<T>(compute: (prev: T | undefined) => T, effect: (val: T, prev: T | undefined) => void | (() => void), error?: (err: unknown, cleanup: () => void) => void | (() => void), options?: NodeOptions<any> & {
+    user?: boolean;
     defer?: boolean;
+    schedule?: boolean;
 }): void;
 export interface TrackedEffect extends Computed<void> {
     _cleanup?: () => void;

package/dist/types-cjs/core/scheduler.d.cts

@@ -9,6 +9,7 @@ export declare let clock: number;
 export declare let activeTransition: Transition | null;
 export declare let projectionWriteActive: boolean;
 export declare let _hitUnhandledAsync: boolean;
+export declare function registerTransientStoreNode(node: Signal<any>): void;
 export declare function resetUnhandledAsync(): void;
 export declare function enforceLoadingBoundary(enabled: boolean): void;
 export declare function shouldReadStashedOptimisticValue(node: Signal<any>): boolean;

package/dist/types-cjs/index.d.cts

@@ -6,4 +6,4 @@ export { createSignal, createMemo, createEffect, createRenderEffect, createTrack
 export type { Accessor, Setter, Signal, ComputeFunction, EffectFunction, EffectBundle, EffectOptions, SignalOptions, MemoOptions, NoInfer } from "./signals.cjs";
 export { mapArray, repeat, type Maybe } from "./map.cjs";
 export * from "./store/index.cjs";
-export { createLoadingBoundary, createErrorBoundary, createRevealOrder, flatten } from "./boundaries.cjs";
+export { createLoadingBoundary, createErrorBoundary, createRevealOrder, flatten, type RevealOrder } from "./boundaries.cjs";

package/dist/types-cjs/signals.d.cts

@@ -15,12 +15,25 @@ export type EffectBundle<Prev, Next extends Prev = Prev> = {
     effect: EffectFunction<Prev, Next>;
     error: (err: unknown, cleanup: () => void) => void;
 };
-/** Options for effect primitives (`createEffect`, `createRenderEffect`, `createTrackedEffect`, `createReaction`). */
-export interface EffectOptions {
+/** Options shared by every effect primitive. */
+interface BaseEffectOptions {
     /** Debug name (dev mode only) */
     name?: string;
+}
+/** Options for effect primitives that support deferring/scheduling their initial run (`createEffect`, `createRenderEffect`, `createReaction`). */
+export interface EffectOptions extends BaseEffectOptions {
     /** When true, defers the initial effect execution until the next change */
     defer?: boolean;
+    /**
+     * When true, enqueues the initial effect callback through the effect queue instead of running
+     * it synchronously at creation. Lets the initial run participate in transitions -- if any
+     * source throws `NotReadyError` during the compute phase, the callback is held until the
+     * transition settles.
+     *
+     * Primarily for render effects that need transition-aware initial mounts (e.g. the root
+     * `insert()` in `render()`).
+     */
+    schedule?: boolean;
 }
 /** Options for plain signals created with `createSignal(value)` or `createOptimistic(value)`. */
 export interface SignalOptions<T> {
@@ -123,14 +136,14 @@ export declare function createRenderEffect<T>(compute: ComputeFunction<undefined
  * state). Use only when dynamic subscription patterns require same-scope tracking.
  *
  * ```typescript
- * createTrackedEffect(compute, options?: EffectOptions);
+ * createTrackedEffect(compute, options?: { name?: string });
  * ```
  * @param compute a function that contains reactive reads to track and returns an optional cleanup function to run on disposal or before next execution
- * @param options `EffectOptions` -- name, defer
+ * @param options -- name
  *
  * @description https://docs.solidjs.com/reference/secondary-primitives/create-tracked-effect
  */
-export declare function createTrackedEffect(compute: () => void | (() => void), options?: EffectOptions): void;
+export declare function createTrackedEffect(compute: () => void | (() => void), options?: BaseEffectOptions): void;
 /**
  * Creates a reactive computation that runs after the render phase with flexible tracking.
  *
@@ -184,3 +197,4 @@ export declare function createOptimistic<T>(fn: ComputeFunction<T>, options?: Si
  * @param callback Function to run, may return a cleanup function
  */
 export declare function onSettled(callback: () => void | (() => void)): void;
+export {};

package/dist/types-cjs/store/optimistic.d.cts

@@ -5,7 +5,7 @@ import { type NoFn, type ProjectionOptions, type Store, type StoreSetter } from
  * and then revert it back to the previous value at end of transition.
  *
  * When called with a plain value, creates an optimistic store.
- * When called with a function, creates a derived optimistic store with `ProjectionOptions` (name, key, all).
+ * When called with a function, creates a derived optimistic store with `ProjectionOptions` (name, key).
  *
  * @param fn a function that receives the current store and can be used to mutate it directly inside a transition
  * @param store The plain store value, or the backing seed when using the derived-store form.

package/dist/types-cjs/store/projection.d.cts

@@ -15,12 +15,26 @@ export declare function createProjectionInternal<T extends object = {}>(fn: (dra
  * ```
  * @param fn a function that receives the current draft and mutates it or returns new data
  * @param seed the backing store host value to wrap and reconcile into
- * @param options `ProjectionOptions` -- name, key, all
+ * @param options `ProjectionOptions` -- name, key
  *
  * @see {@link https://github.com/solidjs/x-reactivity#createprojection}
  */
 export declare function createProjection<T extends object = {}>(fn: (draft: T) => void | T | Promise<void | T> | AsyncIterable<void | T>, seed: Partial<T>, options?: ProjectionOptions): Store<T> & {
     [$REFRESH]: any;
 };
+/**
+ * Shared projection computed body used by both `createProjection` and the derived
+ * form of `createOptimisticStore`. Encapsulates the write-trap draft, `storeSetter`
+ * wrapping, the `handleAsync` subscription with a setter callback, and the commit
+ * path (which must always go through `storeSetter` so the `writeOnly` guard is
+ * engaged during `reconcile`'s property reads).
+ *
+ * `wrapCommit` is invoked for every commit (sync return and each async yield) and
+ * lets callers layer extra context around the write — e.g. the optimistic store
+ * re-enters `setProjectionWriteActive` so reconciles target `STORE_OVERRIDE`
+ * instead of `STORE_OPTIMISTIC_OVERRIDE` even when an async yield fires outside
+ * the outer `setProjectionWriteActive` scope.
+ */
+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), wrapCommit?: (write: () => void) => void): Computed<void | T>;
 export declare function createWriteTraps(isActive?: () => boolean): ProxyHandler<any>;
 export declare const writeTraps: ProxyHandler<any>;

package/dist/types-cjs/store/store.d.cts

@@ -48,7 +48,7 @@ export declare function storeSetter<T extends object>(store: Store<T>, fn: (draf
  * Creates a deeply reactive store with proxy-based tracking.
  *
  * When called with a plain value, wraps it in a reactive proxy.
- * When called with a function, creates a derived projection store with `ProjectionOptions` (name, key, all).
+ * When called with a function, creates a derived projection store with `ProjectionOptions` (name, key).
  *
  * ```typescript
  * // Plain store
@@ -57,7 +57,7 @@ export declare function storeSetter<T extends object>(store: Store<T>, fn: (draf
  * const [store, setStore] = createStore<T>(fn, seed, options?: ProjectionOptions);
  * ```
  * @param store initial value to wrap in a reactive proxy, or a derive function
- * @param options `ProjectionOptions` -- name, key, all (only for derived stores)
+ * @param options `ProjectionOptions` -- name, key (only for derived stores)
  *
  * @returns `[store: Store<T>, setStore: StoreSetter<T>]`
  */

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@solidjs/signals",
-  "version": "2.0.0-beta.7",
+  "version": "2.0.0-beta.8",
   "description": "SolidJS' reactive core implementation",
   "author": "Ryan Carniato",
   "license": "MIT",