@solidjs/signals 2.0.0-beta.8 → 2.0.0-rc.0

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

@@ -1,27 +1,58 @@
-import { $REFRESH, type Computed } from "../core/index.js";
-import { type ProjectionOptions, type Store } from "./store.js";
+import { type Computed, type Refreshable } from "../core/index.js";
+import { type NoFn, 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: Store<T> & {
-        [$REFRESH]: any;
-    };
+    store: Refreshable<Store<T>>;
     node: Computed<void | T>;
 };
 /**
- * Creates a mutable derived store (projection). The derive function receives a mutable
- * draft and can mutate it directly or return a new value for reconciliation.
+ * 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.
  *
- * ```typescript
- * const store = createProjection<T>(fn, seed, options?: ProjectionOptions);
+ * If the derive returns a different entity than the one currently held (the
+ * `/users/1` → `/users/2` shape), the store swaps to it rather than merging,
+ * and nothing below it is treated as surviving.
+ *
+ * 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 }`), or `null` to merge
+ *   positionally with no keyed pass.
+ *
+ * @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),
+ *   []
+ * );
  * ```
- * @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
  *
  * @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;
-};
+export declare function createProjection<T extends object = {}>(fn: (draft: T) => void | T | Promise<void | T> | AsyncIterable<void | T>, seed: Partial<T> | Store<NoFn<T>>, options?: ProjectionOptions): Refreshable<Store<T>>;
 /**
  * Shared projection computed body used by both `createProjection` and the derived
  * form of `createOptimisticStore`. Encapsulates the write-trap draft, `storeSetter`
@@ -35,6 +66,5 @@ export declare function createProjection<T extends object = {}>(fn: (draft: T) =
  * 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>;
+export declare function runProjectionComputed<T extends object>(wrappedStore: Store<T>, fn: (draft: T) => void | T | Promise<void | T> | AsyncIterable<void | T>, key: string | ((item: NonNullable<any>) => any) | null, wrapCommit?: (write: () => void) => void, onDraftWrite?: () => void): Computed<void | T>;
+export declare function createWriteTraps(isActive?: () => boolean, onDraftWrite?: () => void): ProxyHandler<any>;

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

@@ -1 +1,46 @@
-export declare function reconcile<T extends U, U>(value: T, key: string | ((item: NonNullable<any>) => any)): (state: U) => void;
+/**
+ * Shared body of `reconcile()` and the projection commit. `replace` is the
+ * only difference: a projection commit is a value swap, not a merge — its root
+ * proxy is a cell handed out by `createProjection` that can never change
+ * reference, so a derive returning a different entity is not the slot mistake
+ * `reconcile()` throws on. Nothing below the root survives that swap, which is
+ * the rule the keyed diff already applies at a nested slot on a key mismatch.
+ *
+ * @internal
+ */
+export declare function reconcileState(value: any, state: any, key: any, replace: boolean): void;
+/**
+ * Returns a draft-mutating function that smart-merges `value` into a store,
+ * preserving fine-grained reactivity: only changed leaves trigger updates.
+ *
+ * With a `key` (default `"id"`), array items whose key matches between old
+ * and new states keep their identity (updated in place, moves and removals
+ * update the corresponding signals) — the shape for keyed server payloads.
+ * Items without the key field fall back to positional matching.
+ *
+ * With `key: null`, matching is purely positional: index N of the new array
+ * merges into index N of the old, and object properties merge recursively —
+ * the classic pattern for fixed-shape data that churns in place (dashboards,
+ * monitors), where no keyed diff pass is needed or wanted.
+ *
+ * Merging into a slot that holds a *different* entity throws — the caller
+ * picked the slot, so a key mismatch there is a bug.
+ *
+ * @param value the next state to merge in
+ * @param key property name (string) or extractor function for stable
+ * identity (default `"id"`); pass `null` for positional merging
+ *
+ * @example
+ * ```ts
+ * const [todos, setTodos] = createStore<Todo[]>([]);
+ *
+ * async function refresh() {
+ *   const fresh = await api.getTodos();
+ *   setTodos(reconcile(fresh)); // diff-merge by `id`
+ * }
+ *
+ * // fixed-shape polling data — positional merge
+ * setStats(reconcile(nextStats, null));
+ * ```
+ */
+export declare function reconcile<T extends U, U>(value: T, key?: string | ((item: NonNullable<any>) => any) | null): (state: U) => void;

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

@@ -1,6 +1,27 @@
-import { $REFRESH, STORE_SNAPSHOT_PROPS, type Computed, type Signal } from "../core/index.js";
+import { STORE_SNAPSHOT_PROPS, type Computed, type Refreshable, type Signal } from "../core/index.js";
+import { type Transition } from "../core/scheduler.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;
+/** Tuple returned by the plain `createStore(initialValue)` form. */
+export type StoreReturn<T> = [get: Store<T>, set: StoreSetter<T>];
+/** Tuple returned by the derived `createStore(fn, seed, options?)` form. */
+export type ProjectionStoreReturn<T> = [get: Refreshable<Store<T>>, set: StoreSetter<T>];
 /** Base options for store primitives. */
 export interface StoreOptions {
     /** Debug name (dev mode only) */
@@ -8,26 +29,53 @@ export interface StoreOptions {
 }
 /** 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);
+    /** Key property name or function for reconciliation identity; `null` merges positionally */
+    key?: string | ((item: NonNullable<any>) => any) | null;
+    /** Single-layer store: root keys reactive, values raw records replaced by reference */
+    shallow?: boolean;
+    /**
+     * Treat the seed as commit #0: the store is born committed with the seed's
+     * contents, shown until the derive's first real answer lands. While that
+     * first answer is in flight, reads serve the seed everywhere — nothing
+     * suspends to a `<Loading>` boundary, no transition is held, and
+     * `isPending` stays false (the seed answers by declaration; first-load
+     * affordances belong to the data, e.g. a `skeleton: true` field in the
+     * seed). Once the first answer lands (reconciled into the seed), refetches
+     * use normal pending semantics with `isPending` true.
+     *
+     * The store equivalent of `MemoOptions.loadingValue`; the seed already
+     * carries the placeholder shape, so this is just the opt-in.
+     */
+    seedLoadingValue?: boolean;
 }
 export type NoFn<T> = T extends Function ? never : T;
 type DataNode = Signal<any>;
 type DataNodes = Record<PropertyKey, DataNode>;
-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_WRAP = "w", STORE_LOOKUP = "l", STORE_FIREWALL = "f", STORE_OPTIMISTIC = "p";
+/**
+ * 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, $AFFECTS: 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", STORE_OPTIMISTIC_OWNERS = "t", STORE_PARENT = "u", STORE_DESC = "d", STORE_SHALLOW = "s";
 export type StoreNode = {
     [$PROXY]: any;
     [STORE_VALUE]: Record<PropertyKey, any>;
     [STORE_OVERRIDE]?: Record<PropertyKey, any>;
     [STORE_OPTIMISTIC_OVERRIDE]?: Record<PropertyKey, any>;
+    [STORE_OPTIMISTIC_OWNERS]?: Record<PropertyKey, Transition | null>;
     [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>;
+    [STORE_PARENT]?: StoreNode;
+    [STORE_SHALLOW]?: boolean;
+    [STORE_DESC]?: boolean;
 };
 export declare namespace SolidStore {
     interface Unwrappable {
@@ -36,33 +84,130 @@ export declare namespace SolidStore {
 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 const symbolKeyedRecords: WeakSet<object>;
+export declare function lookupTarget(value: any, lookup?: WeakMap<any, any>): StoreNode | undefined;
+/**
+ * Marks a value as raw: no store will ever wrap it — every store presents it
+ * as-is, tracked by reference at whatever slot holds it and updated by
+ * replacement. Useful for class instances and external objects (editors,
+ * scene graphs, Maps) and for record-shaped data updated wholesale. Sticky
+ * for the value's lifetime.
+ */
+export declare let rawValuesUsed: boolean;
+export declare function isRawValue(value: any): boolean;
+export declare function markRaw<T>(value: T): T;
+export declare function markRawIngest(container: any): void;
 export declare function wrap<T extends Record<PropertyKey, any>>(value: T, target?: StoreNode): T;
+export declare function wrapShallow<T extends Record<PropertyKey, any>>(value: T): T;
 export declare function isWrappable<T>(obj: T | NotWrappable): obj is T;
 export declare function setWriteOverride(value: boolean): void;
+export declare function ownEnumerableKeys(o: object): (string | symbol)[];
+/**
+ * Single chokepoint for the store's layered value resolution: returns the
+ * override layer (optimistic first, then regular) that shadows `property`, or
+ * `undefined` when the base `STORE_VALUE` is authoritative. Every trap must
+ * resolve through this — hand-inlining the layer order is how the optimistic
+ * layer gets missed (#2850).
+ */
+export declare function getOverlayLayer(target: StoreNode, property: PropertyKey): Record<PropertyKey, any> | undefined;
+/**
+ * The value a store leaf's backing signal currently shows to readers: active
+ * override, else held pending value, else committed value.
+ */
+export declare function visibleNodeValue(node: DataNode): any;
+/**
+ * Witness live mark coverage of a record into the active isPending() probe.
+ * Tracked reads don't need this — they go through real signal nodes, which
+ * carry marks directly (declaration walk or birth inheritance). This covers
+ * UNTRACKED probes reading through records whose nodes never materialized
+ * (no observer ever subscribed, so no node exists to carry the mark).
+ * Callers guard on `pendingCheckActive`, so plain reads never pay for this.
+ *
+ * @internal
+ */
+export declare function witnessAffectsMark(target: StoreNode, property?: PropertyKey): void;
+/**
+ * Resolves the store nodes an `affects()` declaration marks: with a `key`,
+ * the named slot's leaf node (upserted so the mark has an addressable
+ * carrier); without, the record's $AFFECTS carrier plus every LIVE node in
+ * its subtree (the edges existing readers subscribed through), with the
+ * subtree's identities snapshotted into the mark's scope so nodes created
+ * during the window — and untracked probes over captured proxies — resolve
+ * against it (#2882).
+ *
+ * @internal
+ */
+export declare function getStoreAffectsNodes(target: StoreNode, key?: PropertyKey): DataNode[];
 export declare function trackSelf(target: StoreNode, symbol?: symbol): void;
+export declare function notifySelf(target: StoreNode): void;
+/**
+ * The write overlay a walk must read through: optimistic writes shadow
+ * regular pending writes, the same resolution order as every proxy trap and
+ * `reconcile` (#2850). Merging allocates only in the rare both-present case
+ * (a derived optimistic store with an in-flight projection commit).
+ */
+export declare function mergedOverlay(target: StoreNode): Record<PropertyKey, any> | undefined;
 export declare function getKeys(source: Record<PropertyKey, any>, override: Record<PropertyKey, any> | undefined, enumerable?: boolean): PropertyKey[];
+export declare function getStoreKeys(source: Record<PropertyKey, any>, override: Record<PropertyKey, any> | undefined): PropertyKey[];
+export declare function getStoreSymbols(source: Record<PropertyKey, any>, override: Record<PropertyKey, any> | undefined): symbol[];
 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 with proxy-based tracking.
+ * Creates a deeply-reactive store backed by a Proxy. Reads track each property
+ * accessed; only the parts that change trigger updates.
  *
- * 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).
+ * 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
+ * ```
  *
- * ```typescript
- * // Plain store
- * const [store, setStore] = createStore<T>(initialValue);
- * // Derived store (projection)
- * const [store, setStore] = createStore<T>(fn, seed, options?: ProjectionOptions);
+ * @example
+ * ```ts
+ * // Derived store — auto-fetches & reconciles by `id`.
+ * const [users] = createStore(
+ *   async () => fetch("/users").then(r => r.json()),
+ *   [] as User[]
+ * );
  * ```
- * @param store initial value to wrap in a reactive proxy, or a derive function
- * @param options `ProjectionOptions` -- name, key (only for derived stores)
  *
  * @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: Store<T> & {
-    [$REFRESH]: any;
-}, set: StoreSetter<T>];
+export declare function createStore<T extends object = {}>(store: NoFn<T> | Store<NoFn<T>>, options?: StoreOptions & {
+    shallow?: boolean;
+}): StoreReturn<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): ProjectionStoreReturn<T>;
 export {};

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

@@ -26,5 +26,33 @@ export interface storePath {
     <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/store/utils.d.ts

@@ -1,15 +1,41 @@
 /**
- * Returns a non reactive copy of the store object.
- * It will attempt to preserver the original reference unless the value has been modified.
- * @param item store proxy object
+ * 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 non-reactive snapshot of the store while subscribing to all nested changes.
- * Subscribes to `$TRACK` at every level so that any deep change triggers recomputation,
- * and returns plain (non-proxy) data. Works correctly with `reconcile()`.
- * @param store store proxy object
+ * 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;
@@ -35,9 +61,54 @@ type _Merge<T extends unknown[], Curr = {}> = T extends [
     ...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/affects.d.cts

@@ -0,0 +1,47 @@
+import type { Accessor } from "./signals.cjs";
+import { type Store } from "./store/store.cjs";
+/**
+ * Declares that in-flight work will change the targeted data: the named
+ * slot(s) — and everything DERIVED from them — read as pending
+ * (`isPending` → `true`) from the declaration until the surrounding
+ * transaction settles or reverts. A mark lives on its own channel — a
+ * refcount on the marked node plus dep-graph reachability in the verdict
+ * layer — so the marked values themselves stay readable (a mark is a promise
+ * of change, not an absence of value), no reader ever suspends on one, and
+ * completion/settlement accounting never sees one. This is the declaration
+ * verb of the pending model — additive only. A mark can turn pending ON for
+ * data the graph can't see changing yet; nothing can turn pending OFF while
+ * a real change is in flight — a quiet `refresh()` re-ask under a mark still
+ * reads pending (declaring the reload is what makes it a real question).
+ *
+ * Targets:
+ * - `affects(store)` — a store proxy (any record, root or nested): every
+ *   record reachable from it at declaration time reads pending, including
+ *   through captured child proxies (e.g. `<For>` rows). Siblings are
+ *   untouched; records added after the declaration are not covered.
+ * - `affects(record, key)` — exactly the named slot of the record. One key
+ *   per call (keys do NOT form a path — target the owning record directly).
+ * - `affects(accessor)` — a source accessor (signal or memo): the source
+ *   reads pending.
+ *
+ * Typically called at the top of an `action` alongside optimistic writes —
+ * both are up-front declarations about the same mutation. Outside any
+ * transaction the mark is released at the end of the current flush.
+ *
+ * @example
+ * ```ts
+ * const send = action(function* (text: string) {
+ *   setState(s => { s.messages.push({ text, status: "sending" }); });
+ *   affects(state.messages.at(-1)!, "status"); // this slot pends until settle
+ *   yield api.send(text);
+ * });
+ *
+ * const reload = action(function* () {
+ *   affects(thing);      // the whole store pends…
+ *   refresh(thing);      // …over this otherwise-quiet re-ask
+ *   yield api.done();
+ * });
+ * ```
+ */
+export declare function affects(target: Accessor<unknown> | Store<object>): void;
+export declare function affects<T extends object>(target: Store<T>, key: keyof T): void;