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

package/dist/prod/store/utils.js

@@ -12,14 +12,14 @@ import "../core/effect.js";
 
 import { createMemo } from "../signals.js";
 
-import { ownEnumerableKeys, $PROXY, isWrappable, $TARGET, trackSelf, witnessAffectsMark, mergedOverlay, STORE_VALUE, storeLookup, STORE_LOOKUP, $DELETED, wrap, getStoreSymbols, getPropertyDescriptor, getStoreKeys, getKeys, $TRACK } from "./store.js";
+import { ownEnumerableKeys, $PROXY, isWrappable, $TARGET, lookupTarget, trackSelf, witnessAffectsMark, mergedOverlay, STORE_VALUE, storeLookup, STORE_LOOKUP, $DELETED, wrap, getStoreSymbols, getPropertyDescriptor, getStoreKeys, getKeys, $TRACK, rawValuesUsed, isRawValue } from "./store.js";
 
 function snapshotImpl(e, t, r, n) {
     let o, s, i, c, f, u;
     if (!isWrappable(e)) return e;
     if (r && r.has(e)) return r.get(e);
     if (!r) r = new Map;
-    if (o = e[$TARGET] || n?.get(e)?.[$TARGET]) {
+    if (o = e[$TARGET] || lookupTarget(e, n)) {
         if (t) {
             trackSelf(o, $TRACK);
             // A tracked walk reads THROUGH the record without touching the proxy
@@ -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];
@@ -37,24 +49,24 @@ function snapshotImpl(e, t, r, n) {
     }
     if (s) {
         const s = i?.length ?? e.length;
-        for (let p = 0; p < s; p++) {
-            u = i && p in i ? i[p] : e[p];
+        for (let a = 0; a < s; a++) {
+            u = i && a in i ? i[a] : e[a];
             if (u === $DELETED) continue;
-            if (t && isWrappable(u)) wrap(u, o);
+            if (t && isWrappable(u) && !(rawValuesUsed && isRawValue(u))) wrap(u, o);
             if ((f = snapshotImpl(u, t, r, n)) !== u || c) {
                 if (!c) r.set(e, c = [ ...e ]);
-                c[p] = f;
+                c[a] = f;
             }
         }
         // Enumerate array symbols separately to avoid scanning indices twice.
         // Spread copies omit symbols, so assign them after the numeric walk.
-                const p = n ? getStoreSymbols(e, i) : [];
-        for (let s = 0, l = p.length; s < l; s++) {
-            const l = p[s];
-            const a = getPropertyDescriptor(e, i, l);
-            if (!a || a.get) continue;
+                const a = n ? getStoreSymbols(e, i) : [];
+        for (let s = 0, l = a.length; s < l; s++) {
+            const l = a[s];
+            const p = getPropertyDescriptor(e, i, l);
+            if (!p || p.get) continue;
             u = i && l in i ? i[l] : e[l];
-            if (t && isWrappable(u)) wrap(u, o);
+            if (t && isWrappable(u) && !(rawValuesUsed && isRawValue(u))) wrap(u, o);
             f = snapshotImpl(u, t, r, n);
             if (f !== u || c) {
                 if (!c) r.set(e, c = Object.assign([ ...e ], e));
@@ -71,30 +83,30 @@ function snapshotImpl(e, t, r, n) {
         // A lookup means this object belongs to an immutable store backing tree,
         // even if that nested value has not needed its own proxy yet.
         const s = n ? getStoreKeys(e, undefined) : getKeys(e, undefined);
-        for (let i = 0, p = s.length; i < p; i++) {
-            const p = s[i];
-            const l = Object.getOwnPropertyDescriptor(e, p);
+        for (let i = 0, a = s.length; i < a; i++) {
+            const a = s[i];
+            const l = Object.getOwnPropertyDescriptor(e, a);
             if (l.get) continue;
             u = l.value;
-            if (t && isWrappable(u)) wrap(u, o);
+            if (t && isWrappable(u) && !(rawValuesUsed && isRawValue(u))) wrap(u, o);
             if ((f = snapshotImpl(u, t, r, n)) !== u || c) {
                 if (!c) {
                     c = Object.create(Object.getPrototypeOf(e));
                     Object.assign(c, e);
                 }
-                c[p] = f;
+                c[a] = f;
             }
         }
     } else {
         // An override only exists on a store record, and the target branch above
         // always set `lookup` alongside it — so this branch is always store-keyed.
         const s = getStoreKeys(e, i);
-        for (let p = 0, l = s.length; p < l; p++) {
-            let l = s[p];
-            const a = getPropertyDescriptor(e, i, l);
-            if (a.get) continue;
+        for (let a = 0, l = s.length; a < l; a++) {
+            let l = s[a];
+            const p = getPropertyDescriptor(e, i, l);
+            if (p.get) continue;
             u = l in i ? i[l] : e[l];
-            if (t && isWrappable(u)) wrap(u, o);
+            if (t && isWrappable(u) && !(rawValuesUsed && isRawValue(u))) wrap(u, o);
             if ((f = snapshotImpl(u, t, r, n)) !== e[l] || c) {
                 if (!c) {
                     c = Object.create(Object.getPrototypeOf(e));

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

@@ -72,6 +72,21 @@ export declare function untrack<T>(fn: () => T, strictReadLabel?: string | false
  * date so its status flags reflect the current graph.
  */
 export declare function prepareComputed(comp: Computed<unknown>, refresh: boolean): void;
+/**
+ * Sentinel returned by readNodeFast when the plain-signal fast path does not
+ * apply and the caller must fall back to the full read().
+ */
+export declare const READ_SLOW: unique symbol;
+/**
+ * read()'s plain-signal fast path as a standalone entry for hot callers
+ * (store traps). Safe to substitute for read() only because the bail
+ * conditions mirror read()'s prelude and fast-path guard exactly: the
+ * latestRead and pendingCheck windows run side-effectful hooks before the
+ * fast path, `_fn` nodes need prepareComputed, and firewall / override /
+ * snapshot / transition / lane / dev-strictRead state all take the full
+ * resolution. Anything slow returns READ_SLOW; the caller then calls read().
+ */
+export declare function readNodeFast<T>(el: Signal<T>): T | typeof READ_SLOW;
 export declare function read<T>(el: Signal<T> | Computed<T>): T;
 export declare function setSignal<T>(el: Signal<T> | Computed<T>, v: T | ((prev: T) => T)): T;
 /**

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/optimistic.d.ts

@@ -41,5 +41,5 @@ import { type NoFn, type ProjectionOptions, type Store, type StoreSetter } from
  *
  * @returns `[store: Store<T>, setStore: StoreSetter<T>]`
  */
-export declare function createOptimisticStore<T extends object = {}>(store: NoFn<T> | Store<NoFn<T>>): [get: Store<T>, set: StoreSetter<T>];
+export declare function createOptimisticStore<T extends object = {}>(store: NoFn<T> | Store<NoFn<T>>, options?: ProjectionOptions): [get: Store<T>, set: StoreSetter<T>];
 export declare function createOptimisticStore<T extends object = {}>(fn: (store: T) => void | T | Promise<void | T> | AsyncIterable<void | T>, store: Partial<T> | Store<NoFn<T>>, options?: ProjectionOptions): [get: Refreshable<Store<T>>, set: StoreSetter<T>];

package/dist/types/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/store/store.d.ts

@@ -31,6 +31,8 @@ export interface StoreOptions {
 export interface ProjectionOptions extends StoreOptions {
     /** Key property name or function for reconciliation identity */
     key?: string | ((item: NonNullable<any>) => any);
+    /** Single-layer store: root keys reactive, values raw records replaced by reference */
+    shallow?: boolean;
 }
 export type NoFn<T> = T extends Function ? never : T;
 type DataNode = Signal<any>;
@@ -42,7 +44,7 @@ type DataNodes = Record<PropertyKey, DataNode>;
  * @internal
  */
 export declare const $TRACK: unique symbol, $TARGET: unique symbol, $PROXY: unique symbol, $DELETED: unique symbol, $AFFECTS: unique symbol;
-export declare const STORE_VALUE = "v", STORE_OVERRIDE = "o", STORE_OPTIMISTIC_OVERRIDE = "x", STORE_NODE = "n", STORE_HAS = "h", STORE_CUSTOM_PROTO = "c", STORE_WRAP = "w", STORE_LOOKUP = "l", STORE_FIREWALL = "f", STORE_OPTIMISTIC = "p", STORE_OPTIMISTIC_OWNERS = "t", STORE_PARENT = "u", STORE_DESC = "d";
+export declare const STORE_VALUE = "v", STORE_OVERRIDE = "o", STORE_OPTIMISTIC_OVERRIDE = "x", STORE_NODE = "n", STORE_HAS = "h", STORE_CUSTOM_PROTO = "c", STORE_WRAP = "w", STORE_LOOKUP = "l", STORE_FIREWALL = "f", STORE_OPTIMISTIC = "p", STORE_OPTIMISTIC_OWNERS = "t", STORE_PARENT = "u", STORE_DESC = "d", STORE_SHALLOW = "s";
 export type StoreNode = {
     [$PROXY]: any;
     [STORE_VALUE]: Record<PropertyKey, any>;
@@ -58,6 +60,7 @@ export type StoreNode = {
     [STORE_OPTIMISTIC]?: boolean;
     [STORE_SNAPSHOT_PROPS]?: Record<PropertyKey, any>;
     [STORE_PARENT]?: StoreNode;
+    [STORE_SHALLOW]?: boolean;
     [STORE_DESC]?: boolean;
 };
 export declare namespace SolidStore {
@@ -68,7 +71,20 @@ export type NotWrappable = string | number | bigint | symbol | boolean | Functio
 export declare function createStoreProxy<T extends object>(value: T, traps?: ProxyHandler<StoreNode>, extend?: (target: StoreNode) => void): any;
 export declare const storeLookup: WeakMap<WeakKey, any>;
 export declare const symbolKeyedRecords: WeakSet<object>;
+export declare function lookupTarget(value: any, lookup?: WeakMap<any, any>): StoreNode | undefined;
+/**
+ * Marks a value as raw: no store will ever wrap it — every store presents it
+ * as-is, tracked by reference at whatever slot holds it and updated by
+ * replacement. Useful for class instances and external objects (editors,
+ * scene graphs, Maps) and for record-shaped data updated wholesale. Sticky
+ * for the value's lifetime.
+ */
+export declare let rawValuesUsed: boolean;
+export declare function isRawValue(value: any): boolean;
+export declare function markRaw<T>(value: T): T;
+export declare function markRawIngest(container: any): void;
 export declare function wrap<T extends Record<PropertyKey, any>>(value: T, target?: StoreNode): T;
+export declare function wrapShallow<T extends Record<PropertyKey, any>>(value: T): T;
 export declare function isWrappable<T>(obj: T | NotWrappable): obj is T;
 export declare function setWriteOverride(value: boolean): void;
 export declare function ownEnumerableKeys(o: object): (string | symbol)[];
@@ -176,6 +192,8 @@ export declare function storeSetter<T extends object>(store: Store<T>, fn: (draf
  *
  * @returns `[store: Store<T>, setStore: StoreSetter<T>]`
  */
-export declare function createStore<T extends object = {}>(store: NoFn<T> | Store<NoFn<T>>): StoreReturn<T>;
+export declare function createStore<T extends object = {}>(store: NoFn<T> | Store<NoFn<T>>, options?: StoreOptions & {
+    shallow?: boolean;
+}): StoreReturn<T>;
 export declare function createStore<T extends object = {}>(fn: (store: T) => void | T | Promise<void | T> | AsyncIterable<void | T>, store: Partial<T> | Store<NoFn<T>>, options?: ProjectionOptions): ProjectionStoreReturn<T>;
 export {};

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

@@ -72,6 +72,21 @@ export declare function untrack<T>(fn: () => T, strictReadLabel?: string | false
  * date so its status flags reflect the current graph.
  */
 export declare function prepareComputed(comp: Computed<unknown>, refresh: boolean): void;
+/**
+ * Sentinel returned by readNodeFast when the plain-signal fast path does not
+ * apply and the caller must fall back to the full read().
+ */
+export declare const READ_SLOW: unique symbol;
+/**
+ * read()'s plain-signal fast path as a standalone entry for hot callers
+ * (store traps). Safe to substitute for read() only because the bail
+ * conditions mirror read()'s prelude and fast-path guard exactly: the
+ * latestRead and pendingCheck windows run side-effectful hooks before the
+ * fast path, `_fn` nodes need prepareComputed, and firewall / override /
+ * snapshot / transition / lane / dev-strictRead state all take the full
+ * resolution. Anything slow returns READ_SLOW; the caller then calls read().
+ */
+export declare function readNodeFast<T>(el: Signal<T>): T | typeof READ_SLOW;
 export declare function read<T>(el: Signal<T> | Computed<T>): T;
 export declare function setSignal<T>(el: Signal<T> | Computed<T>, v: T | ((prev: T) => T)): T;
 /**

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/optimistic.d.cts

@@ -41,5 +41,5 @@ import { type NoFn, type ProjectionOptions, type Store, type StoreSetter } from
  *
  * @returns `[store: Store<T>, setStore: StoreSetter<T>]`
  */
-export declare function createOptimisticStore<T extends object = {}>(store: NoFn<T> | Store<NoFn<T>>): [get: Store<T>, set: StoreSetter<T>];
+export declare function createOptimisticStore<T extends object = {}>(store: NoFn<T> | Store<NoFn<T>>, options?: ProjectionOptions): [get: Store<T>, set: StoreSetter<T>];
 export declare function createOptimisticStore<T extends object = {}>(fn: (store: T) => void | T | Promise<void | T> | AsyncIterable<void | T>, store: Partial<T> | Store<NoFn<T>>, options?: ProjectionOptions): [get: Refreshable<Store<T>>, set: StoreSetter<T>];

package/dist/types-cjs/store/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/dist/types-cjs/store/store.d.cts

@@ -31,6 +31,8 @@ export interface StoreOptions {
 export interface ProjectionOptions extends StoreOptions {
     /** Key property name or function for reconciliation identity */
     key?: string | ((item: NonNullable<any>) => any);
+    /** Single-layer store: root keys reactive, values raw records replaced by reference */
+    shallow?: boolean;
 }
 export type NoFn<T> = T extends Function ? never : T;
 type DataNode = Signal<any>;
@@ -42,7 +44,7 @@ type DataNodes = Record<PropertyKey, DataNode>;
  * @internal
  */
 export declare const $TRACK: unique symbol, $TARGET: unique symbol, $PROXY: unique symbol, $DELETED: unique symbol, $AFFECTS: unique symbol;
-export declare const STORE_VALUE = "v", STORE_OVERRIDE = "o", STORE_OPTIMISTIC_OVERRIDE = "x", STORE_NODE = "n", STORE_HAS = "h", STORE_CUSTOM_PROTO = "c", STORE_WRAP = "w", STORE_LOOKUP = "l", STORE_FIREWALL = "f", STORE_OPTIMISTIC = "p", STORE_OPTIMISTIC_OWNERS = "t", STORE_PARENT = "u", STORE_DESC = "d";
+export declare const STORE_VALUE = "v", STORE_OVERRIDE = "o", STORE_OPTIMISTIC_OVERRIDE = "x", STORE_NODE = "n", STORE_HAS = "h", STORE_CUSTOM_PROTO = "c", STORE_WRAP = "w", STORE_LOOKUP = "l", STORE_FIREWALL = "f", STORE_OPTIMISTIC = "p", STORE_OPTIMISTIC_OWNERS = "t", STORE_PARENT = "u", STORE_DESC = "d", STORE_SHALLOW = "s";
 export type StoreNode = {
     [$PROXY]: any;
     [STORE_VALUE]: Record<PropertyKey, any>;
@@ -58,6 +60,7 @@ export type StoreNode = {
     [STORE_OPTIMISTIC]?: boolean;
     [STORE_SNAPSHOT_PROPS]?: Record<PropertyKey, any>;
     [STORE_PARENT]?: StoreNode;
+    [STORE_SHALLOW]?: boolean;
     [STORE_DESC]?: boolean;
 };
 export declare namespace SolidStore {
@@ -68,7 +71,20 @@ export type NotWrappable = string | number | bigint | symbol | boolean | Functio
 export declare function createStoreProxy<T extends object>(value: T, traps?: ProxyHandler<StoreNode>, extend?: (target: StoreNode) => void): any;
 export declare const storeLookup: WeakMap<WeakKey, any>;
 export declare const symbolKeyedRecords: WeakSet<object>;
+export declare function lookupTarget(value: any, lookup?: WeakMap<any, any>): StoreNode | undefined;
+/**
+ * Marks a value as raw: no store will ever wrap it — every store presents it
+ * as-is, tracked by reference at whatever slot holds it and updated by
+ * replacement. Useful for class instances and external objects (editors,
+ * scene graphs, Maps) and for record-shaped data updated wholesale. Sticky
+ * for the value's lifetime.
+ */
+export declare let rawValuesUsed: boolean;
+export declare function isRawValue(value: any): boolean;
+export declare function markRaw<T>(value: T): T;
+export declare function markRawIngest(container: any): void;
 export declare function wrap<T extends Record<PropertyKey, any>>(value: T, target?: StoreNode): T;
+export declare function wrapShallow<T extends Record<PropertyKey, any>>(value: T): T;
 export declare function isWrappable<T>(obj: T | NotWrappable): obj is T;
 export declare function setWriteOverride(value: boolean): void;
 export declare function ownEnumerableKeys(o: object): (string | symbol)[];
@@ -176,6 +192,8 @@ export declare function storeSetter<T extends object>(store: Store<T>, fn: (draf
  *
  * @returns `[store: Store<T>, setStore: StoreSetter<T>]`
  */
-export declare function createStore<T extends object = {}>(store: NoFn<T> | Store<NoFn<T>>): StoreReturn<T>;
+export declare function createStore<T extends object = {}>(store: NoFn<T> | Store<NoFn<T>>, options?: StoreOptions & {
+    shallow?: boolean;
+}): StoreReturn<T>;
 export declare function createStore<T extends object = {}>(fn: (store: T) => void | T | Promise<void | T> | AsyncIterable<void | T>, store: Partial<T> | Store<NoFn<T>>, options?: ProjectionOptions): ProjectionStoreReturn<T>;
 export {};

package/package.json

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