@solidjs/signals 2.0.0-beta.9 → 2.0.0-rc.1

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

@@ -1,9 +1,19 @@
-export type { Store, StoreSetter, StoreNode, StoreOptions, ProjectionOptions, NotWrappable, SolidStore } from "./store.cjs";
+export type { Store, StoreReturn, ProjectionStoreReturn, StoreSetter, StoreNode, StoreOptions, ProjectionOptions, NotWrappable, SolidStore } from "./store.cjs";
 export type { Merge, Omit } from "./utils.cjs";
-export { isWrappable, createStore, $TRACK, $PROXY, $TARGET } from "./store.cjs";
-export { createProjection } from "./projection.cjs";
-export { createOptimisticStore } from "./optimistic.cjs";
-export { reconcile } from "./reconcile.cjs";
+export { isWrappable, $TRACK, $PROXY, $TARGET } from "./store.cjs";
+import type { NoFn, ProjectionOptions, Store, StoreOptions, StoreSetter } from "./store.cjs";
+import type { Refreshable } from "../core/index.cjs";
+export { createProjectionNext as createProjection } from "./next/projection.cjs";
+export { createOptimisticStoreNext as createOptimisticStore } from "./next/optimistic.cjs";
+/** Public createStore: plain form `(init, options?)` and derived writable
+ * form `(fn, seed, options?)`. */
+export declare function createStore<T extends object = {}>(store: NoFn<T> | Store<NoFn<T>>, options?: StoreOptions & {
+    shallow?: boolean;
+}): [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 declare function reconcile<T extends U, U>(value: T, key?: string | ((item: NonNullable<any>) => any) | null): (state: U) => T;
+export declare function snapshot<T>(value: T): T;
+export declare function deep<T>(value: T): T;
 export { storePath } from "./storePath.cjs";
 export type { PathSetter, Part, StorePathRange, ArrayFilterFn, CustomPartial } from "./storePath.cjs";
-export { snapshot, deep, merge, omit } from "./utils.cjs";
+export { merge, omit } from "./utils.cjs";

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

@@ -0,0 +1,20 @@
+import { type NoFn, type ProjectionOptions, type Store, type StoreSetter } from "../store.cjs";
+import type { StoreNextFamily, StoreNextTarget } from "./target.cjs";
+export declare function createOptimisticStoreNext<T extends object = {}>(first: T | ((store: T) => void | T | Promise<void | T> | AsyncIterable<void | T>), second?: NoFn<T> | Store<NoFn<T>>, options?: ProjectionOptions): [get: Store<T>, set: StoreSetter<T>];
+/** Diff the draft against the current OPTIMISTIC VIEW (committed + active
+ * overrides — the same view the draft was seeded from) and emit engine writes
+ * for exactly the changed keys. Visible-view diffing keeps no-op writes from
+ * entangling lanes (RUL-10 / opt R38). */
+export declare function notifyOptimisticWrites(t: StoreNextTarget, pb: Record<PropertyKey, any>): void;
+/**
+ * Landing consumption (RUL-2): fresh authoritative data supersedes every
+ * tentative override in the family. Mirrors legacy clearProjectionOverride —
+ * drop the override, clear lane/ownership, notify subscribers whose visible
+ * value changes (reversion effects go to regular queues via the projection
+ * write posture the caller holds).
+ */
+export declare function consumeOverridesNext(fam: StoreNextFamily): void;
+/** Optimistic-view composition for snapshot/deep (O1: snapshot is the CURRENT
+ * view, lane values included; a fresh copy per call during pending windows —
+ * RUL-12). Returns `src` untouched when no override is active on `t`. */
+export declare function optimisticView(t: StoreNextTarget, src: Record<PropertyKey, any>): Record<PropertyKey, any>;

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

@@ -0,0 +1,24 @@
+/**
+ * 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

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

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

@@ -0,0 +1,99 @@
+/**
+ * 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

@@ -14,8 +14,8 @@ import { type NoFn, type ProjectionOptions, type Store, type StoreSetter } from
  *   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.
+ * 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
@@ -41,5 +41,5 @@ import { type NoFn, type ProjectionOptions, type Store, type StoreSetter } from
  *
  * @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 = {}>(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,5 +1,5 @@
 import { type Computed, type Refreshable } from "../core/index.cjs";
-import { type ProjectionOptions, type Store } from "./store.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>;
@@ -12,6 +12,10 @@ export declare function createProjectionInternal<T extends object = {}>(fn: (dra
  * 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
@@ -24,7 +28,8 @@ export declare function createProjectionInternal<T extends object = {}>(fn: (dra
  * @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 }`).
+ *   (e.g. `{ key: "uuid" }` or `{ key: u => u.slug }`), or `null` to merge
+ *   positionally with no keyed pass.
  *
  * @example
  * ```ts
@@ -47,7 +52,7 @@ export declare function createProjectionInternal<T extends object = {}>(fn: (dra
  *
  * @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>>;
+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`
@@ -61,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-cjs/store/reconcile.d.cts

@@ -1,14 +1,34 @@
+/**
+ * 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 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.
+ * preserving fine-grained reactivity: only changed leaves trigger updates.
  *
- * Items with the same key are updated in place (only changed properties
- * trigger updates). Items added or removed update the corresponding signals.
+ * 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
+ * @param key property name (string) or extractor function for stable
+ * identity (default `"id"`); pass `null` for positional merging
  *
  * @example
  * ```ts
@@ -16,8 +36,11 @@
  *
  * async function refresh() {
  *   const fresh = await api.getTodos();
- *   setTodos(reconcile(fresh, "id")); // diff-merge by `id`
+ *   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)): (state: U) => void;
+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,4 +1,5 @@
-import { STORE_SNAPSHOT_PROPS, type Computed, type Refreshable, type Signal } from "../core/index.cjs";
+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>;
 /**
@@ -17,6 +18,10 @@ export type Store<T> = Readonly<T>;
  * 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) */
@@ -24,95 +29,110 @@ 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_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_OVERRIDE]?: Record<PropertyKey, any>;
-    [STORE_OPTIMISTIC_OVERRIDE]?: Record<PropertyKey, any>;
     [STORE_NODE]?: DataNodes;
     [STORE_HAS]?: DataNodes;
-    [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 {
     }
 }
 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;
+/**
+ * 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 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;
+export declare function getWriteOverride(): boolean;
+export declare function ownEnumerableKeys(o: object): (string | symbol)[];
 /**
- * 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
- * ```
+ * 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.
  *
- * @example
- * ```ts
- * // Derived store — auto-fetches & reconciles by `id`.
- * const [users] = createStore(
- *   async () => fetch("/users").then(r => r.json()),
- *   [] as User[]
- * );
- * ```
+ * @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).
  *
- * @returns `[store: Store<T>, setStore: StoreSetter<T>]`
+ * @internal
  */
-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 declare function getStoreAffectsNodes(target: StoreNode, key?: PropertyKey): DataNode[];
 export {};

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

@@ -1,43 +1,3 @@
-/**
- * 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];