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

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

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

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

@@ -9,6 +9,12 @@ 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;
+/** Downgrade a prototype-overlay pending backing to the clone path: builds
+ * the real container (committed + overlay writes − deletes) that fold will
+ * SWAP in as the committed backing, exactly as if the draft had started on
+ * the clone path. Consumers that need a complete container (reconcile's
+ * diff walks, drafts escaping into other storage) call this. */
+export declare function materializePB(target: StoreNextTarget): void;
 /**
  * Adoption (2026-08-16c): the incoming object becomes the committed backing
  * IMMEDIATELY — reconcile is eagerly visible to every reader (shipped

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

@@ -68,6 +68,24 @@ export interface StoreNextTarget {
     sc: boolean;
     /** Backing was swapped by adoption this batch (fold diff-notifies it). */
     adopted: boolean;
+    /** Pending backing is a prototype-chain OVERLAY of the committed backing
+     * (`Object.create(v)` — own keys are this batch's writes, everything else
+     * reads through). O(written) per flush instead of O(container) clones
+     * (#3044); commit flattens own keys onto an owned committed backing in
+     * place. Only plain-data non-array non-family containers qualify;
+     * `materializePB` downgrades to the clone path when a consumer needs a
+     * real container (reconcile, draft escape). */
+    ovl: boolean;
+    /** Keys deleted in the overlay window (a prototype overlay cannot shadow
+     * a delete); null when none. */
+    del: Set<PropertyKey> | null;
+    /** Keys written through the traps since the last fold commit. Bounds the
+     * setter notify/hold-check to O(written) instead of O(subscribed nodes) —
+     * a record with thousands of per-key subscriptions (selection maps) would
+     * otherwise pay a full node scan on every write. null = no trap writes
+     * this batch (bulk paths fall back to the full scan); WK_ALL sentinel =
+     * bound unusable this batch (array length write implies index deletes). */
+    wk: Set<PropertyKey> | null;
     /** Projection family, null for plain stores (§7b). */
     fam: StoreNextFamily | null;
     /** Shallow store root (values served raw). */

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@solidjs/signals",
-  "version": "2.0.0-rc.1",
+  "version": "2.0.0-rc.3",
   "description": "Solid's reactive primitives: signals, memos, effects, stores, and async-aware computations.",
   "author": "Ryan Carniato",
   "license": "MIT",
@@ -8,7 +8,7 @@
   "repository": {
     "type": "git",
     "url": "git+https://github.com/solidjs/solid.git",
-    "directory": "packages/solid-signals"
+    "directory": "packages/signals"
   },
   "publishConfig": {
     "access": "public"
@@ -39,6 +39,18 @@
     },
     "./package.json": "./package.json"
   },
+  "scripts": {
+    "build": "npm-run-all -nl build:* && pnpm types",
+    "build:clean": "rimraf dist/dev dist/prod dist/node dist/dev.js dist/prod.js dist/node.cjs",
+    "build:js": "rollup -c && node ./scripts/mangle-props.mjs dist/prod dist/node.cjs && node ./scripts/check-pure.mjs dist/prod",
+    "types": "tsc -p tsconfig.build.json && node ../../scripts/sync-dual-types.mjs ./dist/types ./dist/types-cjs",
+    "test": "vitest run",
+    "test:watch": "vitest watch tests",
+    "test:gc": "node --expose-gc ./vitest.js",
+    "test:gc:watch": "node --expose-gc ./vitest.js --watch",
+    "coverage": "vitest run --coverage",
+    "bench": "vitest bench --run"
+  },
   "devDependencies": {
     "@codspeed/vitest-plugin": "^5.4.0",
     "@ianvs/prettier-plugin-sort-imports": "^4.1.1",
@@ -53,17 +65,5 @@
     "typescript": "^6.0.3",
     "vite": "^7.0.0",
     "vitest": "^4.1.6"
-  },
-  "scripts": {
-    "build": "npm-run-all -nl build:* && pnpm types",
-    "build:clean": "rimraf dist/dev dist/prod dist/node dist/dev.js dist/prod.js dist/node.cjs",
-    "build:js": "rollup -c && node ./scripts/mangle-props.mjs dist/prod dist/node.cjs && node ./scripts/check-pure.mjs dist/prod",
-    "types": "tsc -p tsconfig.build.json && node ../../scripts/sync-dual-types.mjs ./dist/types ./dist/types-cjs",
-    "test": "vitest run",
-    "test:watch": "vitest watch tests",
-    "test:gc": "node --expose-gc ./vitest.js",
-    "test:gc:watch": "node --expose-gc ./vitest.js --watch",
-    "coverage": "vitest run --coverage",
-    "bench": "vitest bench --run"
   }
-}
+}

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

@@ -1,45 +0,0 @@
-import { type Refreshable } from "../core/index.js";
-import { type NoFn, type ProjectionOptions, type Store, type StoreSetter } from "./store.js";
-/**
- * The store equivalent of `createOptimistic`. Writes inside an `action`
- * transition are tentative — they show up immediately but auto-revert (or
- * reconcile to the action's resolved value) once the transition finishes.
- *
- * Use this for optimistic UI on collection-shaped data. For single-value
- * optimistic state, prefer `createOptimistic`.
- *
- * - Plain form: `createOptimisticStore(initialValue)`.
- * - Derived form: `createOptimisticStore(fn, seed, options?)` — a projection
- *   store whose authoritative value is recomputed by `fn` and whose
- *   optimistic overlay reverts after each transition.
- *
- * `options.key` defaults to `"id"`; specify it only when your data uses a
- * different identity field (e.g. `{ key: "uuid" }` or `{ key: t => t.slug }`),
- * 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/store/projection.d.ts

@@ -1,70 +0,0 @@
-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: 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/store/reconcile.d.ts

@@ -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/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;