@solidjs/signals 2.0.0-rc.1 → 2.0.0-rc.10

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

@@ -1,24 +0,0 @@
-/**
- * Store rewrite — projections (§7/§7b): a projection is a computed store.
- * The derive runs inside a computed whose recompute merges its output into
- * the projection's backing through the adoption channel (replace-mode root:
- * entity changes merge in place, the root proxy is stable for life). Children
- * wrap into the projection's own FAMILY (writes land here, never in a source
- * family), and every family node carries the projection computed as its
- * firewall — reads link the derive's status and lifecycle natively. The §6c
- * status gate in the traps makes an uninitialized async derive's seed
- * unobservable through every read surface.
- *
- * Mirrors the legacy runProjectionComputed shape (shadow runs for open
- * loading windows, handleAsync landings, commit-through-setter) on next
- * primitives; the generic draft write-traps are reused from the legacy
- * module unchanged.
- */
-import { type Computed, type Refreshable } from "../../core/index.cjs";
-import { type NoFn, type ProjectionOptions, type Store } from "../store.cjs";
-export declare function createProjectionNext<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>>;
-/** Derived writable store (legacy parity): a projection whose public setter
- * masks the recompute for the tick (core R31 — the manual write wins over a
- * same-flush dependency change). */
-export declare function createStoreDerivedNext<T extends object = {}>(fn: (draft: T) => void | T | Promise<void | T> | AsyncIterable<void | T>, seed: Partial<T> | Store<NoFn<T>>, options?: ProjectionOptions): [Refreshable<Store<T>>, (f: (draft: T) => T | void) => void];
-export declare function runProjectionComputedNext<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>;

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

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

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

@@ -1,71 +0,0 @@
-import type { Signal } from "../../core/types.cjs";
-import { type StoreNextFamily, type StoreNextTarget } from "./target.cjs";
-export declare function wrapNext<T extends Record<PropertyKey, any>>(value: T, parent?: StoreNextTarget | null, parentKey?: PropertyKey | null, fam?: StoreNextFamily | null): T;
-/** Unwrap our own proxies to their current backing; leave everything else. */
-export declare function unwrapValue(v: any): any;
-export declare function getNode(target: StoreNextTarget, key: PropertyKey, current: any): Signal<any>;
-export declare function getHasNode(target: StoreNextTarget, key: PropertyKey, present: boolean): Signal<boolean>;
-export declare function getKeySetNode(target: StoreNextTarget): Signal<number>;
-/** Deep-witness bump: any value/shape change on a record with a live deep()
- * subscriber notifies it. One null check when unused. */
-export declare function bumpDeep(t: StoreNextTarget): void;
-/**
- * Adoption (2026-08-16c): the incoming object becomes the committed backing
- * IMMEDIATELY — reconcile is eagerly visible to every reader (shipped
- * contract; only its notifications batch), unlike setter writes which stay
- * pending until flush. Ownership resets (incoming is unowned/user data). Any
- * staged draft clone folds into the diff and is discarded — next is the
- * authoritative base (R21/R32).
- */
-export declare function adoptPB(target: StoreNextTarget, incoming: Record<PropertyKey, any>, eager?: boolean): void;
-/** Same logical slot: both values resolve to one (re-pointed) child target —
- * adoption preserved identity, so the slot did not change (R9). */
-export declare function targetsEqual(ov: any, nv: any): boolean;
-/**
- * The fold diff walks SUBSCRIPTION KEYS ONLY (legacy parity: `for key in
- * nodes`): nodes exist exactly where something tracked, so unobserved data
- * costs nothing here regardless of object size. Accessor safety rides the
- * sticky `t.a` flag — a node's key was necessarily read, so the get trap has
- * already seen whether it is an accessor.
- */
-/** One node's fold notification (shared by notifyFold's walk and the fused
- * adoption walk): accessor-aware compare + equality/identity-gated setSignal. */
-export declare function notifyKeyDiff(node: Signal<any>, key: PropertyKey, old: Record<PropertyKey, any>, neu: Record<PropertyKey, any>, probe?: boolean): void;
-/** Accessor-flag probe for the fused walk's early-continue (accessor keys
- * can never identity-skip: their VALUE is the descriptor's product). */
-export declare function hasAccessorFlag(node: Signal<any>): boolean;
-/** Fused-walk per-key notification with values already in hand: the caller
- * fetched both sides and handled the identity skip; this applies the
- * accessor branch (cached flag only — reconcile channel) or the plain
- * equality/identity-gated write. */
-export declare function notifyKeyValue(node: Signal<any>, key: PropertyKey, ov: any, nv: any, old: Record<PropertyKey, any>, neu: Record<PropertyKey, any>): void;
-/** Presence + membership halves of a fold notification (shared tail). */
-export declare function notifyFoldTail(t: StoreNextTarget, old: Record<PropertyKey, any>, neu: Record<PropertyKey, any>): void;
-export declare function notifyFold(t: StoreNextTarget, old: Record<PropertyKey, any>, neu: Record<PropertyKey, any>): void;
-/** Authoritative-write wrapper exported for the optimistic module: sets the
- * scheduler's projectionWriteActive through THIS module's binding (proven to
- * share the instance core reads — cross-module live-binding writes from other
- * store modules were observed not to propagate under the test transform). */
-export declare function runAuthoritative<T>(fn: () => T): T;
-/** Active optimistic override on an armed node (armed slot idles at
- * NOT_PENDING; undefined = unarmed plain node). */
-export declare function hasActiveOverride(node: Signal<any>): boolean;
-export type SetStoreNextFunction<T> = (fn: (draft: T) => T | void) => void;
-/** Low-level setter primitive: opens write mode on a next proxy, runs `fn`,
- * emits write-time notifications at outermost exit, applies returned
- * replacements as adoptions. `guard=false` skips the owned-scope dev guard —
- * projection recomputes legitimately write from inside their computed. */
-export declare function storeSetterNext<T>(proxy: T, fn: (draft: T) => T | void, guard?: boolean): void;
-export declare function createStoreNext<T extends Record<PropertyKey, any>>(init: T, shallow?: boolean): [T, SetStoreNextFunction<T>];
-/** Tracking deep snapshot (`deep()` for next targets): subscribes to the
- * key-set and every property node at every reachable level, then returns the
- * plain view. Shared references and cycles handled via the visited set. */
-export declare function deepNext<T>(value: T): T;
-/**
- * Snapshot with per-object registration resolution (RUL-12 DAG ruling): every
- * reachable wrappable resolves through its target's CURRENT backing, so
- * privatized subtrees are seen through any parent path. Identity-preserving:
- * a subtree with no substitutions below returns its own object (zero copy for
- * settled, never-diverged graphs).
- */
-export declare function snapshotNext<T>(value: T): T;

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

@@ -1,99 +0,0 @@
-/**
- * Store rewrite — target & ownership (INTERNALS-STORE-STATE.md §1, §5b).
- *
- * The proxy wraps this internal target, never the raw (proxy-target
- * indirection, decision 2026-08-16d). `b` is the single committed home; `pb`
- * is the per-target pending backing (RUL-1's pending home): the CoW clone
- * created at first draft write, mutated natively by the draft, folded into
- * `b` at flush commit. Adoption (setter replacement / reconcile) parks an
- * UNOWNED incoming object in `pb` — fold swaps it in and ownership resets.
- *
- * Creation budget (§5b): one minimal target + one proxy + one storeLookup
- * entry per read-through object; zero layer slots; nodes, has-nodes, and the
- * key-set node are lazy, materialized only by subscription.
- */
-import type { Computed, Signal } from "../../core/types.cjs";
-/** Projection family (§7b): children wrap into the family's own map (writes
- * land in the projection, never the source family), and every node created
- * under the family carries the projection computed as its firewall. */
-export interface StoreNextFamily {
-    /** Optimistic family: nodes are born armed (`_overrideValue` slot) so every
-     * write rides the core optimistic engine — lanes, per-transaction ownership,
-     * reverts all core-native (§3, RUL-3). */
-    opt?: boolean;
-    /** Root proxy (registered with the scheduler's optimistic-store set for the
-     * transitionBlocked store-half, #2951). */
-    px?: any;
-    /** Targets currently carrying active node overrides (landing-consumption
-     * walk, RUL-2: visible landed truth replaces optimism). */
-    overlaid?: Set<any>;
-    map: WeakMap<object, StoreNextTarget>;
-    /** The projection computed — assigned after creation (accessor pattern). */
-    node: Computed<any> | null;
-    shallow?: boolean;
-}
-export interface StoreNextTarget {
-    /** Committed backing: source object (shared) or owned clone. */
-    v: Record<PropertyKey, any>;
-    /** Pending backing for the current flush (null when settled). */
-    pb: Record<PropertyKey, any> | null;
-    /** cached: committed backing is another store's proxy (§7b chained). */
-    ch: boolean;
-    /** live value-node count (deleted-key sweep fast-out in the fused walk). */
-    nc: number;
-    /** Lazy per-property subscription nodes (real core signals). */
-    n: Record<PropertyKey, Signal<any>> | null;
-    /** Lazy per-key presence nodes (`in` tracks presence, not value — R13). */
-    h: Record<PropertyKey, Signal<boolean>> | null;
-    /** Lazy key-set node: membership/iteration/$TRACK subscriptions (§6). */
-    k: Signal<number> | null;
-    /** Lazy deep-witness node: `deep()` subscribes ONE node per record instead
-     * of one per path; write paths bump it only when it exists. Separate from
-     * `k` so $TRACK/mapArray never rerun on leaf value changes (R9). */
-    dk: Signal<number> | null;
-    /** Parent target (path copying walks this at commit). */
-    u: StoreNextTarget | null;
-    /** Property key of this target in the parent's backing. */
-    pk: PropertyKey | null;
-    /** The proxy for this target (stable outward identity). */
-    px: any;
-    /** Sticky descendants flag (§6d). */
-    d: boolean;
-    /** Sticky accessors-seen flag: an own accessor property was observed on
-     * this target (first-read scan, defineProperty, or clone scan). Gates the
-     * fold diff's descriptor-safe path and the get trap's descriptor path. */
-    a: boolean;
-    /** Accessor scan performed (scan-once on first trap read; adopted data is
-     * not rescanned — legacy-parity behavior). */
-    sc: boolean;
-    /** Backing was swapped by adoption this batch (fold diff-notifies it). */
-    adopted: boolean;
-    /** Projection family, null for plain stores (§7b). */
-    fam: StoreNextFamily | null;
-    /** Shallow store root (values served raw). */
-    s: boolean;
-}
-/**
- * Ownership (first cut, decision 2026-08-16d): one WeakSet of store-owned
- * backings serving both the production identity-skip guard and the __TEST__
- * no-mutation oracle.
- */
-export declare const ownedRaw: WeakSet<object>;
-/** raw → target. The only raw-keyed lookup; boundary mechanism (O8). */
-export declare const storeNextLookup: WeakMap<object, StoreNextTarget>;
-/** __TEST__ oracle: every object ingested from a user (never mutate). */
-export declare const ingestedRaw: WeakSet<object> | null;
-export declare function devAssertNeverUserMutation(target: object): void;
-/** Injection table for optimistic-only store machinery (next/optimistic.ts).
- * Every call site is gated on `fam?.opt`, and optimistic families can only
- * be created by createOptimisticStore — whose install populates this — so
- * the non-null assertions at the sites hold by construction. Keeping the
- * implementations out of next/store.ts lets plain-store bundles tree-shake
- * the optimistic channel entirely. */
-export interface OptStoreHooks {
-    notifyOptimisticWrites(t: any, pb: Record<PropertyKey, any>): void;
-    optimisticView(t: any, src: Record<PropertyKey, any>): Record<PropertyKey, any>;
-    applyTentative(t: any, incoming: any, keyFn: ((item: any) => any) | null): void;
-}
-export declare let optHooks: OptStoreHooks | null;
-export declare function setOptHooks(h: OptStoreHooks): void;

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

@@ -1,45 +0,0 @@
-import { type Refreshable } from "../core/index.cjs";
-import { type NoFn, type ProjectionOptions, type Store, type StoreSetter } from "./store.cjs";
-/**
- * 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 }`),
- * or `null` to merge positionally. 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>>, options?: ProjectionOptions): [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-cjs/store/projection.d.cts

@@ -1,70 +0,0 @@
-import { type Computed, type Refreshable } from "../core/index.cjs";
-import { type NoFn, type ProjectionOptions, type Store } from "./store.cjs";
-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.
- *
- * 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),
- *   []
- * );
- * ```
- *
- * @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> | 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`
- * 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) | null, wrapCommit?: (write: () => void) => void, onDraftWrite?: () => void): Computed<void | T>;
-export declare function createWriteTraps(isActive?: () => boolean, onDraftWrite?: () => void): ProxyHandler<any>;

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

@@ -1,46 +0,0 @@
-/**
- * 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-cjs/store/store.d.cts

@@ -1,138 +0,0 @@
-import { type Signal } from "../core/index.cjs";
-import type { Refreshable } from "../core/index.cjs";
-/** 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) */
-    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; `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>;
-/**
- * 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_NODE = "n", STORE_HAS = "h", STORE_PARENT = "u", STORE_DESC = "d", STORE_SHALLOW = "s";
-/** Structural view of a store target as shared machinery sees it (the real
- * shape is `StoreNextTarget` in ./next/target.ts). */
-export type StoreNode = {
-    [$PROXY]: any;
-    [STORE_VALUE]: Record<PropertyKey, any>;
-    [STORE_NODE]?: DataNodes;
-    [STORE_HAS]?: DataNodes;
-    [STORE_PARENT]?: StoreNode;
-    [STORE_SHALLOW]?: boolean;
-    [STORE_DESC]?: boolean;
-};
-export declare namespace SolidStore {
-    interface Unwrappable {
-    }
-}
-export type NotWrappable = string | number | bigint | symbol | boolean | Function | null | undefined | SolidStore.Unwrappable[keyof SolidStore.Unwrappable];
-/**
- * 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 markRawOne(v: any): void;
-export declare function markRawIngest(container: any): void;
-export declare function isWrappable<T>(obj: T | NotWrappable): obj is T;
-export declare function setWriteOverride(value: boolean): void;
-export declare function getWriteOverride(): boolean;
-export declare function ownEnumerableKeys(o: object): (string | symbol)[];
-/**
- * Scope inheritance for late-created nodes: every live mark whose identity
- * scope contains the owning record's raw — and, for keyed marks, whose key
- * is this property — gets counted on the new node. Inherited marks live
- * exactly as long as the scope's carrier — the release hook below drops
- * them with the entry.
- */
-export declare function inheritAffectsMarks(node: DataNode, raw: object, property: PropertyKey): void;
-/** Next-store node factory for affects carriers/slots: injected by the
- * rewrite module (next targets alias the legacy field names, so everything
- * here EXCEPT node creation works on them structurally). */
-export declare let nextAffectsNodeResolver: ((target: any, key: PropertyKey) => DataNode) | null;
-export declare function setNextAffectsNodeResolver(fn: (target: any, key: PropertyKey) => DataNode): void;
-/** Next-store optimistic view for the declaration walk (optimistic rows
- * pushed before the declaration are in motion too — legacy reads its write
- * overlays; next composes armed-node overrides). */
-export declare let nextOptimisticViewResolver: ((target: any, raw: any) => any) | null;
-export declare function setNextOptimisticViewResolver(fn: (target: any, raw: any) => any): void;
-/** @internal birth inheritance for nodes created inside a live mark window —
- * exported for the rewrite's node factories. */
-export declare function affectsScopesLive(): boolean;
-/**
- * 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 {};

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

@@ -1,58 +0,0 @@
-import { type NotWrappable } from "./store.cjs";
-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-cjs/store/utils.d.cts

@@ -1,74 +0,0 @@
-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 {};