@solidjs/signals 2.0.0-rc.5 → 2.0.0-rc.7

package/dist/prod/boundaries.js

@@ -291,7 +291,9 @@ class CollectionQueue extends Queue {
             if (t) {
                 const e = this.v.size === 0;
                 this.v.add(t);
-                if (e) setSignal(this.D, true);
+                if (e) {
+                    setSignal(this.D, true);
+                }
                 if (this.ee & STATUS_ERROR) {
                     setSignal(this._, unwrapStatusError(t.o?._));
                 }

package/dist/prod/core/async.js

@@ -28,13 +28,15 @@ function addPendingSource(e, n) {
 }
 
 function removePendingSource(e, n) {
-    if (!e.o?.le?.delete(n)) return false;
-    if (e.o?.le.size === 0) if (e.o !== null) e.o.le = undefined;
+    const t = e.o?.le;
+    if (!t?.delete(n)) return false;
+    if (!t.size) e.o.le = undefined;
     return true;
 }
 
 function clearPendingSources(e) {
-    e.o?.le?.clear();
+    // This set is node-owned and never shared; dropping the sole reference
+    // releases the set and every entry without a redundant clear() walk.
     if (e.o !== null) e.o.le = undefined;
 }
 
@@ -140,6 +142,10 @@ function settleErroredDependents(e, n) {
 }
 
 function settlePendingSource(e) {
+    // The normal landing path already cleared the source's own set. Superseded
+    // re-parks arrive here with an abandoned self entry, which must retire in
+    // the same walk as its propagated copies.
+    removePendingSource(e, e);
     let n = false;
     let t;
     const r = new Set;
@@ -253,6 +259,10 @@ function handleAsync(e, n, t) {
         }
         settleTransition();
         notifyStatus(e, r ? STATUS_PENDING : STATUS_ERROR, t);
+        // A NotReady rejection is a landing into another pending source. The
+        // rejected flight will never settle its self entry, so transfer ownership
+        // after notifyStatus has propagated the replacement source.
+                if (r) settlePendingSource(e);
         e.Te = clock;
         // A real error settles derivatively-pending dependents (notifyStatus
         // cleared their pending sources), so stranded lazy ones release here —
@@ -267,14 +277,27 @@ function handleAsync(e, n, t) {
                 if (e.ie & (REACTIVE_DIRTY | REACTIVE_OPTIMISTIC_DIRTY)) return;
         settleTransition();
         const i = !!(e.S & STATUS_UNINITIALIZED);
+        // Captured before clearStatus wipes it: a quiet re-ask's landing may be
+        // transition-held below, and the displayed value keeps answering the same
+        // question until the hold commits — the classification must survive to
+        // that reveal or companion synchronization briefly classifies the held
+        // old value as pending, a one-frame pulse to direct observers (#3178).
+        // A truthy capture implies `_x` exists, so the restore writes it directly.
+                const l = e.o?.De;
         trimStaleDeps(e);
         clearStatus(e);
-        const l = resolveLane(e);
-        if (l) l.De.delete(e);
+        if (l) e.o.De = true;
+        const s = resolveLane(e);
+        if (s) s.Oe.delete(e);
         if (t) {
-            t(r);
+            try {
+                t(r);
+            } catch (e) {
+                handleError(e);
+                return;
+            }
             if (i) clearStatus(e, true);
-        } else if (e.o?.Oe !== undefined) {
+        } else if (e.o?.Pe !== undefined) {
             // Optimistic node — resting OR covered by an active override — holds
             // through the shared pending-node path, exactly like a plain async memo,
             // so the commit clears STATUS_UNINITIALIZED (#2806) and elevation to
@@ -284,8 +307,8 @@ function handleAsync(e, n, t) {
             // (A17 — every reader sees the override); the revert reveals whatever
             // has committed by then, so corrections reveal atomically with their
             // transition rather than escaping it.
-            if (e.Pe === NOT_PENDING) queuePendingNode(e);
-            e.Pe = r;
+            if (e.Re === NOT_PENDING) queuePendingNode(e);
+            e.Re = r;
             // The hold is a companion-visible write like any other (A13/A19): the
             // clearStatus() above computed its verdict before the hold existed, so
             // isPending must re-derive (the value is not final until commit — V1)
@@ -293,7 +316,7 @@ function handleAsync(e, n, t) {
             // only notified when the hold is visible to them: under an active
             // override every reader sees the override (A17), so waking subs would
             // re-show an unchanged view — the revert is the notification point.
-                        GlobalQueue.Re?.(e, r);
+                        GlobalQueue.Ue?.(e, r);
             if (!hasActiveOverride(e)) {
                 insertSubs(e);
             } else if (e.T & CONFIG_AUTHORITATIVE_OBSERVED) {
@@ -306,14 +329,14 @@ function handleAsync(e, n, t) {
                 // branch in recompute(). Optional call: the bit implies the
                 // optimistic engine WAS consulted, but the hook only installs with
                 // it — a bare-core build must not crash here.
-                GlobalQueue.Ue?.(e);
+                GlobalQueue.he?.(e);
             }
             e.Te = clock;
-        } else if (l) {
+        } else if (s) {
             // Route through lane's effect queue for independent flushing
-            const n = e.he;
+            const n = e.ge;
             const t = e.be;
-            const o = e.ge;
+            const o = e.pe;
             try {
                 if (!n && i || !o || !o(r, t)) {
                     e.be = r;
@@ -321,7 +344,7 @@ function handleAsync(e, n, t) {
                     // The latest() shadow write gives latest() effects independent lanes; the
                     // _pendingSignal update is a no-op repeat of the clearStatus() call above
                     // (computePendingState doesn't read _value).
-                                        GlobalQueue.Re?.(e, r);
+                                        GlobalQueue.Ue?.(e, r);
                     insertSubs(e, true);
                 }
             } catch (n) {
@@ -345,8 +368,12 @@ function handleAsync(e, n, t) {
         // (`_pendingValue` set above or inside setSignal) is not — the verdict's
         // held-value branch is window-gated, and commitPendingNode closes the
         // window when the hold commits, so no one-frame isPending pulse can leak
-        // to live observers between the landing and its commit (#2990).
-                if (e.Pe === NOT_PENDING) e.Ne = false;
+        // to live observers between the landing and its commit (#2990). The
+        // quiet re-ask classification follows the same schedule (#3178).
+                if (e.Re === NOT_PENDING) {
+            e.Ne = false;
+            if (l) e.o.De = false;
+        }
         settlePendingSource(e);
         schedule();
         flush();
@@ -505,7 +532,7 @@ function handleAsync(e, n, t) {
         // becomes disposal-bearing, which is exactly the class a directly
         // returned iterable already occupies.
                 const registerDeferredClose = n => {
-            if (!e.pe) e.pe = n; else if (Array.isArray(e.pe)) e.pe.push(n); else e.pe = [ e.pe, n ];
+            if (!e.Ge) e.Ge = n; else if (Array.isArray(e.Ge)) e.Ge.push(n); else e.Ge = [ e.Ge, n ];
         };
         n.then(r => {
             if (l) {
@@ -568,7 +595,7 @@ function clearStatus(e, n = false) {
     // The pending window is over; its quiet classification dies with it.
     // (Unconditional: _reask is baked into the node literals, so this is a
     // plain store to an existing slot — no shape change.)
-        if (e.o !== null) e.o.Ge = false;
+        if (e.o !== null) e.o.De = false;
     e.S = n ? 0 : e.S & STATUS_UNINITIALIZED;
     if (e.o?._) setPendingError(e);
     // Update pending signal for isPending() reactivity (companions only exist
@@ -584,7 +611,7 @@ function notifyStatus(e, n, t, r, o) {
     if (n === STATUS_ERROR && !(t instanceof StatusError) && !(t instanceof NotReadyError)) t = new StatusError(e, t);
     const i = n === STATUS_PENDING && t instanceof NotReadyError ? t.source : undefined;
     const l = i === e;
-    const s = n === STATUS_PENDING && e.o?.Oe !== undefined && !l;
+    const s = n === STATUS_PENDING && e.o?.Pe !== undefined && !l;
     const u = s && hasActiveOverride(e);
     if (!r) {
         if (n === STATUS_PENDING && i) {

package/dist/prod/core/attribution-hooks.js

@@ -0,0 +1,3 @@
+let attrHooks = null;
+
+export { attrHooks };

package/dist/prod/core/constants.js

@@ -137,6 +137,14 @@ const CONFIG_HAS_LANE = 1 << 10;
  * (A17). Cleared at commit (the commit IS the reveal); subscribers masked
  * during the hold are woken by finalizePureQueue's post-revert pass. */ const CONFIG_HELD_TRUTH = 1 << 17;
 
+/** SLOT node (store leaf): created through `slotSignal` with `_host`/`_key`
+ * backrefs baked into the literal. The unobserved sweep dispatches these to
+ * the ONE shared hook (`setSlotUnobserved`) instead of a per-node closure
+ * held in a per-node extension — store mounts materialize one signal per
+ * touched leaf, so per-node allocations (options object, equals closure,
+ * unobserved closure, NodeExtension) were the measured create-floor bytes
+ * (warm dbmon profile: store node machinery ~36% + GC ~29%). */ const CONFIG_SLOT_NODE = 1 << 18;
+
 const STATUS_PENDING = 1 << 0;
 
 const STATUS_ERROR = 1 << 1;
@@ -181,4 +189,4 @@ const defaultContext = {};
  * @internal
  */ const $REFRESH = Symbol("refresh");
 
-export { $REFRESH, CONFIG_AUTHORITATIVE_OBSERVED, CONFIG_AUTHORITATIVE_READ, CONFIG_AUTO_DISPOSE, CONFIG_CHILDREN_FORBIDDEN, CONFIG_CHILD_COMPANIONS, CONFIG_DIRECT_COMMIT, CONFIG_FRESH_READ, CONFIG_FW_CHILDREN, CONFIG_HAS_COMPANIONS, CONFIG_HAS_LANE, CONFIG_HAS_SNAPSHOT, CONFIG_HELD_TRUTH, CONFIG_IN_SNAPSHOT_SCOPE, CONFIG_NO_SNAPSHOT, CONFIG_OPTIMISTIC, CONFIG_OWNED_WRITE, CONFIG_SYNC, CONFIG_TRANSPARENT, EFFECT_RENDER, EFFECT_TRACKED, EFFECT_USER, NOT_PENDING, NO_SNAPSHOT, OVERRIDE_UNDEFINED, REACTIVE_CHECK, REACTIVE_DIRTY, REACTIVE_DISPOSED, REACTIVE_IN_HEAP, REACTIVE_IN_HEAP_HEIGHT, REACTIVE_LAZY, REACTIVE_MANUAL_WRITE, REACTIVE_MISSED_WAKE, REACTIVE_NONE, REACTIVE_OPTIMISTIC_DIRTY, REACTIVE_REASK, REACTIVE_RECOMPUTING_DEPS, REACTIVE_SNAPSHOT_STALE, REACTIVE_ZOMBIE, STATUS_ERROR, STATUS_PENDING, STATUS_UNINITIALIZED, STORE_SNAPSHOT_PROPS, SUPPORTS_PROXY, defaultContext, unwrapOverride };
+export { $REFRESH, CONFIG_AUTHORITATIVE_OBSERVED, CONFIG_AUTHORITATIVE_READ, CONFIG_AUTO_DISPOSE, CONFIG_CHILDREN_FORBIDDEN, CONFIG_CHILD_COMPANIONS, CONFIG_DIRECT_COMMIT, CONFIG_FRESH_READ, CONFIG_FW_CHILDREN, CONFIG_HAS_COMPANIONS, CONFIG_HAS_LANE, CONFIG_HAS_SNAPSHOT, CONFIG_HELD_TRUTH, CONFIG_IN_SNAPSHOT_SCOPE, CONFIG_NO_SNAPSHOT, CONFIG_OPTIMISTIC, CONFIG_OWNED_WRITE, CONFIG_SLOT_NODE, CONFIG_SYNC, CONFIG_TRANSPARENT, EFFECT_RENDER, EFFECT_TRACKED, EFFECT_USER, NOT_PENDING, NO_SNAPSHOT, OVERRIDE_UNDEFINED, REACTIVE_CHECK, REACTIVE_DIRTY, REACTIVE_DISPOSED, REACTIVE_IN_HEAP, REACTIVE_IN_HEAP_HEIGHT, REACTIVE_LAZY, REACTIVE_MANUAL_WRITE, REACTIVE_MISSED_WAKE, REACTIVE_NONE, REACTIVE_OPTIMISTIC_DIRTY, REACTIVE_REASK, REACTIVE_RECOMPUTING_DEPS, REACTIVE_SNAPSHOT_STALE, REACTIVE_ZOMBIE, STATUS_ERROR, STATUS_PENDING, STATUS_UNINITIALIZED, STORE_SNAPSHOT_PROPS, SUPPORTS_PROXY, defaultContext, unwrapOverride };

package/dist/prod/core/context.js

@@ -29,11 +29,13 @@ import { getOwner } from "./owner.js";
     if (!t) {
         throw new NoOwnerError;
     }
-    const n = hasContext(e, t) ? t.we[e.id] : e.defaultValue;
-    if (isUndefined(n)) {
+    // `undefined` alone means unset — a provided `null` is a value (no `??`).
+        let r = t.we[e.id];
+    if (r === undefined) r = e.defaultValue;
+    if (r === undefined) {
         throw new ContextNotFoundError;
     }
-    return n;
+    return r;
 }
 
 /**
@@ -44,24 +46,16 @@ import { getOwner } from "./owner.js";
  * @throws `NoOwnerError` if there's no owner at the time of call.
  *
  * @internal
- */ function setContext(e, t, n = getOwner()) {
-    if (!n) {
+ */ function setContext(e, t, r = getOwner()) {
+    if (!r) {
         throw new NoOwnerError;
     }
     // We're creating a new object to avoid child context values being exposed to parent owners. If
     // we don't do this, everything will be a singleton and all hell will break lose.
-        n.we = {
-        ...n.we,
-        [e.id]: isUndefined(t) ? e.defaultValue : t
+        r.we = {
+        ...r.we,
+        [e.id]: t === undefined ? e.defaultValue : t
     };
 }
 
-function hasContext(e, t) {
-    return !isUndefined(t?.we[e.id]);
-}
-
-function isUndefined(e) {
-    return typeof e === "undefined";
-}
-
 export { createContext, getContext, setContext };