@solidjs/signals 2.0.0-beta.10 → 2.0.0-beta.12

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

@@ -0,0 +1,125 @@
+import { STORE_SNAPSHOT_PROPS, type Computed, type Refreshable, type Signal } from "../core/index.js";
+/** A read-only view of a store's value as seen by consumers. Mutate it via the paired `StoreSetter`. */
+export type Store<T> = Readonly<T>;
+/**
+ * A store setter. The callback receives a writable **draft** of the store.
+ *
+ * - **Mutate in place (canonical):** `s.foo = 1`, `s.list.push(x)`,
+ *   `s.list.splice(i, 1)`. This is the default form for most updates.
+ * - **Return a new value:** for shapes where mutation is awkward, most
+ *   commonly removing items (`s => s.list.filter(...)`). Arrays are replaced
+ *   by index (length adjusted); objects are shallow-diffed at the top level
+ *   (keys present in the returned value are written, missing keys deleted).
+ *
+ * The setter does **not** perform keyed reconciliation. If you need surviving
+ * items to keep their store identity across full-array replacement, use the
+ * projection form — `createStore(fn, seed, { key })` or `createProjection` —
+ * whose derive function reconciles its return by `options.key`.
+ */
+export type StoreSetter<T> = (fn: (state: T) => T | void) => void;
+/** Base options for store primitives. */
+export interface StoreOptions {
+    /** Debug name (dev mode only) */
+    name?: string;
+}
+/** Options for derived/projected stores created with `createStore(fn)`, `createProjection`, or `createOptimisticStore(fn)`. */
+export interface ProjectionOptions extends StoreOptions {
+    /** Key property name or function for reconciliation identity */
+    key?: string | ((item: NonNullable<any>) => any);
+}
+export type NoFn<T> = T extends Function ? never : T;
+type DataNode = Signal<any>;
+type DataNodes = Record<PropertyKey, DataNode>;
+/**
+ * Brand symbols used internally by the store proxy / projection plumbing.
+ * Cross-package wiring; not part of the user-facing API.
+ *
+ * @internal
+ */
+export declare const $TRACK: unique symbol, $TARGET: unique symbol, $PROXY: unique symbol, $DELETED: unique symbol;
+export declare const STORE_VALUE = "v", STORE_OVERRIDE = "o", STORE_OPTIMISTIC_OVERRIDE = "x", STORE_NODE = "n", STORE_HAS = "h", STORE_CUSTOM_PROTO = "c", STORE_WRAP = "w", STORE_LOOKUP = "l", STORE_FIREWALL = "f", STORE_OPTIMISTIC = "p";
+export type StoreNode = {
+    [$PROXY]: any;
+    [STORE_VALUE]: Record<PropertyKey, any>;
+    [STORE_OVERRIDE]?: Record<PropertyKey, any>;
+    [STORE_OPTIMISTIC_OVERRIDE]?: Record<PropertyKey, any>;
+    [STORE_NODE]?: DataNodes;
+    [STORE_HAS]?: DataNodes;
+    [STORE_CUSTOM_PROTO]?: boolean;
+    [STORE_WRAP]?: (value: any, target?: StoreNode) => any;
+    [STORE_LOOKUP]?: WeakMap<any, any>;
+    [STORE_FIREWALL]?: Computed<any>;
+    [STORE_OPTIMISTIC]?: boolean;
+    [STORE_SNAPSHOT_PROPS]?: Record<PropertyKey, any>;
+};
+export declare namespace SolidStore {
+    interface Unwrappable {
+    }
+}
+export type NotWrappable = string | number | bigint | symbol | boolean | Function | null | undefined | SolidStore.Unwrappable[keyof SolidStore.Unwrappable];
+export declare function createStoreProxy<T extends object>(value: T, traps?: ProxyHandler<StoreNode>, extend?: (target: StoreNode) => void): any;
+export declare const storeLookup: WeakMap<WeakKey, any>;
+export declare function wrap<T extends Record<PropertyKey, any>>(value: T, target?: StoreNode): T;
+export declare function isWrappable<T>(obj: T | NotWrappable): obj is T;
+export declare function setWriteOverride(value: boolean): void;
+export declare function trackSelf(target: StoreNode, symbol?: symbol): void;
+export declare function getKeys(source: Record<PropertyKey, any>, override: Record<PropertyKey, any> | undefined, enumerable?: boolean): PropertyKey[];
+export declare function getPropertyDescriptor(source: Record<PropertyKey, any>, override: Record<PropertyKey, any> | undefined, property: PropertyKey): PropertyDescriptor | undefined;
+export declare const storeTraps: ProxyHandler<StoreNode>;
+export declare function storeSetter<T extends object>(store: Store<T>, fn: (draft: T) => T | void): void;
+/**
+ * Creates a deeply-reactive store backed by a Proxy. Reads track each property
+ * accessed; only the parts that change trigger updates.
+ *
+ * Store properties hold **plain values**, not accessors. The proxy already
+ * tracks reads per-property — wrapping a value in `() => state.foo` produces
+ * a getter that *won't* track when called, which looks like a reactivity bug
+ * but is just a category error. If you have a signal-shaped piece of state,
+ * make it a property of the store (`{ foo: 1 }`) rather than nesting an
+ * accessor inside (`{ foo: () => signal() }`).
+ *
+ * The setter takes a **draft-mutating** function — mutate the draft in place
+ * (canonical). The callback may also return a new value: arrays are replaced
+ * by index (length adjusted), objects are shallow-diffed at the top level
+ * (keys present in the returned value are written, missing keys deleted). Use
+ * the return form for shapes where mutation is awkward — most commonly
+ * removing items via `filter`. The setter does **not** do keyed reconciliation;
+ * for that, use the derived/projection form (or `createProjection`).
+ *
+ * - Plain form: `createStore(initialValue)` — wraps a value in a reactive
+ *   proxy.
+ * - Derived form: `createStore(fn, seed, options?)` — a *projection store*
+ *   whose contents are computed by `fn(draft)`. `fn` may be sync, async, or
+ *   an `AsyncIterable`; the projection's result reconciles against the
+ *   existing store by `options.key` (default `"id"`) for stable identity.
+ *
+ * @example
+ * ```ts
+ * const [state, setState] = createStore({
+ *   user: { name: "Ada", age: 36 },
+ *   todos: [] as { id: string; text: string; done: boolean }[]
+ * });
+ *
+ * // Canonical: mutate the draft in place.
+ * setState(s => { s.user.age = 37; });
+ * setState(s => { s.todos.push({ id: "1", text: "x", done: false }); });
+ *
+ * // Return form: reach for it when mutation is awkward.
+ * setState(s => s.todos.filter(t => !t.done));               // remove items
+ * setState(s => ({ ...s, user: { name: "Grace", age: 85 } })); // shallow replace
+ * ```
+ *
+ * @example
+ * ```ts
+ * // Derived store — auto-fetches & reconciles by `id`.
+ * const [users] = createStore(
+ *   async () => fetch("/users").then(r => r.json()),
+ *   [] as User[]
+ * );
+ * ```
+ *
+ * @returns `[store: Store<T>, setStore: StoreSetter<T>]`
+ */
+export declare function createStore<T extends object = {}>(store: NoFn<T> | Store<NoFn<T>>): [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 {};

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

@@ -0,0 +1,58 @@
+import { type NotWrappable } from "./store.js";
+type W<T> = Exclude<T, NotWrappable>;
+type KeyOf<T> = number extends keyof T ? 0 extends 1 & T ? keyof T : [T] extends [never] ? never : [T] extends [readonly unknown[]] ? number : keyof T : keyof T;
+export type CustomPartial<T> = T extends readonly unknown[] ? "0" extends keyof T ? {
+    [K in Extract<keyof T, `${number}`>]?: T[K];
+} : {
+    [x: number]: T[number];
+} : Partial<T>;
+export type StorePathRange = {
+    from?: number;
+    to?: number;
+    by?: number;
+};
+export type ArrayFilterFn<T> = (item: T, index: number) => boolean;
+export type PathSetter<T> = T | CustomPartial<T> | ((prev: T) => T | CustomPartial<T>) | typeof DELETE;
+export type Part<T, K extends KeyOf<T> = KeyOf<T>> = K | ([K] extends [never] ? never : readonly K[]) | ([T] extends [readonly unknown[]] ? ArrayFilterFn<T[number]> | StorePathRange : never);
+declare const DELETE: unique symbol;
+export interface storePath {
+    DELETE: typeof DELETE;
+    <T, K1 extends KeyOf<W<T>>, K2 extends KeyOf<W<W<T>[K1]>>, K3 extends KeyOf<W<W<W<T>[K1]>[K2]>>, K4 extends KeyOf<W<W<W<W<T>[K1]>[K2]>[K3]>>, K5 extends KeyOf<W<W<W<W<W<T>[K1]>[K2]>[K3]>[K4]>>, K6 extends KeyOf<W<W<W<W<W<W<T>[K1]>[K2]>[K3]>[K4]>[K5]>>, K7 extends KeyOf<W<W<W<W<W<W<W<T>[K1]>[K2]>[K3]>[K4]>[K5]>[K6]>>>(k1: Part<W<T>, K1>, k2: Part<W<W<T>[K1]>, K2>, k3: Part<W<W<W<T>[K1]>[K2]>, K3>, k4: Part<W<W<W<W<T>[K1]>[K2]>[K3]>, K4>, k5: Part<W<W<W<W<W<T>[K1]>[K2]>[K3]>[K4]>, K5>, k6: Part<W<W<W<W<W<W<T>[K1]>[K2]>[K3]>[K4]>[K5]>, K6>, k7: Part<W<W<W<W<W<W<W<T>[K1]>[K2]>[K3]>[K4]>[K5]>[K6]>, K7>, setter: PathSetter<W<W<W<W<W<W<W<T>[K1]>[K2]>[K3]>[K4]>[K5]>[K6]>[K7]>): (state: T) => void;
+    <T, K1 extends KeyOf<W<T>>, K2 extends KeyOf<W<W<T>[K1]>>, K3 extends KeyOf<W<W<W<T>[K1]>[K2]>>, K4 extends KeyOf<W<W<W<W<T>[K1]>[K2]>[K3]>>, K5 extends KeyOf<W<W<W<W<W<T>[K1]>[K2]>[K3]>[K4]>>, K6 extends KeyOf<W<W<W<W<W<W<T>[K1]>[K2]>[K3]>[K4]>[K5]>>>(k1: Part<W<T>, K1>, k2: Part<W<W<T>[K1]>, K2>, k3: Part<W<W<W<T>[K1]>[K2]>, K3>, k4: Part<W<W<W<W<T>[K1]>[K2]>[K3]>, K4>, k5: Part<W<W<W<W<W<T>[K1]>[K2]>[K3]>[K4]>, K5>, k6: Part<W<W<W<W<W<W<T>[K1]>[K2]>[K3]>[K4]>[K5]>, K6>, setter: PathSetter<W<W<W<W<W<W<T>[K1]>[K2]>[K3]>[K4]>[K5]>[K6]>): (state: T) => void;
+    <T, K1 extends KeyOf<W<T>>, K2 extends KeyOf<W<W<T>[K1]>>, K3 extends KeyOf<W<W<W<T>[K1]>[K2]>>, K4 extends KeyOf<W<W<W<W<T>[K1]>[K2]>[K3]>>, K5 extends KeyOf<W<W<W<W<W<T>[K1]>[K2]>[K3]>[K4]>>>(k1: Part<W<T>, K1>, k2: Part<W<W<T>[K1]>, K2>, k3: Part<W<W<W<T>[K1]>[K2]>, K3>, k4: Part<W<W<W<W<T>[K1]>[K2]>[K3]>, K4>, k5: Part<W<W<W<W<W<T>[K1]>[K2]>[K3]>[K4]>, K5>, setter: PathSetter<W<W<W<W<W<T>[K1]>[K2]>[K3]>[K4]>[K5]>): (state: T) => void;
+    <T, K1 extends KeyOf<W<T>>, K2 extends KeyOf<W<W<T>[K1]>>, K3 extends KeyOf<W<W<W<T>[K1]>[K2]>>, K4 extends KeyOf<W<W<W<W<T>[K1]>[K2]>[K3]>>>(k1: Part<W<T>, K1>, k2: Part<W<W<T>[K1]>, K2>, k3: Part<W<W<W<T>[K1]>[K2]>, K3>, k4: Part<W<W<W<W<T>[K1]>[K2]>[K3]>, K4>, setter: PathSetter<W<W<W<W<T>[K1]>[K2]>[K3]>[K4]>): (state: T) => void;
+    <T, K1 extends KeyOf<W<T>>, K2 extends KeyOf<W<W<T>[K1]>>, K3 extends KeyOf<W<W<W<T>[K1]>[K2]>>>(k1: Part<W<T>, K1>, k2: Part<W<W<T>[K1]>, K2>, k3: Part<W<W<W<T>[K1]>[K2]>, K3>, setter: PathSetter<W<W<W<T>[K1]>[K2]>[K3]>): (state: T) => void;
+    <T, K1 extends KeyOf<W<T>>, K2 extends KeyOf<W<W<T>[K1]>>>(k1: Part<W<T>, K1>, k2: Part<W<W<T>[K1]>, K2>, setter: PathSetter<W<W<T>[K1]>[K2]>): (state: T) => void;
+    <T, K1 extends KeyOf<W<T>>>(k1: Part<W<T>, K1>, setter: PathSetter<W<T>[K1]>): (state: T) => void;
+    <T>(setter: PathSetter<T>): (state: T) => void;
+}
+/**
+ * Path-based setter helper for `createStore`. Call `storePath(...path, value)`
+ * to produce a draft-mutating function suitable for passing to `setStore`.
+ *
+ * The canonical setter form in Solid 2.0 is the draft-mutating callback
+ * (`setStore(s => { s.user.name = "Ada"; })`). `storePath` is a backwards-
+ * compatibility helper for users porting from Solid 1.x's
+ * `setStore("user", "name", "Ada")` style — it's optional and you can mix the
+ * two styles freely.
+ *
+ * Path parts can be:
+ * - a single key — `"user"`, `0`
+ * - an array of keys — `[0, 1, 2]`
+ * - a range over an array — `{ from?, to?, by? }`
+ * - a filter `(item, index) => boolean` for arrays
+ *
+ * The final argument is the new value or an updater `(prev) => next`. Use
+ * `storePath.DELETE` to remove a property.
+ *
+ * @example
+ * ```ts
+ * const [state, setState] = createStore({ user: { name: "Ada" }, todos: [] });
+ *
+ * setState(storePath("user", "name", "Grace"));
+ * setState(storePath("todos", t => !t.done, "done", true)); // mark all undone as done
+ * setState(storePath("user", "nickname", storePath.DELETE));
+ * ```
+ */
+export declare const storePath: storePath;
+export {};

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

@@ -0,0 +1,114 @@
+/**
+ * Returns a plain (non-proxy, non-reactive) deep copy of a store value.
+ * Reading via `snapshot` does **not** subscribe to changes — use this when you
+ * need to hand a stable plain object to non-reactive code (logging,
+ * serialization, structured-clone, network payloads, etc.).
+ *
+ * Returns the original object identity for any sub-tree that wasn't modified
+ * relative to the proxy's underlying source.
+ *
+ * @example
+ * ```ts
+ * const [state] = createStore({ user: { name: "Ada" }, todos: [] });
+ *
+ * console.log(JSON.stringify(snapshot(state))); // safe, non-reactive copy
+ * ```
+ */
+export declare function snapshot<T>(item: T): T;
+export declare function snapshot<T>(item: T, map?: Map<unknown, unknown>, lookup?: WeakMap<any, any>): T;
+/**
+ * Returns a plain (non-proxy) deep copy **and** subscribes the current
+ * tracking scope to every nested change in the source store. Any write
+ * anywhere in the subtree invalidates the consumer.
+ *
+ * Use this when you need plain data inside a reactive scope and want to
+ * react to deep mutations (e.g. passing a snapshot to `reconcile()` or to a
+ * memo that should rerun on any nested change). For most read paths, prefer
+ * direct property access — Solid stores already track per-property reads
+ * with no `deep()` wrapper needed.
+ *
+ * @example
+ * ```ts
+ * const [state] = createStore({ a: { b: { c: 1 } } });
+ *
+ * createEffect(
+ *   () => deep(state),                  // reruns on any nested change
+ *   plain => sendToWorker(plain)        // worker gets a non-proxy copy
+ * );
+ * ```
+ */
+export declare function deep<T extends object>(store: T): T;
+type DistributeOverride<T, F> = T extends undefined ? F : T;
+type Override<T, U> = T extends any ? U extends any ? {
+    [K in keyof T]: K extends keyof U ? DistributeOverride<U[K], T[K]> : T[K];
+} & {
+    [K in keyof U]: K extends keyof T ? DistributeOverride<U[K], T[K]> : U[K];
+} : T & U : T & U;
+type OverrideSpread<T, U> = T extends any ? {
+    [K in keyof ({
+        [K in keyof T]: any;
+    } & {
+        [K in keyof U]?: any;
+    } & {
+        [K in U extends any ? keyof U : keyof U]?: any;
+    })]: K extends keyof T ? Exclude<U extends any ? U[K & keyof U] : never, undefined> | T[K] : U extends any ? U[K & keyof U] : never;
+} : T & U;
+type Simplify<T> = T extends any ? {
+    [K in keyof T]: T[K];
+} : T;
+type _Merge<T extends unknown[], Curr = {}> = T extends [
+    infer Next | (() => infer Next),
+    ...infer Rest
+] ? _Merge<Rest, Override<Curr, Next>> : T extends [...infer Rest, infer Next | (() => infer Next)] ? Override<_Merge<Rest, Curr>, Next> : T extends [] ? Curr : T extends (infer I | (() => infer I))[] ? OverrideSpread<Curr, I> : Curr;
+export type Merge<T extends unknown[]> = Simplify<_Merge<T>>;
+/**
+ * Merges multiple props-like objects into a single proxy that *preserves
+ * reactivity*. Reads are forwarded to the right-most source that defines the
+ * property, so later sources override earlier ones (like `Object.assign`).
+ *
+ * Function arguments are treated as memo-backed sources — useful for passing
+ * derived defaults whose computation should track reactively.
+ *
+ * Use this in component bodies to merge defaults / overrides without losing
+ * Solid's per-property tracking.
+ *
+ * @example
+ * ```tsx
+ * function Button(_props: { label: string; type?: string; disabled?: boolean }) {
+ *   const props = merge({ type: "button", disabled: false }, _props);
+ *
+ *   return <button type={props.type} disabled={props.disabled}>{props.label}</button>;
+ * }
+ * ```
+ */
+export declare function merge<T extends unknown[]>(...sources: T): Merge<T>;
+export type Omit<T, K extends readonly (keyof T)[]> = {
+    [P in keyof T as Exclude<P, K[number]>]: T[P];
+};
+/**
+ * Returns a reactive proxy of `props` with the listed keys hidden. Tracking
+ * on the remaining keys is preserved.
+ *
+ * Use it to forward "rest" props to a child element while pulling out the
+ * keys your component handles itself — the equivalent of `splitProps(p, ["a","b"])[1]`.
+ *
+ * @example
+ * ```tsx
+ * function Input(props: { label: string; value: string; onInput: (v: string) => void } & JSX.HTMLAttributes<HTMLInputElement>) {
+ *   const rest = omit(props, "label", "value", "onInput");
+ *
+ *   return (
+ *     <label>
+ *       {props.label}
+ *       <input
+ *         {...rest}
+ *         value={props.value}
+ *         onInput={e => props.onInput(e.currentTarget.value)}
+ *       />
+ *     </label>
+ *   );
+ * }
+ * ```
+ */
+export declare function omit<T extends Record<any, any>, K extends readonly (keyof T)[]>(props: T, ...keys: K): Omit<T, K>;
+export {};

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

@@ -73,7 +73,7 @@ export declare class CollectionQueue extends Queue {
  */
 export declare function createLoadingBoundary(fn: () => any, fallback: () => any, options?: {
     on?: () => any;
-}): import("./signals.cjs").Accessor<unknown>;
+}): import("./signals.cjs").SourceAccessor<unknown>;
 /**
  * Lower-level primitive that backs the `<Errored>` flow control. Catches
  * thrown errors inside `fn` and invokes `fallback(error, reset)` instead.
@@ -97,7 +97,7 @@ export declare function createLoadingBoundary(fn: () => any, fallback: () => any
  * }
  * ```
  */
-export declare function createErrorBoundary<U>(fn: () => any, fallback: (error: unknown, reset: () => void) => U): import("./signals.cjs").Accessor<unknown>;
+export declare function createErrorBoundary<U>(fn: () => any, fallback: (error: unknown, reset: () => void) => U): import("./signals.cjs").SourceAccessor<unknown>;
 /**
  * Coordinate the reveal timing of sibling loading boundaries.
  *

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

@@ -9,12 +9,14 @@ export declare const REACTIVE_DISPOSED: number;
 export declare const REACTIVE_OPTIMISTIC_DIRTY: number;
 export declare const REACTIVE_SNAPSHOT_STALE: number;
 export declare const REACTIVE_LAZY: number;
+export declare const REACTIVE_MANUAL_WRITE: number;
 export declare const CONFIG_OWNED_WRITE: number;
 export declare const CONFIG_NO_SNAPSHOT: number;
 export declare const CONFIG_TRANSPARENT: number;
 export declare const CONFIG_IN_SNAPSHOT_SCOPE: number;
 export declare const CONFIG_CHILDREN_FORBIDDEN: number;
 export declare const CONFIG_AUTO_DISPOSE: number;
+export declare const CONFIG_SYNC: number;
 export declare const STATUS_NONE = 0;
 export declare const STATUS_PENDING: number;
 export declare const STATUS_ERROR: number;
@@ -37,12 +39,12 @@ export declare const defaultContext: {};
  */
 export declare const $REFRESH: unique symbol;
 /**
- * Brand applied to derived/projected stores indicating they participate in
- * the `refresh()` re-run protocol. Use this alias instead of inlining
- * `T & { [$REFRESH]: any }` so that user-defined hooks that wrap
- * `createOptimisticStore` / `createProjection` / projection-form
- * `createStore` can have their return types inferred without leaking the
- * internal `$REFRESH` symbol into public type signatures (TS4058).
+ * Brand applied to values that participate in the `refresh()` re-run protocol.
+ * Accessors receive this handle internally; projected stores expose it through
+ * their public return type so user-defined hooks that wrap `createOptimisticStore`
+ * / `createProjection` / projection-form `createStore` can have their return
+ * types inferred without leaking the internal `$REFRESH` symbol into public type
+ * signatures (TS4058).
  */
 export type Refreshable<T> = T & {
     readonly [$REFRESH]: any;

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

@@ -19,6 +19,13 @@ 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>, options?: NodeOptions<T>): Computed<T>;
+/**
+ * Build an Effect node with all effect-specific fields baked into a single object literal,
+ * so V8 sees the full hidden class shape at construction time. Effects always run in lazy
+ * mode (recompute is called explicitly by `effect()`), so we hardcode the lazy bits and skip
+ * the auto-dispose CONFIG bit (effect() previously cleared it post-construction).
+ */
+export declare function createEffectNode<T>(fn: (prev?: T) => T, effectFn: (val: T, prev: T | undefined) => void | (() => void), errorFn: ((err: unknown, cleanup: () => void) => void | (() => void)) | undefined, type: number, notifyStatus: ((status?: number, error?: any) => void) | undefined, options: NodeOptions<T> | undefined): any;
 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>;
@@ -55,6 +62,21 @@ export declare function setStrictRead(v: string | false): string | false;
 export declare function untrack<T>(fn: () => T, strictReadLabel?: string | false): T;
 export declare function read<T>(el: Signal<T> | Computed<T>): T;
 export declare function setSignal<T>(el: Signal<T> | Computed<T>, v: T | ((prev: T) => T)): T;
+/**
+ * Suppresses automatic recomputation of `el` until the scheduler drains. Used
+ * when a manual write should win over dependency changes queued in the same
+ * tick. The MANUAL_WRITE flag is cleared by the pending-node drain; projection
+ * computeds don't commit values, but they still need the same end-of-tick
+ * cleanup point.
+ */
+export declare function suppressComputedRecompute(el: Computed<unknown>): void;
+/**
+ * User-facing setter for the memo form of `createSignal(fn)`. Behaves like
+ * `setSignal`, but also cancels any pending recompute of the memo so the
+ * manual value wins over a value that would otherwise be produced by an
+ * upstream change in the same tick.
+ */
+export declare function setMemo<T>(el: Computed<T>, v: T | ((prev: T) => T)): T;
 /**
  * Executes `fn` with the given `owner` set as the current owner. Any reactive
  * primitives (`createSignal`, `createMemo`, `createEffect`, `onCleanup`,
@@ -117,14 +139,13 @@ export declare function latest<T>(fn: () => T): T;
  */
 export declare function isPending(fn: () => any): boolean;
 /**
- * Forces a reactive source to re-execute, even if its inputs haven't changed.
+ * Invalidates one reactive source, forcing it to re-execute even if its inputs
+ * haven't changed.
  *
- * Two forms:
- * - `refresh(memo)` — pass an accessor (memo / signal getter) and its
- *   underlying computation reruns.
- * - `refresh(store)` — pass a *projected* store created from
- *   `createStore(fn, ...)` or `createProjection(...)` and the projection
- *   recomputes.
+ * Pass either a Solid-created accessor or a projected store created from
+ * `createStore(fn, ...)` / `createProjection(...)`. `refresh()` is a
+ * write-like invalidation operation: it does not read the target's value, and
+ * refreshing a plain signal accessor is a no-op.
  *
  * Use it to invalidate cached async values (e.g. force a re-fetch) without
  * tearing the consumer down.
@@ -137,7 +158,7 @@ export declare function isPending(fn: () => any): boolean;
  * <button onClick={() => refresh(user)}>Reload</button>
  * ```
  */
-export declare function refresh<T>(fn: (() => T) | Refreshable<T>): T;
+export declare function refresh<T>(target: Refreshable<T>): void;
 /**
  * Returns `true` while a `refresh()` call is in progress. Useful for showing
  * a "refreshing" indicator distinct from the initial-load `<Loading>`

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

@@ -6,7 +6,7 @@ export interface DevHooks {
     onStoreNodeUpdate?: (state: any, property: PropertyKey, value: any, prev: any) => void;
 }
 export type DiagnosticSeverity = "warn" | "error";
-export type DiagnosticCode = "STRICT_READ_UNTRACKED" | "PENDING_ASYNC_UNTRACKED_READ" | "PENDING_ASYNC_FORBIDDEN_SCOPE" | "SIGNAL_WRITE_IN_OWNED_SCOPE" | "RUN_WITH_DISPOSED_OWNER" | "NO_OWNER_CLEANUP" | "CLEANUP_IN_FORBIDDEN_SCOPE" | "PRIMITIVE_IN_FORBIDDEN_SCOPE" | "NO_OWNER_EFFECT" | "NO_OWNER_BOUNDARY" | "ASYNC_OUTSIDE_LOADING_BOUNDARY" | "MISSING_EFFECT_FN";
+export type DiagnosticCode = "STRICT_READ_UNTRACKED" | "PENDING_ASYNC_UNTRACKED_READ" | "PENDING_ASYNC_FORBIDDEN_SCOPE" | "SIGNAL_WRITE_IN_OWNED_SCOPE" | "RUN_WITH_DISPOSED_OWNER" | "NO_OWNER_CLEANUP" | "CLEANUP_IN_FORBIDDEN_SCOPE" | "PRIMITIVE_IN_FORBIDDEN_SCOPE" | "NO_OWNER_EFFECT" | "NO_OWNER_BOUNDARY" | "ASYNC_OUTSIDE_LOADING_BOUNDARY" | "INVALID_REFRESH_TARGET" | "MISSING_EFFECT_FN" | "SYNC_NODE_RECEIVED_ASYNC";
 export type DiagnosticKind = "strict-read" | "async" | "write" | "lifecycle" | "owner";
 export interface DiagnosticEvent {
     sequence: number;

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

@@ -3,6 +3,7 @@ export interface Effect<T> extends Computed<T>, Owner {
     _effectFn: (val: T, prev: T | undefined) => void | (() => void);
     _errorFn?: (err: unknown, cleanup: () => void) => void;
     _cleanup?: () => void;
+    _cleanupRegistered?: boolean;
     _modified: boolean;
     _prevValue: T | undefined;
     _type: number;

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

@@ -1,4 +1,5 @@
 import type { Computed, Link, Signal } from "./types.cjs";
 export declare function unlinkSubs(link: Link): Link | null;
+export declare function trimStaleDeps(el: Computed<any>): void;
 export declare function unobserved(el: Computed<unknown>): void;
 export declare function link(dep: Signal<any> | Computed<any>, sub: Computed<any>): void;

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

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

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

@@ -67,28 +67,33 @@ export declare class Queue implements IQueue {
 }
 export declare class GlobalQueue extends Queue {
     _running: boolean;
+    _pendingNode: Signal<any> | null;
     _pendingNodes: Signal<any>[];
     _optimisticNodes: OptimisticNode[];
     _optimisticStores: Set<any>;
     static _update: (el: Computed<unknown>) => void;
     static _dispose: (el: Computed<unknown>, self: boolean, zombie: boolean) => void;
+    static _runEffect: (el: Computed<unknown>) => void;
     static _clearOptimisticStore: ((store: any) => void) | null;
     flush(): void;
     notify(node: Computed<any>, mask: number, flags: number, error?: any): boolean;
     initTransition(transition?: Transition | null): void;
 }
+export declare function queuePendingNode(node: Signal<any>): void;
 export declare function insertSubs(node: Signal<any> | Computed<any>, optimistic?: boolean): void;
 export declare function finalizePureQueue(completingTransition?: Transition | null, incomplete?: boolean): void;
 export declare function trackOptimisticStore(store: any): void;
 export declare const globalQueue: GlobalQueue;
 /**
- * Synchronously processes the pending reactive queue: runs every scheduled
- * memo/effect/computation that has dirty inputs, until the graph is settled.
+ * Synchronously processes the pending reactive queue, or runs `fn` in a synchronous
+ * flush scope before draining the queue.
  *
  * Reactive updates are normally batched onto the microtask queue, so multiple
  * writes in a row collapse into a single update pass. Call `flush()` when you
  * need to *observe* the result of those writes synchronously — most commonly
- * in tests, but also at the boundary of imperative integration code.
+ * in tests, but also at the boundary of imperative integration code. Pass a
+ * callback when the writes themselves should bypass microtask scheduling and
+ * drain synchronously when the callback returns.
  *
  * @example
  * ```ts
@@ -98,9 +103,20 @@ export declare const globalQueue: GlobalQueue;
  * setCount(5);
  * flush();
  * expect(doubled()).toBe(10);
+ *
+ * flush(() => setCount(6));
+ * expect(doubled()).toBe(12);
+ *
+ * // Nested flushes drain at each level:
+ * flush(() => {
+ *   setCount(7);
+ *   flush(() => setCount(8)); // inner drain — effects fire here
+ *   // outer continues with up-to-date state
+ * });
  * ```
  */
 export declare function flush(): void;
+export declare function flush<T>(fn: () => T): T;
 export declare function currentTransition(transition: Transition): Transition;
 export declare function setActiveTransition(transition: Transition | null): void;
 export declare function runInTransition<T>(transition: Transition, fn: () => T): T;

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

@@ -21,6 +21,7 @@ export interface NodeOptions<T> {
     _noSnapshot?: boolean;
     unobserved?: () => void;
     lazy?: boolean;
+    sync?: boolean;
 }
 export interface RawSignal<T> {
     _subs: Link | null;
@@ -56,6 +57,7 @@ export interface Owner {
     _queue: IQueue;
     _firstChild: Owner | null;
     _nextSibling: Owner | null;
+    _prevSibling: Owner | null;
     _pendingDisposal: Disposable | Disposable[] | null;
     _pendingFirstChild: Owner | null;
 }

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

@@ -3,7 +3,7 @@ import { type Dev } from "./core/index.cjs";
 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.cjs";
 export { createSignal, createMemo, createEffect, createRenderEffect, createTrackedEffect, createReaction, createOptimistic, resolve, onSettled, onCleanup } from "./signals.cjs";
-export type { Accessor, Setter, Signal, ComputeFunction, EffectFunction, EffectBundle, EffectOptions, SignalOptions, MemoOptions, NoInfer } from "./signals.cjs";
+export type { Accessor, SourceAccessor, 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, type RevealOrder } from "./boundaries.cjs";

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

@@ -2,8 +2,14 @@ import { type Accessor } from "./signals.cjs";
 export type Maybe<T> = T | void | null | undefined | false;
 /**
  * Reactively maps an array, reusing the previously-mapped value for unchanged
- * items. The callback receives `(value, index)` as accessors so individual
- * items and indexes can be subscribed to without re-running the mapper.
+ * items.
+ *
+ * The callback shape follows the keying mode:
+ * - default / `keyed: true` receives `(item, index)` where `item` is the raw
+ *   row value and `index` is an accessor.
+ * - `keyed: false` receives `(item, index)` where `item` is an accessor and
+ *   `index` is a stable number.
+ * - `keyed: item => key` receives accessors for both arguments.
  *
  * This is the underlying helper that powers `<For>`. App code should use
  * `<For>` directly; reach for `mapArray` when implementing custom list
@@ -19,15 +25,25 @@ export type Maybe<T> = T | void | null | undefined | false;
  * ```ts
  * const view = mapArray(
  *   items,
- *   (item, index) => `${index()}: ${item().label}`,
+ *   (item, index) => `${index()}: ${item.label}`,
  *   { fallback: () => "no items" }
  * );
  * ```
  *
  * @description https://docs.solidjs.com/reference/reactive-utilities/map-array
  */
-export declare function mapArray<Item, MappedItem>(list: Accessor<Maybe<readonly Item[]>>, map: (value: Accessor<Item>, index: Accessor<number>) => MappedItem, options?: {
-    keyed?: boolean | ((item: Item) => any);
+export declare function mapArray<Item, MappedItem>(list: Accessor<Maybe<readonly Item[]>>, map: (value: Item, index: Accessor<number>) => MappedItem, options?: {
+    keyed?: true;
+    fallback?: Accessor<any>;
+    name?: string;
+}): Accessor<MappedItem[]>;
+export declare function mapArray<Item, MappedItem>(list: Accessor<Maybe<readonly Item[]>>, map: (value: Accessor<Item>, index: number) => MappedItem, options: {
+    keyed: false;
+    fallback?: Accessor<any>;
+    name?: string;
+}): Accessor<MappedItem[]>;
+export declare function mapArray<Item, MappedItem>(list: Accessor<Maybe<readonly Item[]>>, map: (value: Accessor<Item>, index: Accessor<number>) => MappedItem, options: {
+    keyed: (item: Item) => any;
     fallback?: Accessor<any>;
     name?: string;
 }): Accessor<MappedItem[]>;