@solidjs/signals 2.0.0-beta.15 → 2.0.0-beta.17

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

@@ -1,45 +0,0 @@
-import { type Refreshable } from "../core/index.js";
-import { type NoFn, type ProjectionOptions, type Store, type StoreSetter } from "./store.js";
-/**
- * The store equivalent of `createOptimistic`. Writes inside an `action`
- * transition are tentative — they show up immediately but auto-revert (or
- * reconcile to the action's resolved value) once the transition finishes.
- *
- * Use this for optimistic UI on collection-shaped data. For single-value
- * optimistic state, prefer `createOptimistic`.
- *
- * - Plain form: `createOptimisticStore(initialValue)`.
- * - Derived form: `createOptimisticStore(fn, seed, options?)` — a projection
- *   store whose authoritative value is recomputed by `fn` and whose
- *   optimistic overlay reverts after each transition.
- *
- * `options.key` defaults to `"id"`; specify it only when your data uses a
- * different identity field (e.g. `{ key: "uuid" }` or `{ key: t => t.slug }`).
- * Restating the default just adds noise.
- *
- * @example
- * ```ts
- * const [todos, setTodos] = createOptimisticStore<Todo[]>([]);
- *
- * // Mutation: optimistic add, then in-place reconcile to the saved row.
- * const addTodo = action(function* (text: string) {
- *   const tempId = crypto.randomUUID();
- *   setTodos(t => { t.push({ id: tempId, text, pending: true }); });
- *   const saved = yield api.createTodo(text);
- *   setTodos(t => {
- *     const i = t.findIndex(x => x.id === tempId);
- *     if (i >= 0) t[i] = saved;
- *   });
- * });
- *
- * // Return form: filter is the natural shape for removal.
- * const removeTodo = action(function* (id: string) {
- *   setTodos(t => t.filter(x => x.id !== id));
- *   yield api.removeTodo(id);
- * });
- * ```
- *
- * @returns `[store: Store<T>, setStore: StoreSetter<T>]`
- */
-export declare function createOptimisticStore<T extends object = {}>(store: NoFn<T> | Store<NoFn<T>>): [get: Store<T>, set: StoreSetter<T>];
-export declare function createOptimisticStore<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>];

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

@@ -1,66 +0,0 @@
-import { type Computed, type Refreshable } from "../core/index.js";
-import { type ProjectionOptions, type Store } from "./store.js";
-export declare function createProjectionInternal<T extends object = {}>(fn: (draft: T) => void | T | Promise<void | T> | AsyncIterable<void | T>, seed: Partial<T>, options?: ProjectionOptions): {
-    store: Refreshable<Store<T>>;
-    node: Computed<void | T>;
-};
-/**
- * Creates a derived (projected) store. Like `createMemo` but for stores: the
- * derive function receives a mutable draft and either mutates it in place
- * (canonical) or returns a new value. Either way the result is reconciled
- * against the previous draft by `options.key` (default `"id"`), so surviving
- * items keep their proxy identity — only added/removed items are
- * created/disposed.
- *
- * Returns the projected store directly (no setter — reads only).
- *
- * Use this when you want the structural-sharing / per-property tracking
- * behaviour of a store on top of a derived computation. For simple read-only
- * derivations, `createMemo` is lighter.
- *
- * @param fn receives the current draft; mutate it in place or return new
- *   data. Return is convenient for filter/derive shapes where mutation is
- *   awkward.
- * @param seed the backing store value to wrap and reconcile into
- * @param options `ProjectionOptions` — `name`, `key`. `key` defaults to
- *   `"id"`; specify it only when your data uses a different identity field
- *   (e.g. `{ key: "uuid" }` or `{ key: u => u.slug }`).
- *
- * @example
- * ```ts
- * // Mutation form — update individual fields on the draft.
- * const summary = createProjection<{ total: number; active: number }>(
- *   draft => {
- *     draft.total = users().length;
- *     draft.active = users().filter(u => u.active).length;
- *   },
- *   { total: 0, active: 0 }
- * );
- *
- * // Return form — produce a derived collection. Reconciled by `id` so each
- * // surviving user keeps the same store identity across recomputes.
- * const activeUsers = createProjection<User[]>(
- *   () => allUsers().filter(u => u.active),
- *   []
- * );
- * ```
- *
- * @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): Refreshable<Store<T>>;
-/**
- * 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/src/store/reconcile.d.ts

@@ -1,23 +0,0 @@
-/**
- * Returns a draft-mutating function that smart-merges `value` into a store,
- * preserving the identity of items whose `key` field matches between old and
- * new states. Useful when applying server payloads or full-replacement data
- * onto an existing store without losing fine-grained reactivity.
- *
- * Items with the same key are updated in place (only changed properties
- * trigger updates). Items added or removed update the corresponding signals.
- *
- * @param value the next state to merge in
- * @param key property name (string) or extractor function for stable identity
- *
- * @example
- * ```ts
- * const [todos, setTodos] = createStore<Todo[]>([]);
- *
- * async function refresh() {
- *   const fresh = await api.getTodos();
- *   setTodos(reconcile(fresh, "id")); // diff-merge by `id`
- * }
- * ```
- */
-export declare function reconcile<T extends U, U>(value: T, key: string | ((item: NonNullable<any>) => any)): (state: U) => void;

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

@@ -1,125 +0,0 @@
-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

@@ -1,58 +0,0 @@
-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

@@ -1,114 +0,0 @@
-/**
- * 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/src/boundaries.d.cts

@@ -1,173 +0,0 @@
-import { Queue, type Computed, type Effect } from "./core/index.cjs";
-import type { Signal } from "./core/index.cjs";
-export interface BoundaryComputed<T> extends Computed<T> {
-    _propagationMask: number;
-}
-type RevealSlot = CollectionQueue | RevealController;
-type BoolAccessor = () => boolean;
-export type RevealOrder = "sequential" | "together" | "natural";
-type OrderAccessor = () => RevealOrder;
-export declare class RevealController {
-    _orderAccessor: OrderAccessor;
-    _collapsedAccessor: BoolAccessor;
-    _slots: RevealSlot[];
-    _parentController?: RevealController;
-    _disabled: Signal<boolean>;
-    _collapsed: Signal<boolean>;
-    _ready: boolean;
-    _minimallyReady: boolean;
-    _evaluating: boolean;
-    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;
-}
-export declare class CollectionQueue extends Queue {
-    _collectionType: number;
-    _sources: Set<Computed<any>>;
-    _tree?: BoundaryComputed<any>;
-    _pending: boolean;
-    _disabled: Signal<boolean>;
-    _collapsed: Signal<boolean>;
-    _revealController?: RevealController;
-    _initialized: boolean;
-    _onFn: (() => any) | undefined;
-    _prevOn: any;
-    constructor(type: number);
-    run(type: number): void;
-    notify(node: Effect<any>, type: number, flags: number, error?: any): boolean;
-    checkSources(): void;
-}
-/**
- * Lower-level primitive that backs the `<Loading>` flow control. Catches
- * pending async reads inside `fn` and renders `fallback` until they settle.
- *
- * App code should use `<Loading fallback={...}>` instead — reach for this only
- * when authoring custom boundary components.
- *
- * @param fn the tracked subtree
- * @param fallback the fallback shown while async reads in `fn` are unresolved
- * @param options `on` — accessor whose value scopes the boundary; when set,
- *   transitions caused by writes to other reactive sources are *not* caught
- *
- * @example
- * ```tsx
- * // Custom boundary component built on top of the primitive.
- * function MyLoading(props: { fallback: JSX.Element; children: JSX.Element }) {
- *   return createLoadingBoundary(
- *     () => props.children,
- *     () => props.fallback
- *   ) as unknown as JSX.Element;
- * }
- * ```
- */
-export declare function createLoadingBoundary(fn: () => any, fallback: () => any, options?: {
-    on?: () => any;
-}): 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.
- * `reset()` recomputes the failing sources so the boundary can attempt to
- * recover.
- *
- * App code should use `<Errored fallback={...}>` instead — reach for this only
- * when authoring custom boundary components.
- *
- * @example
- * ```tsx
- * // Custom boundary that wraps the primitive and adds telemetry.
- * function TracedErrored(props: { fallback: (e: unknown) => JSX.Element; children: JSX.Element }) {
- *   return createErrorBoundary(
- *     () => props.children,
- *     (err, reset) => {
- *       reportError(err);
- *       return props.fallback(err);
- *     }
- *   ) as unknown as JSX.Element;
- * }
- * ```
- */
-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.
- *
- * 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).
- *
- * @example
- * ```ts
- * // Primitive form of `<Reveal>` — coordinate sibling loading boundaries
- * // programmatically. App code uses the JSX `<Reveal>` component instead.
- * // Both options are accessors so they can react to state changes.
- * createRevealOrder(
- *   () => renderSiblings(),
- *   { order: () => mode(), collapsed: () => true }
- * );
- * ```
- */
-export declare function createRevealOrder<T>(fn: () => T, options?: {
-    order?: OrderAccessor;
-    collapsed?: BoolAccessor;
-}): T;
-/**
- * Resolves a children value to its renderable form: unwraps zero-arg functions
- * (accessors), recursively flattens arrays, and optionally skips
- * non-rendering values (`null`, `undefined`, `true`, `false`, `""`).
- *
- * Used internally by flow components and by the renderer to walk a children
- * tree. App code rarely needs this directly — see `children()` in `solid-js`
- * for the user-facing helper that memoizes the result.
- *
- * @param children value or array of values to flatten
- * @param options
- *   - `skipNonRendered` — drop values that won't render
- *   - `doNotUnwrap` — leave function children as-is (caller will resolve)
- *
- * @example
- * ```ts
- * // Custom renderer walking a children tree manually. Most authors should
- * // use `children()` from solid-js, which memoizes the resolved value.
- * function renderChildren(value: unknown): unknown {
- *   return flatten(value, { skipNonRendered: true });
- * }
- * ```
- */
-export declare function flatten(children: any, options?: {
-    skipNonRendered?: boolean;
-    doNotUnwrap?: boolean;
-}): any;
-export {};

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

@@ -1,35 +0,0 @@
-/**
- * Wraps a generator function so each invocation runs as a single transaction
- * (a "transition") that batches every signal/store write between yields. The
- * surrounding UI sees one atomic update per yielded step; nothing is committed
- * until the action either completes or the next `yield` resolves.
- *
- * Yield promises (or any awaitable) inside the generator — the action waits
- * for each before continuing, but the writes you made beforehand are already
- * visible (or held by `<Loading>` if optimistic). Yield bare values for
- * synchronous batched steps.
- *
- * Each call returns a `Promise` that resolves with the generator's return
- * value, or rejects if it throws. Pair with `createOptimistic` /
- * `createOptimisticStore` to apply tentative writes that auto-revert if the
- * action fails.
- *
- * @example
- * ```ts
- * const [todos, setTodos] = createOptimisticStore<Todo[]>([]);
- *
- * const addTodo = action(function* (text: string) {
- *   const tempId = crypto.randomUUID();
- *   setTodos(t => { t.push({ id: tempId, text, pending: true }); }); // optimistic
- *   const saved = yield api.createTodo(text); // network round-trip
- *   setTodos(t => {
- *     const i = t.findIndex(x => x.id === tempId);
- *     if (i >= 0) t[i] = saved;
- *   });
- *   return saved;
- * });
- *
- * await addTodo("buy milk");
- * ```
- */
-export declare function action<Args extends any[], Y, R>(genFn: (...args: Args) => Generator<Y, R, any> | AsyncGenerator<Y, R, any>): (...args: Args) => Promise<R>;

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

@@ -1,6 +0,0 @@
-import { type OptimisticLane } from "./lanes.cjs";
-import type { Computed } from "./types.cjs";
-export declare function settlePendingSource(el: Computed<any>): void;
-export declare function handleAsync<T>(el: Computed<T>, result: T | PromiseLike<T> | AsyncIterable<T>, setter?: (value: T) => void): T;
-export declare function clearStatus(el: Computed<any>, clearUninitialized?: boolean): void;
-export declare function notifyStatus(el: Computed<any>, status: number, error: any, blockStatus?: boolean, lane?: OptimisticLane): void;