@solidjs/signals 2.0.0-beta.25 → 2.0.0-beta.27

package/dist/prod/store/store.js

@@ -1,4 +1,4 @@
-import { $REFRESH, STORE_SNAPSHOT_PROPS, NOT_PENDING, unwrapOverride, STATUS_UNINITIALIZED, STATUS_PENDING, NO_SNAPSHOT } from "../core/constants.js";
+import { $REFRESH, STORE_SNAPSHOT_PROPS, NOT_PENDING, unwrapOverride, STATUS_ERROR, STATUS_UNINITIALIZED, STATUS_PENDING, NO_SNAPSHOT } from "../core/constants.js";
 
 import { suppressComputedRecompute, isEqual, signal, pendingCheckActive, untrack, setSignal, read, readNodeFast, READ_SLOW, snapshotCaptureActive, snapshotSources } from "../core/core.js";
 
@@ -122,6 +122,14 @@ function isRawValue(e) {
 
 function markRawOne(e) {
     if (isWrappable(e)) {
+        // A store proxy is already tracked elsewhere: the shallow boundary passes
+        // it through by reference (replaced, never edited — same slot semantics
+        // as a raw) instead of claiming it raw. The sticky mark is global, so
+        // marking a live proxy would make wrap() serve it verbatim through every
+        // OTHER store too — downstream deep stores then captured it instead of
+        // wrapping it in their own family, and their writes landed in the
+        // upstream store's override layer (#2932).
+        if (e[$TARGET] !== undefined) return;
         rawValuesUsed = true;
         rawValues.add(e);
     }
@@ -173,11 +181,39 @@ function wrapShallow(e) {
     return r;
 }
 
+const OBJECT_PROTO = Object.prototype;
+
+// Per-prototype memo for the custom-proto branch of isWrappable: the verdict
+// is fully determined by the prototype (tag and Node lineage both live on
+// the chain), so each class pays the tag call once — not per read.
+const wrappableProtos = new WeakMap;
+
 function isWrappable(e) {
     if (e == null || typeof e !== "object" || Object.isFrozen(e)) return false;
-    // Dynamic Node check (kept dynamic so test/SSR overrides of `globalThis.Node`
-    // are observed at call time).
-        return typeof Node === "undefined" || !(e instanceof Node);
+    // Plain data and user class instances wrap; platform objects never do
+    // (#2952). Native code brand-checks internal slots and throws through a
+    // proxy (`Map.prototype.size`, `Date.prototype.getTime`, ...), so
+    // collections and other built-ins can't honestly be stores — they get the
+    // markRaw-children contract automatically: served raw, mutations land raw,
+    // the property holding them still tracks (reassignment notifies). The tag
+    // check separates them structurally: user classes stringify as
+    // `[object Object]` while every native/host object carries its own brand
+    // (`[object Map]`, `[object Date]`, `[object Headers]`, ...), including
+    // subclasses, which inherit the tag. getPrototypeOf keeps the hot path
+    // (plain and null-proto objects) intrinsic-only — no property lookup.
+        const t = Object.getPrototypeOf(e);
+    if (t === OBJECT_PROTO || t === null) return true;
+    if (Array.isArray(e)) return true;
+    let r = wrappableProtos.get(t);
+    if (r === undefined) {
+        r = Object.prototype.toString.call(e) === "[object Object]" && (
+        // Dynamic Node check (kept dynamic so test/SSR overrides of
+        // `globalThis.Node` are observed at call time): shimmed DOMs implement
+        // nodes as plain user classes, which pass the tag check.
+        typeof Node === "undefined" || !(e instanceof Node));
+        wrappableProtos.set(t, r);
+    }
+    return r;
 }
 
 let writeOverride = false;
@@ -255,7 +291,7 @@ function ownEnumerableKeysPlain(e) {
  * The value a store leaf's backing signal currently shows to readers: active
  * override, else held pending value, else committed value.
  */ function visibleNodeValue(e) {
-    return e.Ee !== undefined && e.Ee !== NOT_PENDING ? unwrapOverride(e.Ee) : e.Ne !== NOT_PENDING ? e.Ne : e.Pe;
+    return e.Ae !== undefined && e.Ae !== NOT_PENDING ? unwrapOverride(e.Ae) : e.De !== NOT_PENDING ? e.De : e.Ue;
 }
 
 function hasOwnStoreProperty(e, t) {
@@ -306,11 +342,11 @@ function getNode(e, t, r, n, o = isEqual, i) {
         }
     }, e[STORE_FIREWALL]);
     if (e[STORE_OPTIMISTIC]) {
-        O.Ee = NOT_PENDING;
+        O.Ae = NOT_PENDING;
     }
     if (i && r in i) {
         const e = i[r];
-        O.Ve = e === undefined ? NO_SNAPSHOT : e;
+        O.xe = e === undefined ? NO_SNAPSHOT : e;
         snapshotSources?.add(O);
     }
     if (typeof r === "symbol" && r !== $TRACK && r !== $AFFECTS) symbolKeyedRecords.add(t);
@@ -574,8 +610,8 @@ function getPropertyDescriptor(e, t, r) {
 function prepareStoreWrite(e, t, r) {
     if (e[STORE_OPTIMISTIC]) {
         const t = e[STORE_FIREWALL];
-        if (t?.Ue) {
-            globalQueue.initTransition(t.Ue);
+        if (t?.Ie) {
+            globalQueue.initTransition(t.Ie);
         }
     }
     const n = e[STORE_VALUE];
@@ -618,8 +654,11 @@ function prepareStoreWrite(e, t, r) {
  * concurrent actions writing disjoint keys must revert independently, exactly
  * like optimistic signal nodes do via the transition's _optimisticNodes.
  * `activeTransition` is the write's transaction (action() opens it before the
- * body runs); null marks an ambient write that clears at plain flush end.
- * Same-key writes across actions keep last-write-wins layer semantics.
+ * body runs); null marks an ambient write, which clears at plain flush end —
+ * unless its flush's transition is blocked on the store's own in-flight truth
+ * (pending firewall, #2951), in which case it rides that transaction to
+ * settle. Same-key writes across actions keep last-write-wins layer
+ * semantics.
  */ function stampOptimisticOwner(e, t, r) {
     if (t === STORE_OPTIMISTIC_OVERRIDE) (e[STORE_OPTIMISTIC_OWNERS] ??= Object.create(null))[r] = activeTransition;
 }
@@ -672,16 +711,36 @@ function notifyStoreProperty(e, t, r, n, o, i) {
 let Writing = null;
 
 /**
- * A derived store's seed is a draft for the derive function, never an
- * observable value (#2897): until the firewall first resolves there is
- * nothing to read, so every consumer path throws NotReady — tracked reads
- * through their node (core read()), and the untracked fall-throughs in the
- * traps through this guard. Returning the seed leaked it; returning
- * `undefined` would break non-nullable types. Callers exempt the firewall
- * itself (the derive function works its own draft while uninitialized).
- */ function throwIfUninitialized(e) {
+ * A derived store follows async memo rules (#2897 ruling): its seed is a
+ * draft for the derive function, never an observable value, and an errored
+ * derive is an error state, never a silent stale/seed serve. Until the
+ * firewall first resolves there is nothing to read, so every consumer path
+ * throws NotReady — tracked reads through their node (core read()), and the
+ * untracked fall-throughs in the traps through this guard. Returning the
+ * seed leaked it; returning `undefined` would break non-nullable types.
+ * Callers exempt the firewall itself (the derive function works its own
+ * draft while uninitialized).
+ *
+ * Error rail: a firewall carrying STATUS_ERROR throws its error for every
+ * late reader — memo parity, where read()'s error branch does the same for
+ * plain computeds. Rejection clears STATUS_UNINITIALIZED at commit, so
+ * without this check late readers silently got the seed while settle-time
+ * subscribers saw the error.
+ *
+ * Loading rail: the veto requires the firewall to still be in flight, not
+ * just flagged: STATUS_UNINITIALIZED's clear is deferred to batch commit,
+ * so during the settle flush a firewall that has already recomputed — and
+ * reconciled real values into STORE_VALUE — still carries the stale flag.
+ * STATUS_PENDING is the live bit (it clears eagerly at settle, mirroring
+ * core read()'s verdict), so gating on it stops the guard from throwing a
+ * fresh NotReadyError that nothing would ever sweep. #2944: mapArray's
+ * keyed diff reads items inside its internal owner (untracked by design)
+ * in exactly this window, and the stale throw wedged <For> permanently.
+ */ function throwIfUnreadable(e) {
     const t = e[STORE_FIREWALL];
-    if (t && t.S & STATUS_UNINITIALIZED) throw t._ ?? new NotReadyError(t);
+    if (!t) return;
+    const r = t.S;
+    if (r & STATUS_ERROR || r & STATUS_UNINITIALIZED && r & STATUS_PENDING) throw t._ ?? new NotReadyError(t);
 }
 
 const storeTraps = {
@@ -731,20 +790,20 @@ const storeTraps = {
         const s = getOverlayLayer(e, t);
         const E = !!s;
         const S = !!e[STORE_VALUE][$TARGET];
-        const f = s ?? e[STORE_VALUE];
+        const T = s ?? e[STORE_VALUE];
         if (!i) {
-            const n = Object.getOwnPropertyDescriptor(f, t);
+            const n = Object.getOwnPropertyDescriptor(T, t);
             if (n && n.get) return n.get.call(r);
             if (!n && !E && e[STORE_CUSTOM_PROTO]) {
-                const e = unwrapStoreValue(f);
+                const e = unwrapStoreValue(T);
                 if (hasInheritedAccessor(e, t)) {
-                    return Reflect.get(f, t, r);
+                    return Reflect.get(T, t, r);
                 }
             }
         }
         if (writeOnly(r)) {
             if (isPrototypePollutionKey(t) && !hasOwnStoreProperty(e, t)) return undefined;
-            let r = i && (E || !S) ? visibleNodeValue(i) : f[t];
+            let r = i && (E || !S) ? visibleNodeValue(i) : T[t];
             r === $DELETED && (r = undefined);
             if (!isWrappable(r)) return r;
             // Shallow boundary: records are replaced, never edited in place. Reads
@@ -756,19 +815,26 @@ const storeTraps = {
             Writing?.add(n);
             return n;
         }
-        let c = i ? E || !S ? read(o[t]) : (read(o[t]), f[t]) : f[t];
+        let c = i ? E || !S ? read(o[t]) : (read(o[t]), T[t]) : T[t];
         c === $DELETED && (c = undefined);
         if (!i) {
-            if (!E && typeof c === "function" && !Object.prototype.hasOwnProperty.call(f, t)) {
+            if (!E && typeof c === "function" && !Object.prototype.hasOwnProperty.call(T, t)) {
                 let t;
-                return !Array.isArray(e[STORE_VALUE]) && (t = Object.getPrototypeOf(e[STORE_VALUE])) && t !== Object.prototype ? c.bind(f) : c;
+                return !Array.isArray(e[STORE_VALUE]) && (t = Object.getPrototypeOf(e[STORE_VALUE])) && t !== Object.prototype ? c.bind(T) : c;
             } else if (getObserver() && !n) {
                 return read(getNode(e, o, t, isWrappable(c) ? wrap(c, e) : c, isEqual, e[STORE_SNAPSHOT_PROPS]));
             }
         }
         // Untracked fall-through (tracked reads already threw via their node in
         // read(); the dev strictRead error above wins first for memo parity).
-                if (!n) throwIfUninitialized(e);
+        // Observer-present reads must NOT re-consult the flag here: during the
+        // settle flush the firewall has recomputed (first values live on the
+        // pending rail, served by read() above) but its UNINITIALIZED clear is
+        // deferred to batch commit — vetoing read()'s verdict with the stale flag
+        // threw a fresh NotReadyError for an already-settled source, which no
+        // sweep would ever release (#2938: projection over an async store wedged
+        // its Loading boundary on `undefined`).
+                if (!n && !getObserver()) throwIfUnreadable(e);
         return isWrappable(c) ? wrap(c, e) : c;
     },
     has(e, t) {
@@ -788,7 +854,7 @@ const storeTraps = {
                 if (getObserver()) {
             return read(getNode(e, o, t, n));
         }
-        throwIfUninitialized(e);
+        throwIfUnreadable(e);
         return n;
     },
     set(e, t, r) {
@@ -800,37 +866,48 @@ const storeTraps = {
                 const s = getOverlayLayer(e, t);
                 const E = s ? s[t] : o;
                 const S = s ? s[t] !== $DELETED : t in e[STORE_VALUE];
-                const f = unwrapStoreValue(r);
-                if (e[STORE_SHALLOW] && isWrappable(f)) rawValues.add(f);
+                // Shallow slots hold store proxies verbatim (pass-through reference,
+                // never raw-marked — see markRawOne/#2932); everything else unwraps
+                // and marks as usual.
+                                const T = !!e[STORE_SHALLOW] && r?.[$TARGET] !== undefined;
+                const c = T ? r : unwrapStoreValue(r);
+                if (e[STORE_SHALLOW] && !T && isWrappable(c)) {
+                    // Flip the live gate too: a bare add was inert unless something else
+                    // had already marked a raw somewhere (wrap() checks rawValuesUsed
+                    // first), so the documented set-trap ingest mark silently no-oped in
+                    // apps whose only shallow data arrived through writes.
+                    rawValuesUsed = true;
+                    rawValues.add(c);
+                }
                 // Symbol-keyed writes on arrays are metadata, not index writes — never run
                 // them through the numeric index/length machinery (`parseInt` on a symbol
                 // throws). #2769
-                                const c = typeof t === "string" ? Number(t) : -1;
-                const R = Array.isArray(O) && Number.isInteger(c) && c >= 0 && c < 4294967295 && String(c) === t;
-                const T = R ? c + 1 : 0;
-                const u = R && (getOverlayLayer(e, "length") ?? O).length;
-                const a = R && T > u ? T : undefined;
-                if (E === f && a === undefined) return true;
+                                const f = typeof t === "string" ? Number(t) : -1;
+                const R = Array.isArray(O) && Number.isInteger(f) && f >= 0 && f < 4294967295 && String(f) === t;
+                const u = R ? f + 1 : 0;
+                const a = R && (getOverlayLayer(e, "length") ?? O).length;
+                const l = R && u > a ? u : undefined;
+                if (E === c && l === undefined) return true;
                 armOptimisticStoreWrite(e, n);
-                if (f !== undefined && f === o && a === undefined) {
+                if (c !== undefined && c === o && l === undefined) {
                     delete e[i]?.[t];
                     if (i === STORE_OPTIMISTIC_OVERRIDE) delete e[STORE_OPTIMISTIC_OWNERS]?.[t];
                 } else {
                     const r = e[i] || (e[i] = Object.create(null));
-                    r[t] = f;
+                    r[t] = c;
                     stampOptimisticOwner(e, i, t);
-                    if (a !== undefined) {
-                        r.length = a;
+                    if (l !== undefined) {
+                        r.length = l;
                         stampOptimisticOwner(e, i, "length");
                     }
                 }
-                notifyStoreProperty(e, t, "set", f, E, S);
+                notifyStoreProperty(e, t, "set", c, E, S);
                 // Shrinking an array's length must remove the truncated indices, otherwise
                 // they leak through `has`, `ownKeys`, and (tracked) index reads from the
                 // underlying value. Mark each as deleted and notify so reactive reads update. #2768
-                                if (Array.isArray(O) && t === "length" && typeof f === "number" && typeof E === "number" && f < E) {
+                                if (Array.isArray(O) && t === "length" && typeof c === "number" && typeof E === "number" && c < E) {
                     const t = e[i] || (e[i] = Object.create(null));
-                    for (let r = f; r < E; r++) {
+                    for (let r = c; r < E; r++) {
                         if (t[r] === $DELETED) continue;
                         const n = r in t ? t[r] : O[r];
                         if (!(r in t) && !(r in O)) continue;
@@ -840,13 +917,13 @@ const storeTraps = {
                     }
                 }
                 // notify length change
-                                if (Array.isArray(O) && t !== "length" && a !== undefined) {
+                                if (Array.isArray(O) && t !== "length" && l !== undefined) {
                     const t = getNodes(e, STORE_NODE);
                     if (t.length) {
-                        setSignal(t.length, a);
+                        setSignal(t.length, l);
                     } else if (!projectionWriteActive && !e[STORE_OPTIMISTIC]) {
-                        const r = upsertStoreNode(e, t, "length", u, e[STORE_SNAPSHOT_PROPS]);
-                        setSignal(r, a);
+                        const r = upsertStoreNode(e, t, "length", a, e[STORE_SNAPSHOT_PROPS]);
+                        setSignal(r, l);
                     }
                 }
                 if (false) ;
@@ -907,7 +984,7 @@ const storeTraps = {
             // path is exempt (like the get/has traps' writeOnly early returns):
             // the first landing's reconcile enumerates the store while
             // STATUS_UNINITIALIZED is still set — it IS the initialization.
-                        if (!getObserver() && !writeOnly(e[$PROXY])) throwIfUninitialized(e);
+                        if (!getObserver() && !writeOnly(e[$PROXY])) throwIfUnreadable(e);
         }
         // Merge optimistic override with regular override for key enumeration
                 let t = getKeys(e[STORE_VALUE], e[STORE_OVERRIDE], false);

package/dist/types/core/async.d.ts

@@ -3,6 +3,8 @@ import type { Computed, Link } from "./types.js";
 export declare function addPendingSource(el: Computed<any>, source: Computed<any>): boolean;
 export declare function setPendingError(el: Computed<any>, source?: Computed<any>, error?: any): void;
 export declare function forEachDependent(el: Computed<any>, fn: (node: Computed<any>, link: Link) => void): void;
+export declare function releaseSettledDependents(el: Computed<any>): void;
+export declare function settleErroredDependents(el: Computed<any>, error: any): void;
 export declare function settlePendingSource(el: Computed<any>): void;
 export declare function isThenable<T>(value: T | PromiseLike<T>): value is PromiseLike<T>;
 export declare function handleAsync<T>(el: Computed<T>, result: T | PromiseLike<T> | AsyncIterable<T>, setter?: (value: T) => void): T;

package/dist/types/core/scheduler.d.ts

@@ -64,6 +64,7 @@ export declare class Queue implements IQueue {
     _parent: IQueue | null;
     _queues: [QueueCallback[], QueueCallback[]];
     _children: IQueue[];
+    _ranAt: number;
     created: number;
     addChild(child: IQueue): void;
     removeChild(child: IQueue): void;

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

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

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

@@ -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
@@ -61,5 +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, onDraftWrite?: () => void): Computed<void | T>;
+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,3 +1,14 @@
+/**
+ * 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.
@@ -12,6 +23,9 @@
  * 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

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

@@ -29,8 +29,8 @@ 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;
 }

package/dist/types-cjs/core/async.d.cts

@@ -3,6 +3,8 @@ import type { Computed, Link } from "./types.cjs";
 export declare function addPendingSource(el: Computed<any>, source: Computed<any>): boolean;
 export declare function setPendingError(el: Computed<any>, source?: Computed<any>, error?: any): void;
 export declare function forEachDependent(el: Computed<any>, fn: (node: Computed<any>, link: Link) => void): void;
+export declare function releaseSettledDependents(el: Computed<any>): void;
+export declare function settleErroredDependents(el: Computed<any>, error: any): void;
 export declare function settlePendingSource(el: Computed<any>): void;
 export declare function isThenable<T>(value: T | PromiseLike<T>): value is PromiseLike<T>;
 export declare function handleAsync<T>(el: Computed<T>, result: T | PromiseLike<T> | AsyncIterable<T>, setter?: (value: T) => void): T;

package/dist/types-cjs/core/scheduler.d.cts

@@ -64,6 +64,7 @@ export declare class Queue implements IQueue {
     _parent: IQueue | null;
     _queues: [QueueCallback[], QueueCallback[]];
     _children: IQueue[];
+    _ranAt: number;
     created: number;
     addChild(child: IQueue): void;
     removeChild(child: IQueue): 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

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

@@ -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
@@ -61,5 +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, onDraftWrite?: () => void): Computed<void | T>;
+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,3 +1,14 @@
+/**
+ * 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.
@@ -12,6 +23,9 @@
  * 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

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

@@ -29,8 +29,8 @@ 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;
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@solidjs/signals",
-  "version": "2.0.0-beta.25",
+  "version": "2.0.0-beta.27",
   "description": "Solid's reactive primitives: signals, memos, effects, stores, and async-aware computations.",
   "author": "Ryan Carniato",
   "license": "MIT",