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

package/dist/prod/store/store.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);
     }
@@ -255,7 +263,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._e !== NOT_PENDING ? e._e : e.Ue;
 }
 
 function hasOwnStoreProperty(e, t) {
@@ -306,11 +314,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);
@@ -428,11 +436,11 @@ o) {
     // Callers guard on `pendingCheckActive`, which only flips inside
     // isPending() — the verdict layer is loaded and its hook installed.
     const r = e[STORE_NODE]?.[$AFFECTS];
-    if (r?.t) GlobalQueue.Lt(r);
+    if (r?.t) GlobalQueue.Dt(r);
     if (affectsScopes.size) {
         const n = e[STORE_VALUE];
         for (const [e, o] of affectsScopes) {
-            if (e !== r && e.t && o.scope.has(n) && (o.key === undefined || o.key === t)) GlobalQueue.Lt(e);
+            if (e !== r && e.t && o.scope.has(n) && (o.key === undefined || o.key === t)) GlobalQueue.Dt(e);
         }
     }
 }
@@ -574,8 +582,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];
@@ -756,20 +764,27 @@ const storeTraps = {
             Writing?.add(n);
             return n;
         }
-        let c = i ? E || !S ? read(o[t]) : (read(o[t]), f[t]) : f[t];
-        c === $DELETED && (c = undefined);
+        let R = i ? E || !S ? read(o[t]) : (read(o[t]), f[t]) : f[t];
+        R === $DELETED && (R = undefined);
         if (!i) {
-            if (!E && typeof c === "function" && !Object.prototype.hasOwnProperty.call(f, t)) {
+            if (!E && typeof R === "function" && !Object.prototype.hasOwnProperty.call(f, 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 ? R.bind(f) : R;
             } else if (getObserver() && !n) {
-                return read(getNode(e, o, t, isWrappable(c) ? wrap(c, e) : c, isEqual, e[STORE_SNAPSHOT_PROPS]));
+                return read(getNode(e, o, t, isWrappable(R) ? wrap(R, e) : R, 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(c) ? wrap(c, e) : c;
+        // 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()) throwIfUninitialized(e);
+        return isWrappable(R) ? wrap(R, e) : R;
     },
     has(e, t) {
         if (t === $PROXY || t === $TRACK || t === "__proto__") return true;
@@ -800,37 +815,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 f = !!e[STORE_SHALLOW] && r?.[$TARGET] !== undefined;
+                const R = f ? r : unwrapStoreValue(r);
+                if (e[STORE_SHALLOW] && !f && isWrappable(R)) {
+                    // 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(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 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 T = Array.isArray(O) && Number.isInteger(c) && c >= 0 && c < 4294967295 && String(c) === t;
+                const u = T ? c + 1 : 0;
+                const a = T && (getOverlayLayer(e, "length") ?? O).length;
+                const l = T && u > a ? u : undefined;
+                if (E === R && l === undefined) return true;
                 armOptimisticStoreWrite(e, n);
-                if (f !== undefined && f === o && a === undefined) {
+                if (R !== undefined && R === 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] = R;
                     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", R, 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 R === "number" && typeof E === "number" && R < E) {
                     const t = e[i] || (e[i] = Object.create(null));
-                    for (let r = f; r < E; r++) {
+                    for (let r = R; 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 +866,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) ;

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

@@ -3,6 +3,7 @@ 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 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/async.d.cts

@@ -3,6 +3,7 @@ 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 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/package.json

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