@solidjs/signals 2.0.0-beta.23 → 2.0.0-beta.24

package/dist/prod/store/store.js

@@ -32,15 +32,40 @@ const STORE_VALUE = "v", STORE_OVERRIDE = "o", STORE_OPTIMISTIC_OVERRIDE = "x",
 
 const STORE_SELF_PENDING = Symbol(0);
 
+// Every StoreNode field is initialized up front, in one fixed order, so all
+// targets share a single hidden class. The traps and reconcile read these
+// fields on their hottest paths; fields added lazily in varying orders made
+// those loads megamorphic across a large store graph (dictionary-mode probes
+// on every trap hit). Assignments elsewhere must never `delete` a field —
+// write `undefined` instead, or the shape degrades again.
+function initStoreFields(e) {
+    e[STORE_OVERRIDE] = undefined;
+    e[STORE_OPTIMISTIC_OVERRIDE] = undefined;
+    e[STORE_OPTIMISTIC_OWNERS] = undefined;
+    e[STORE_NODE] = undefined;
+    e[STORE_HAS] = undefined;
+    e[STORE_CUSTOM_PROTO] = undefined;
+    e[STORE_WRAP] = undefined;
+    e[STORE_LOOKUP] = undefined;
+    e[STORE_FIREWALL] = undefined;
+    e[STORE_OPTIMISTIC] = undefined;
+    e[STORE_SNAPSHOT_PROPS] = undefined;
+    e[STORE_PARENT] = undefined;
+    e[STORE_DESC] = undefined;
+    e[$PROXY] = null;
+}
+
 function createStoreProxy(e, t = storeTraps, r) {
     let n;
     if (Array.isArray(e)) {
         n = [];
-        n.v = e;
+        n[STORE_VALUE] = e;
+        initStoreFields(n);
     } else {
         n = {
-            v: e
+            [STORE_VALUE]: e
         };
+        initStoreFields(n);
         const t = e?.[$TARGET]?.[STORE_VALUE] ?? e;
         const r = Object.getPrototypeOf(t);
         if (r !== null && r !== Object.prototype) {
@@ -97,17 +122,17 @@ function unwrapStoreValue(e, t, r) {
     if (!t) t = new Map;
     if (t.has(e)) return t.get(e);
     const i = n[STORE_VALUE];
-    const s = Array.isArray(i);
-    const E = s ? [] : Object.create(Object.getPrototypeOf(i));
-    t.set(e, E);
+    const E = Array.isArray(i);
+    const O = E ? [] : Object.create(Object.getPrototypeOf(i));
+    t.set(e, O);
     r = n[STORE_LOOKUP] ?? storeLookup;
     for (const e of getStoreKeys(i, o)) {
-        if (s && e === "length") continue;
+        if (E && e === "length") continue;
         const n = e in o ? o[e] : i[e];
-        if (n !== $DELETED) E[e] = unwrapStoreValue(n, t, r);
+        if (n !== $DELETED) O[e] = unwrapStoreValue(n, t, r);
     }
-    if (s) E.length = o.length ?? i.length;
-    return E;
+    if (E) O.length = o.length ?? i.length;
+    return O;
 }
 
 function isPrototypePollutionKey(e) {
@@ -182,10 +207,10 @@ function getNodes(e, t) {
 
 function getNode(e, t, r, n, o = isEqual, i) {
     if (t[r]) return t[r];
-    const s = signal(n, {
+    const E = signal(n, {
         equals: o,
         unobserved() {
-            if (t[r] === s) {
+            if (t[r] === E) {
                 delete t[r];
                 // Drop the symbol-record mark once the last user symbol node is
                 // gone, so reconcile's fast path stops probing a now string-only
@@ -205,28 +230,28 @@ function getNode(e, t, r, n, o = isEqual, i) {
         }
     }, e[STORE_FIREWALL]);
     if (e[STORE_OPTIMISTIC]) {
-        s.Ee = NOT_PENDING;
+        E.Ee = NOT_PENDING;
     }
     if (i && r in i) {
         const e = i[r];
-        s.Ve = e === undefined ? NO_SNAPSHOT : e;
-        snapshotSources?.add(s);
+        E.Ve = e === undefined ? NO_SNAPSHOT : e;
+        snapshotSources?.add(E);
     }
     if (typeof r === "symbol" && r !== $TRACK && r !== $AFFECTS) symbolKeyedRecords.add(t);
     // A node born inside a live mark's identity scope inherits the mark
     // (the declaration walk could only cover nodes that existed then). The
     // record's own $AFFECTS carrier is the mark's channel, never a member.
-        if (r !== $AFFECTS && affectsScopes.size) inheritAffectsMarks(s, e[STORE_VALUE], r);
+        if (r !== $AFFECTS && affectsScopes.size) inheritAffectsMarks(E, e[STORE_VALUE], r);
     // Node presence bubbles up the wrap chain (sticky), so reconcile can see
     // "subscribers live somewhere below" through node-less intermediate
     // records — the captured-proxy diff gate (#2902). Amortized O(1): stops at
     // the first already-flagged ancestor.
-        let E = e;
-    while (E && !E[STORE_DESC]) {
-        E[STORE_DESC] = true;
-        E = E[STORE_PARENT];
+        let O = e;
+    while (O && !O[STORE_DESC]) {
+        O[STORE_DESC] = true;
+        O = O[STORE_PARENT];
     }
-    return t[r] = s;
+    return t[r] = E;
 }
 
 /**
@@ -263,42 +288,42 @@ const affectsScopes = new Map;
 o) {
     if (!isWrappable(e)) return;
     const i = e[$TARGET] || (n ?? storeLookup).get(e)?.[$TARGET];
-    const s = i ? i[STORE_VALUE] : e;
-    if (o.has(s)) return;
-    o.add(s);
-    t.scope.add(s);
-    let E;
+    const E = i ? i[STORE_VALUE] : e;
+    if (o.has(E)) return;
+    o.add(E);
+    t.scope.add(E);
+    let O;
     if (i) {
         collectRecordNodes(i[STORE_NODE], r);
         collectRecordNodes(i[STORE_HAS], r);
-        E = mergedOverlay(i);
+        O = mergedOverlay(i);
         // Carry the effective lookup into untouched descendants. Default stores
         // use the global lookup just like snapshotImpl; without it, nested raw
         // objects fall back to string-only enumeration and symbol branches vanish.
                 n = i[STORE_LOOKUP] ?? n ?? storeLookup;
     }
-    if (Array.isArray(s)) {
-        const e = E?.length ?? s.length;
+    if (Array.isArray(E)) {
+        const e = O?.length ?? E.length;
         for (let i = 0; i < e; i++) {
-            const e = E && i in E ? E[i] : s[i];
+            const e = O && i in O ? O[i] : E[i];
             if (e !== $DELETED) walkAffectsScope(e, t, r, n, o);
         }
         // Arrays can also carry symbol metadata. Enumerate symbols separately to
         // avoid scanning large index lists twice. Outside a store tree, retain the
         // existing index-only walk.
-                const O = i || n ? getStoreSymbols(s, E) : [];
-        for (let e = 0, i = O.length; e < i; e++) {
-            const i = O[e];
-            const c = getPropertyDescriptor(s, E, i);
-            if (!c || c.get) continue;
-            walkAffectsScope(c.value, t, r, n, o);
+                const s = i || n ? getStoreSymbols(E, O) : [];
+        for (let e = 0, i = s.length; e < i; e++) {
+            const i = s[e];
+            const S = getPropertyDescriptor(E, O, i);
+            if (!S || S.get) continue;
+            walkAffectsScope(S.value, t, r, n, o);
         }
     } else {
-        const e = i || n ? getStoreKeys(s, E) : getKeys(s, E);
-        for (let i = 0, O = e.length; i < O; i++) {
-            const O = getPropertyDescriptor(s, E, e[i]);
-            if (!O || O.get) continue;
-            walkAffectsScope(O.value, t, r, n, o);
+        const e = i || n ? getStoreKeys(E, O) : getKeys(E, O);
+        for (let i = 0, s = e.length; i < s; i++) {
+            const s = getPropertyDescriptor(E, O, e[i]);
+            if (!s || s.get) continue;
+            walkAffectsScope(s.value, t, r, n, o);
         }
     }
 }
@@ -489,10 +514,10 @@ function prepareStoreWrite(e, t, r) {
         }
     }
     const i = e[STORE_OPTIMISTIC] && !projectionWriteActive;
-    const s = i ? STORE_OPTIMISTIC_OVERRIDE : STORE_OVERRIDE;
+    const E = i ? STORE_OPTIMISTIC_OVERRIDE : STORE_OVERRIDE;
     return {
         base: o,
-        overrideKey: s,
+        overrideKey: E,
         state: n
     };
 }
@@ -526,42 +551,42 @@ function prepareStoreWrite(e, t, r) {
 function upsertStoreNode(e, t, r, n, o) {
     if (t[r]) return t[r];
     const i = isWrappable(n) ? wrap(n, e) : n;
-    const s = getNode(e, t, r, i, isEqual, o);
-    registerTransientStoreNode(s);
-    return s;
+    const E = getNode(e, t, r, i, isEqual, o);
+    registerTransientStoreNode(E);
+    return E;
 }
 
 function notifyStoreProperty(e, t, r, n, o, i) {
     // Cold writes upsert a transient pending node so untracked reads batch like signals.
     // Skip for projection writes (different commit semantics) and for optimistic stores
     // (whose whole purpose is immediate visibility via STORE_OPTIMISTIC_OVERRIDE).
-    const s = projectionWriteActive || e[STORE_OPTIMISTIC];
-    const E = r !== "delete";
-    const O = e[STORE_HAS]?.[t];
-    if (O) {
-        setSignal(O, E);
-    } else if (!s && r !== "invalidate" && i !== E) {
+    const E = projectionWriteActive || e[STORE_OPTIMISTIC];
+    const O = r !== "delete";
+    const s = e[STORE_HAS]?.[t];
+    if (s) {
+        setSignal(s, O);
+    } else if (!E && r !== "invalidate" && i !== O) {
         const r = upsertStoreNode(e, getNodes(e, STORE_HAS), t, i);
-        setSignal(r, E);
+        setSignal(r, O);
     }
-    const c = getNodes(e, STORE_NODE);
+    const S = getNodes(e, STORE_NODE);
     if (r === "set") {
-        if (c[t]) {
-            setSignal(c[t], () => isWrappable(n) ? wrap(n, e) : n);
-        } else if (!s) {
-            const r = upsertStoreNode(e, c, t, o, e[STORE_SNAPSHOT_PROPS]);
+        if (S[t]) {
+            setSignal(S[t], () => isWrappable(n) ? wrap(n, e) : n);
+        } else if (!E) {
+            const r = upsertStoreNode(e, S, t, o, e[STORE_SNAPSHOT_PROPS]);
             setSignal(r, () => isWrappable(n) ? wrap(n, e) : n);
         }
     } else if (r === "invalidate") {
-        if (c[t]) {
-            setSignal(c[t], {});
-            delete c[t];
+        if (S[t]) {
+            setSignal(S[t], {});
+            delete S[t];
         }
     } else {
-        if (c[t]) {
-            setSignal(c[t], undefined);
-        } else if (!s) {
-            const r = upsertStoreNode(e, c, t, o, e[STORE_SNAPSHOT_PROPS]);
+        if (S[t]) {
+            setSignal(S[t], undefined);
+        } else if (!E) {
+            const r = upsertStoreNode(e, S, t, o, e[STORE_SNAPSHOT_PROPS]);
             setSignal(r, undefined);
         }
     }
@@ -593,50 +618,65 @@ const storeTraps = {
             trackSelf(e);
             return r;
         }
+        // Hot path: an existing node on a plain target — no firewall (so neither
+        // selfRead nor the uninitialized guard can apply), no override layers,
+        // no write scope, and a raw (non-proxy) source. This is the shape of
+        // every effect re-read of a settled store; it pays one node read and the
+        // wrap check, nothing else. Any exotic bit falls through to the full
+        // resolution below, and dev strictRead keeps its warning path.
+                if (e[STORE_FIREWALL] === undefined && e[STORE_OVERRIDE] === undefined && e[STORE_OPTIMISTIC_OVERRIDE] === undefined && !writeOverride && (Writing === null || !Writing.has(r))) {
+            const r = e[STORE_NODE];
+            const n = r && r[t];
+            if (n !== undefined && e[STORE_VALUE][$TARGET] === undefined) {
+                let t = read(n);
+                if (t === $DELETED) t = undefined;
+                return isWrappable(t) ? wrap(t, e) : t;
+            }
+        }
         const n = getObserver() === e[STORE_FIREWALL];
         const o = getNodes(e, STORE_NODE);
         const i = n ? undefined : o[t];
-        const s = e[STORE_VALUE];
-        if (!i && !e[STORE_OVERRIDE] && !e[STORE_OPTIMISTIC_OVERRIDE] && !e[STORE_CUSTOM_PROTO] && !e[STORE_OPTIMISTIC] && !e[STORE_SNAPSHOT_PROPS] && !s[$TARGET] && !(t in s) && getObserver() && !n && !writeOnly(r)) {
+        const E = e[STORE_VALUE];
+        if (!i && !e[STORE_OVERRIDE] && !e[STORE_OPTIMISTIC_OVERRIDE] && !e[STORE_CUSTOM_PROTO] && !e[STORE_OPTIMISTIC] && !e[STORE_SNAPSHOT_PROPS] && !E[$TARGET] && !(t in E) && getObserver() && !n && !writeOnly(r)) {
             return read(getNode(e, o, t, undefined));
         }
-        const E = getOverlayLayer(e, t);
-        const O = !!E;
-        const c = !!e[STORE_VALUE][$TARGET];
-        const S = E ?? e[STORE_VALUE];
+        const O = getOverlayLayer(e, t);
+        const s = !!O;
+        const S = !!e[STORE_VALUE][$TARGET];
+        const c = O ?? e[STORE_VALUE];
         if (!i) {
-            const n = Object.getOwnPropertyDescriptor(S, t);
+            const n = Object.getOwnPropertyDescriptor(c, t);
             if (n && n.get) return n.get.call(r);
-            if (!n && !O && e[STORE_CUSTOM_PROTO]) {
-                const e = unwrapStoreValue(S);
+            if (!n && !s && e[STORE_CUSTOM_PROTO]) {
+                const e = unwrapStoreValue(c);
                 if (hasInheritedAccessor(e, t)) {
-                    return Reflect.get(S, t, r);
+                    return Reflect.get(c, t, r);
                 }
             }
         }
         if (writeOnly(r)) {
             if (isPrototypePollutionKey(t) && !hasOwnStoreProperty(e, t)) return undefined;
-            let r = i && (O || !c) ? visibleNodeValue(i) : S[t];
+            let r = i && (s || !S) ? visibleNodeValue(i) : c[t];
             r === $DELETED && (r = undefined);
             if (!isWrappable(r)) return r;
             const n = wrap(r, e);
             Writing?.add(n);
             return n;
         }
-        let f = i ? O || !c ? read(o[t]) : (read(o[t]), S[t]) : S[t];
-        f === $DELETED && (f = undefined);
+        let T = i ? s || !S ? read(o[t]) : (read(o[t]), c[t]) : c[t];
+        T === $DELETED && (T = undefined);
         if (!i) {
-            if (!O && typeof f === "function" && !Object.prototype.hasOwnProperty.call(S, t)) {
+            if (!s && typeof T === "function" && !Object.prototype.hasOwnProperty.call(c, t)) {
                 let t;
-                return !Array.isArray(e[STORE_VALUE]) && (t = Object.getPrototypeOf(e[STORE_VALUE])) && t !== Object.prototype ? f.bind(S) : f;
+                return !Array.isArray(e[STORE_VALUE]) && (t = Object.getPrototypeOf(e[STORE_VALUE])) && t !== Object.prototype ? T.bind(c) : T;
             } else if (getObserver() && !n) {
-                return read(getNode(e, o, t, isWrappable(f) ? wrap(f, e) : f, isEqual, e[STORE_SNAPSHOT_PROPS]));
+                return read(getNode(e, o, t, isWrappable(T) ? wrap(T, e) : T, 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);
-        return isWrappable(f) ? wrap(f, e) : f;
+        return isWrappable(T) ? wrap(T, e) : T;
     },
     has(e, t) {
         if (t === $PROXY || t === $TRACK || t === "__proto__") return true;
@@ -663,50 +703,50 @@ const storeTraps = {
         const n = e[$PROXY];
         if (writeOnly(n)) {
             untrack(() => {
-                const {base: o, overrideKey: i, state: s} = prepareStoreWrite(e, n, t);
-                const E = getOverlayLayer(e, t);
-                const O = E ? E[t] : o;
-                const c = E ? E[t] !== $DELETED : t in e[STORE_VALUE];
-                const S = unwrapStoreValue(r);
+                const {base: o, overrideKey: i, state: E} = prepareStoreWrite(e, n, t);
+                const O = getOverlayLayer(e, t);
+                const s = O ? O[t] : o;
+                const S = O ? O[t] !== $DELETED : t in e[STORE_VALUE];
+                const c = unwrapStoreValue(r);
                 // 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 f = typeof t === "string" ? Number(t) : -1;
-                const T = Array.isArray(s) && Number.isInteger(f) && f >= 0 && f < 4294967295 && String(f) === t;
-                const R = T ? f + 1 : 0;
-                const u = T && (getOverlayLayer(e, "length") ?? s).length;
-                const l = T && R > u ? R : undefined;
-                if (O === S && l === undefined) return true;
+                                const T = typeof t === "string" ? Number(t) : -1;
+                const R = Array.isArray(E) && Number.isInteger(T) && T >= 0 && T < 4294967295 && String(T) === t;
+                const f = R ? T + 1 : 0;
+                const u = R && (getOverlayLayer(e, "length") ?? E).length;
+                const l = R && f > u ? f : undefined;
+                if (s === c && l === undefined) return true;
                 armOptimisticStoreWrite(e, n);
-                if (S !== undefined && S === o && l === 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] = S;
+                    r[t] = c;
                     stampOptimisticOwner(e, i, t);
                     if (l !== undefined) {
                         r.length = l;
                         stampOptimisticOwner(e, i, "length");
                     }
                 }
-                notifyStoreProperty(e, t, "set", S, O, c);
+                notifyStoreProperty(e, t, "set", c, s, 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(s) && t === "length" && typeof S === "number" && typeof O === "number" && S < O) {
+                                if (Array.isArray(E) && t === "length" && typeof c === "number" && typeof s === "number" && c < s) {
                     const t = e[i] || (e[i] = Object.create(null));
-                    for (let r = S; r < O; r++) {
+                    for (let r = c; r < s; r++) {
                         if (t[r] === $DELETED) continue;
-                        const n = r in t ? t[r] : s[r];
-                        if (!(r in t) && !(r in s)) continue;
+                        const n = r in t ? t[r] : E[r];
+                        if (!(r in t) && !(r in E)) continue;
                         t[r] = $DELETED;
                         stampOptimisticOwner(e, i, r);
                         notifyStoreProperty(e, r, "delete", undefined, n, true);
                     }
                 }
                 // notify length change
-                                if (Array.isArray(s) && t !== "length" && l !== undefined) {
+                                if (Array.isArray(E) && t !== "length" && l !== undefined) {
                     const t = getNodes(e, STORE_NODE);
                     if (t.length) {
                         setSignal(t.length, l);
@@ -727,11 +767,11 @@ const storeTraps = {
             untrack(() => {
                 const {base: o, overrideKey: i} = prepareStoreWrite(e, n, t);
                 armOptimisticStoreWrite(e, n);
-                const s = "value" in r ? {
+                const E = "value" in r ? {
                     ...r,
                     value: unwrapStoreValue(r.value)
                 } : r;
-                Object.defineProperty(e[i] || (e[i] = Object.create(null)), t, s);
+                Object.defineProperty(e[i] || (e[i] = Object.create(null)), t, E);
                 stampOptimisticOwner(e, i, t);
                 notifyStoreProperty(e, t, "invalidate");
                 if (false) ;

package/dist/prod/store/utils.js

@@ -27,6 +27,18 @@ function snapshotImpl(e, t, r, n) {
                         if (pendingCheckActive) witnessAffectsMark(o);
         }
         i = mergedOverlay(o);
+        // A derived store's STORE_VALUE is the inner store's live proxy
+        // (store-in-store: createOptimisticStore/createProjection over a store).
+        // Without an overlay of its own, the fast path below would map to — and
+        // could return — that proxy verbatim. Recurse instead so the
+        // inner store's own target branch unwraps it (chains of any depth).
+        // With an overlay, a fresh `result` is always built, so the walk over the
+        // inner proxy already copies plain values.
+                if (!i && o[STORE_VALUE][$TARGET]) {
+            f = snapshotImpl(o[STORE_VALUE], t, r, n);
+            r.set(e, f);
+            return f;
+        }
         s = Array.isArray(o[STORE_VALUE]);
         r.set(e, i ? c = s ? [] : Object.create(Object.getPrototypeOf(o[STORE_VALUE])) : o[STORE_VALUE]);
         e = o[STORE_VALUE];

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

@@ -23,7 +23,6 @@
  * ```
  */
 export declare class NotReadyError extends Error {
-    source: any;
     /**
      * Tags a visibility-only notification on the affects() boundary channel:
      * boundaries update display state from it, but the root queue never
@@ -31,6 +30,7 @@ export declare class NotReadyError extends Error {
      * construction.
      */
     _markVisual?: boolean;
+    source: any;
     constructor(source: any);
 }
 export declare class StatusError extends Error {

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

@@ -1,14 +1,20 @@
 /**
  * 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.
  *
  * @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 +22,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/core/error.d.cts

@@ -23,7 +23,6 @@
  * ```
  */
 export declare class NotReadyError extends Error {
-    source: any;
     /**
      * Tags a visibility-only notification on the affects() boundary channel:
      * boundaries update display state from it, but the root queue never
@@ -31,6 +30,7 @@ export declare class NotReadyError extends Error {
      * construction.
      */
     _markVisual?: boolean;
+    source: any;
     constructor(source: any);
 }
 export declare class StatusError extends Error {

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

@@ -1,14 +1,20 @@
 /**
  * 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.
  *
  * @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 +22,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/package.json

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