@solidjs/signals 2.0.0-rc.2 → 2.0.0-rc.4

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

@@ -0,0 +1,41 @@
+import type { StoreNextTarget } from "./target.cjs";
+import type { RowOps } from "./patch.cjs";
+/**
+ * Patch-channel emission seams (pay-for-use). The store/reconcile/optimistic
+ * write paths emit through these installed hook objects instead of importing
+ * `patch.js` statically, so the channel tree-shakes out of apps that never
+ * register a patch consumer.
+ *
+ * TWO TIERS, armed at registration (patch.js installs them; it is retained
+ * only through its registration exports, which only compiled patch-mode
+ * output — via the web runtime's driver module — imports):
+ * - VALUE hooks (`patchHooks`): record patches. Armed by `registerPatch` —
+ *   present in any bundle with one eligible template under patch mode.
+ * - ROW hooks (`rowHooks`): list structure (row ops, slot ticks, the
+ *   identity/keyed diff builders in reconcile.js they drag in). Armed by
+ *   `registerRowOps`/`registerSlotPatchNext` — the LIST driver's
+ *   registrations, so value-only bundles never retain the row machinery.
+ *
+ * Soundness: every emission site is guarded by the matching `pc` channel
+ * (`pc.p` for value, `pc.ro`/`pc.sp` for rows), and a target can only
+ * acquire that channel through the corresponding registration — so each
+ * hook object is installed by the time any guard passes. Type-only imports
+ * from `patch.js` are erased.
+ */
+export interface PatchValueHooks {
+    emitPatch(t: StoreNextTarget, next: any, prev: any): void;
+    emitPatchLocal(t: StoreNextTarget, next: any, prev: any): void;
+    emitPatchOptimistic(t: StoreNextTarget, next: any, prev: any): void;
+    hasPatches(): boolean;
+    demoteToEffects(t: StoreNextTarget): void;
+}
+export interface PatchRowHooks {
+    emitRowOps(t: StoreNextTarget, next: any[], ops: RowOps): void;
+    emitSlotPatch(t: StoreNextTarget, index: number, next: any, prev: any): void;
+    emitSetterRowOps(t: StoreNextTarget, prevRows: any[], nextRows: any[]): void;
+    emitRowOpsOptimistic(t: StoreNextTarget, next: any[] | null, ops: RowOps | null): void;
+}
+export declare let patchHooks: PatchValueHooks | null;
+export declare let rowHooks: PatchRowHooks | null;
+export declare function installPatchHooks(hooks: PatchValueHooks): void;
+export declare function installRowHooks(hooks: PatchRowHooks): void;

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

@@ -0,0 +1,91 @@
+import type { Owner } from "../../core/types.cjs";
+import { type StoreNextTarget } from "./target.cjs";
+export type PatchFn = (next: any, prev: any, force?: boolean) => void;
+interface PatchEntry {
+    fn: PatchFn;
+    owner: Owner | null;
+}
+/**
+ * Emit a record's visibility transition. Callers gate on `hasPatches()` and
+ * `t.d` cheaply; this function re-checks and walks ancestors (§4b).
+ */
+export declare function emitPatch(t: StoreNextTarget, next: any, prev: any): void;
+/** Emission for sites that already stand at the record with both sides in
+ * hand and have already handled ancestors (the adoption walk descends —
+ * parents were visited first), so no bubbling walk. */
+export declare function emitPatchLocal(t: StoreNextTarget, next: any, prev: any): void;
+export declare function emitPatchOptimistic(t: StoreNextTarget, next: any, prev: any): void;
+/** Row-ops emission at OPTIMISTIC (lane) timing: user drafts on an
+ * optimistic family must show structure IN FLIGHT — bypassing the
+ * transition stash exactly like emitPatchOptimistic. Two forms:
+ * - `ops` given (write site): `nextRows` is the draft's intended visible
+ *   list, ops the identity diff against the pre-write optimistic view.
+ * - `ops === null` (revert site): RESYNC — the consumer rebuilds retention
+ *   by row identity against the live post-revert view, resolved from the
+ *   target at drain time (overrides are gone by then, so `pb ?? v` IS the
+ *   committed truth). */
+export declare function emitRowOpsOptimistic(t: StoreNextTarget, nextRows: any[] | null, ops: RowOps | null): void;
+/** Test-only accounting probe: the live registration count must return to
+ * baseline across register/unbind/demote cycles. @internal */
+export declare function patchCountForTests(): number;
+export declare function hasPatches(): boolean;
+export declare function registerPatch(record: any, fn: PatchFn): () => void;
+/** Dual-driver bind probe (compiler runtime contract): when `record` is a
+ * patchable store record, returns its CURRENT raw backing (the driver's
+ * initial force-apply reads it directly — no proxy traffic, no tracking);
+ * returns undefined otherwise (driver falls back to the effect path).
+ * Not patchable: non-records, non-proxies, accessor-bearing records
+ * (patches read raw — getters need tracked evaluation), broken chains. */
+export declare function patchableRaw(record: any): Record<PropertyKey, any> | undefined;
+/** Accessor demotion (design §5): a record that acquires an accessor after
+ * registration stops being patchable — reads must go through tracked
+ * evaluation. Clears patches and repairs the global count; callers re-drive
+ * the pulled bodies (demoteToEffects). */
+export declare function demotePatches(t: StoreNextTarget): PatchEntry[] | null;
+/** The demotion re-drive (re-audit blocker 3): each pulled body becomes the
+ * SAME dual-driver effect fallback the web runtime would have chosen had the
+ * record carried the accessor at bind — a tracked compute pass (next === prev
+ * short-circuits every compare into a pure read THROUGH THE PROXY, so getter
+ * dependencies track) plus an untracked force-apply at effect timing.
+ *
+ * Creation is DEFERRED to the effect phase: the trap that discovers the
+ * accessor runs mid-draft, and an effect's initial pass must not read
+ * through the proxy inside the write window. The record's own transition
+ * for that draft is covered by the new effect's initial force-apply.
+ *
+ * Known edge (documented): a demoted LIST-ROW body re-drives under its
+ * registering owner (the list owner), so per-row severing on removal is
+ * lost for demoted rows — the effect lives until the LIST disposes. Rows
+ * only demote when user code defines an accessor on a row record at
+ * runtime. */
+export declare function demoteToEffects(t: StoreNextTarget): void;
+/** Structural ops for one keyed-array transition. `prefix` rows key-matched
+ * in place; for each later index i (absolute), `sources[i - prefix]` is the
+ * OLD index its row retained from, or -1 for a new row. `removed` holds the
+ * dropped old row values (unbind/teardown handles). Aligned value ticks emit
+ * NOTHING — ops exist only when structure changed. */
+export interface RowOps {
+    prefix: number;
+    sources: number[];
+    removed: any[];
+}
+/** `ops === null` is the RESYNC form (optimistic revert): the consumer
+ * rebuilds retention by row identity against `next` (the live view). */
+export type RowOpsFn = (next: any[], ops: RowOps | null) => void;
+/** Register a structural-ops consumer on a keyed store array (the list
+ * container's channel — what `For` consumes through the seam). */
+export declare function registerRowOps(array: any, fn: RowOpsFn): () => void;
+/** Slot patches (shallow arrays) ride the same apply queue: the walk emits
+ * per aligned value-replaced slot; application happens at effect phase under
+ * the registration owner's lifetime. */
+export declare function emitSlotPatch(t: StoreNextTarget, index: number, next: any, prev: any): void;
+/** Slot patch for shallow arrays: the reconcile walk emits (index, next,
+ * prev) for KEY-ALIGNED value-replaced slots (structure rides row ops), and
+ * the emission queues through the patch apply queue — effect-phase timing,
+ * transition stamping, disposed-owner drop — like every other channel. */
+export declare function registerSlotPatchNext(arr: any, fn: (index: number, next: any, prev: any) => void): () => void;
+/** Row-ops ride the SAME apply queue/timing as record patches: transition-
+ * stamped, applied at effect phase, in emission order (structure before the
+ * new rows' own patches can exist; retained rows' value patches commute). */
+export declare function emitRowOps(t: StoreNextTarget, next: any[], ops: RowOps): void;
+export {};

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

@@ -1,3 +1,17 @@
+import type { RowOps } from "./patch.cjs";
+import { type StoreNextTarget } from "./target.cjs";
 type KeyFn = (item: any) => any;
 export declare function reconcileNextState(value: any, state: any, key: string | KeyFn | null | undefined, replace?: boolean): void;
+/** Key equality for EVERY key comparison in this module (re-audit 2, P1-5):
+ * SameValueZero, matching the Map-based matchers (buildRowOps, the adoption
+ * window) — NaN keys are equal to themselves, so aligned NaN rows stay
+ * aligned in the prefix walk instead of forever misaligning. Adoption and
+ * row ops MUST agree on key equality or retained DOM rows go stale. */
+export declare function sameKey(a: any, b: any): boolean;
+export declare function emitSetterRowOps(t: StoreNextTarget, prevRows: any[], nextRows: any[]): void;
+/** Identity-keyed structural diff, returned rather than emitted: shared by
+ * the setter channel (regular queue) and the OPTIMISTIC write channel (lane
+ * queue) — same retention semantics, different dispatch timing. Returns
+ * null when the lists are identity-aligned (no structure changed). */
+export declare function buildIdentityRowOps(prevRows: any[], nextRows: any[]): RowOps | null;
 export {};

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

@@ -1,5 +1,7 @@
 import type { Signal } from "../../core/types.cjs";
-import { type StoreNextFamily, type StoreNextTarget } from "./target.cjs";
+import { type StoreNextFamily, type StoreNextTarget, type PatchChannel } from "./target.cjs";
+/** Lazily allocate the patch-channel extension (one literal shape). */
+export declare function pcOf(t: StoreNextTarget): PatchChannel;
 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;
@@ -9,6 +11,10 @@ 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;
+/** Scanned plainness for patch admission (patchableRaw): runs the one-time
+ * accessor scan if it hasn't happened yet — the sticky `a` flag alone is not
+ * trustworthy before a scan (it starts false and is discovered lazily). */
+export declare function targetIsPlain(target: StoreNextTarget): boolean;
 /** 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
@@ -63,8 +69,30 @@ export type SetStoreNextFunction<T> = (fn: (draft: T) => T | void) => void;
  * 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>];
+/** True when `proxy` is a SHALLOW store (children served verbatim, slots
+ * replaced by reference — #2932). The list driver uses this to choose the
+ * slot-patch channel (collected row bodies) over per-record registration. */
+export declare function storeIsShallow(proxy: any): boolean;
+/** True when `proxy` belongs to a projection/optimistic FAMILY. The list
+ * driver must DECLINE family arrays (external audit finding): family
+ * structural changes never emit row/slot ops (the setter channel is
+ * fam-gated; optimistic writes ride node overrides), and the proxy identity
+ * is stable so the each-watch cannot catch the change either — an engaged
+ * list would freeze on optimistic/projection structural updates. Record-
+ * level family patches are unaffected (they have their own emission). */
+export declare function storeHasFamily(proxy: any): boolean;
+/** True when `proxy` belongs to an OPTIMISTIC family specifically. The list
+ * driver declines these (audit finding, narrowed): optimistic user writes
+ * ride node-level overrides — they never enter the reconcile walk, so no
+ * row/slot ops are emitted and an engaged list would freeze on optimistic
+ * structural changes. PROJECTION (non-optimistic) families are drivable:
+ * their recomputes go through the reconcile walk, whose emissions are
+ * transition-stamped in the apply queue like any other (equivalence-matrix
+ * gated). Re-admitting optimistic families requires a lane-timed structural
+ * emission mirroring emitPatchOptimistic, plus revert resync. */
+export declare function storeHasOptimisticFamily(proxy: any): boolean;
 /** Tracking deep snapshot (`deep()` for next targets): subscribes to the
- * key-set and every property node at every reachable level, then returns the
+ * key-set and deep-witness 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;
 /**

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

@@ -12,7 +12,7 @@
  * 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";
+import type { Computed, Owner, 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. */
@@ -32,6 +32,40 @@ export interface StoreNextFamily {
     node: Computed<any> | null;
     shallow?: boolean;
 }
+/** Write-side patch-channel state (stage 2), grouped off the target's named
+ * fields — see the shape rule on `StoreNextTarget.pc`. One literal shape,
+ * allocated by `pcOf` on first use. */
+export interface PatchChannel {
+    /** Slot-patch hooks for shallow arrays — the reconcile walk emits
+     * (i, next, prev) for key-aligned value-replaced slots through the patch
+     * apply queue (records are raw, no per-record targets exist).
+     * MULTI-CONSUMER (external audit): one array can drive several lists. */
+    sp: {
+        fn: (index: number, next: any, prev: any) => void;
+        owner: Owner | null;
+    }[] | null;
+    /** Patch-channel consumers (next/patch.ts): per-record compiled patch
+     * entries, multi-consumer. null when unpatched (the common case). */
+    p: object[] | null;
+    /** Same-batch coalescing stamp (re-audit 2/3): the container array this
+     * channel last pushed a non-forced SELF entry into, plus that entry. A
+     * later same-batch emission UPDATES the queued entry's `next` in place
+     * (latest state wins — adoption REPLACES the captured object, so dropping
+     * the later emission would apply stale state) while `prev` stays the
+     * batch's earliest. The drain clears both stamps so a quiet record
+     * retains nothing from its last batch. */
+    qa: unknown;
+    qe: unknown;
+    /** Row-ops consumers (next/patch.ts, PR-B): structural list ops —
+     * (nextRows, { prefix, sources, removed }) at apply timing. */
+    ro: object[] | 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: Set<PropertyKey> | null;
+}
 export interface StoreNextTarget {
     /** Committed backing: source object (shared) or owned clone. */
     v: Record<PropertyKey, any>;
@@ -47,6 +81,15 @@ export interface StoreNextTarget {
     h: Record<PropertyKey, Signal<boolean>> | null;
     /** Lazy key-set node: membership/iteration/$TRACK subscriptions (§6). */
     k: Signal<number> | null;
+    /** Patch-channel extension (lazily allocated on first use): groups the
+     * write-side stage-2 fields so they never widen the TARGET's own named
+     * field count. LOAD-BEARING SHAPE RULE: array proxy targets carry their
+     * fields as named properties on a real array, and V8 normalizes an array
+     * to dictionary properties as the named count grows (empirically at
+     * counts ≡ 0 mod 3 from 18 up on V8 13.x) — every trap field read then
+     * becomes a hash lookup (~15% uibench, tree suites worst). New
+     * patch-channel state MUST go inside this object, not on the target. */
+    pc: PatchChannel | 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). */
@@ -79,17 +122,21 @@ export interface StoreNextTarget {
     /** 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). */
     s: boolean;
+    /** Held committed view (#3074/#3075): the pre-hold committed backing,
+     * served to committed-visibility readers while `ht` is live. Adoption is
+     * eager by contract, but a projection recompute deriving from uncommitted
+     * inputs (a transition-held source, or a latest()-pull ahead of the flush)
+     * swaps the backing SPECULATIVELY — the old view must stay servable until
+     * the hold resolves. */
+    hv: Record<PropertyKey, any> | null;
+    /** The holder for `hv`: a live transition (cleared lazily when it is done)
+     * or the PLAIN_HOLD sentinel (a latest()-pull staging — cleared by the
+     * fold commit). null = no hold. */
+    ht: any;
 }
 /**
  * Ownership (first cut, decision 2026-08-16d): one WeakSet of store-owned
@@ -115,3 +162,6 @@ export interface OptStoreHooks {
 }
 export declare let optHooks: OptStoreHooks | null;
 export declare function setOptHooks(h: OptStoreHooks): void;
+/** Sticky descendants flag walk (§6d): reconcile's keyed pruning descends
+ * only where subscriptions exist at/below. Nodes AND patches count. */
+export declare function markDescendants(target: StoreNextTarget): void;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@solidjs/signals",
-  "version": "2.0.0-rc.2",
+  "version": "2.0.0-rc.4",
   "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>;