@solidjs/signals 2.0.0-rc.6 → 2.0.0-rc.8

package/dist/prod/core/verdict.js

@@ -10,7 +10,7 @@ import { insertIntoHeap, queueFor, markHeap, enqueueSub } from "./heap.js";
 
 import "./invariants.js";
 
-import { findLane, hasActiveOverride, assignOrMergeLane } from "./lanes.js";
+import { findLane, laneHeld, hasActiveOverride, assignOrMergeLane } from "./lanes.js";
 
 import { installOptimisticEngine } from "./optimistic.js";
 
@@ -47,23 +47,23 @@ let pendingProbe = null;
  * O(all-leaves-ever-read)-per-update pathology). Entries are permanent like
  * the companions themselves; a store with no leaf-level isPending()/latest()
  * reads never allocates the set or pays the walk. */ function markFirewallChildCompanions(e) {
-    const t = e.st;
+    const t = e.ce;
     if (!t) return;
     t.T |= CONFIG_CHILD_COMPANIONS;
-    (ext(t).St ??= new Set).add(e);
+    (ext(t).Dt ??= new Set).add(e);
 }
 
 function getPendingSignal(e) {
-    let t = e.o?.ye;
+    let t = e.o?.Le;
     if (!t) {
         // Start false, write true if pending - ensures reversion returns to false
         t = optimisticSignal(false, {
             ownedWrite: true
         });
-        ext(e).ye = t;
+        ext(e).Le = t;
         e.T |= CONFIG_HAS_COMPANIONS;
         markFirewallChildCompanions(e);
-        ext(t).Tt = e;
+        ext(t).Gt = e;
         if (computePendingState(e)) setSignal(t, true);
     }
     return t;
@@ -72,7 +72,7 @@ function getPendingSignal(e) {
 function collectPendingSources(e) {
     if (!pendingProbe) return;
     pendingProbe.sources.add(e);
-    const t = e.st || e;
+    const t = e.ce || e;
     if (t !== e) pendingProbe.sources.add(t);
 }
 
@@ -105,33 +105,29 @@ function collectPendingSources(e) {
         if (e.S & STATUS_ERROR) return false;
     if (t.has(e)) return false;
     t.add(e);
-    const n = e.st;
+    const n = e.ce;
     if (n && markWalk(n, t)) return true;
     // Mid-recompute (the clearStatus companion poke runs before
     // trimStaleDeps), only the validated prefix [_deps.._depsTail] is this
     // pass's dependency set — walking past it would read dropped deps and
     // latch a stale verdict on the companion.
         const i = e;
-    const r = i.ie & REACTIVE_RECOMPUTING_DEPS ? i.je : undefined;
+    const r = i.ie & REACTIVE_RECOMPUTING_DEPS ? i.et : undefined;
     if (r !== null) {
-        for (let e = i.ut ?? null; e !== null; e = e.lt) {
-            if (!e.ve && markWalk(e.ot, t)) return true;
+        for (let e = i.fe ?? null; e !== null; e = e.ae) {
+            if (!e.je && markWalk(e.Se, t)) return true;
             if (e === r) break;
         }
     }
     return false;
 }
 
-/** Gated entry: apps with no live mark pay one integer compare. */ function markCovered(e) {
-    return activeAffectsMarks !== 0 && markWalk(e, new Set);
-}
-
 function quietPending(e) {
     if (e.o?.le) {
-        for (const t of e.o.le) if (!t.o?.De) return false;
+        for (const t of e.o.le) if (!t.o?.Ue) return false;
         return true;
     }
-    return e.o?.De ?? false;
+    return e.o?.Ue ?? false;
 }
 
 // NOTE: a loadingValue node's open loading window (_loading) is verdict-quiet
@@ -151,45 +147,46 @@ function computePendingState(e) {
     // Mark coverage is transitive by dep-graph reachability: a latest() shadow
     // reaches its owner (and a store leaf its firewall) through its own deps,
     // so the one walk covers direct marks, derivation, and companion chains.
-        if (markCovered(e)) return true;
-    const n = e.st;
-    if (e.o?.Tt) {
-        const t = e.o?.Tt;
-        const n = t.st || t;
+    // Gated: apps with no live mark pay one integer compare.
+        if (activeAffectsMarks !== 0 && markWalk(e, new Set)) return true;
+    const n = e.ce;
+    if (e.o?.Gt) {
+        const t = e.o?.Gt;
+        const n = t.ce || t;
         return newQuestionInFlight(n);
     }
-    if (n && e.Re !== NOT_PENDING && !hasActiveOverride(e)) {
-        return !!(n.ie & REACTIVE_MANUAL_WRITE) || !n.o?.Ie && !(n.S & STATUS_PENDING) || !!(n.S & STATUS_PENDING) && quietPending(n);
+    if (n && e.Ge !== NOT_PENDING && !hasActiveOverride(e)) {
+        return !!(n.ie & REACTIVE_MANUAL_WRITE) || !n.o?.Pe && !(n.S & STATUS_PENDING) || !!(n.S & STATUS_PENDING) && quietPending(n);
     }
     // `!comp._loading`: a hold created while the loading window is still open is
     // the window's own landing in flight to its commit — verdict-quiet like the
     // rest of the window (the UNINITIALIZED check suppresses exactly this frame
     // for windowless first loads; born-committed nodes need their own gate, #2990).
-        if (e.Re !== NOT_PENDING && !(t.S & STATUS_UNINITIALIZED) && !t.Ne) {
-        if (hasActiveOverride(e)) return !e.pe || !e.pe(e.Re, unwrapOverride(e.o?.Pe));
+        if (e.Ge !== NOT_PENDING && !(t.S & STATUS_UNINITIALIZED) && !t.Ae) {
+        if (hasActiveOverride(e)) return !e.ve || !e.ve(e.Ge, unwrapOverride(e.o?.be));
         // A quiet re-ask's held landing still answers the same question: the
         // classification survives the landing (asyncWrite) and dies with the
         // commit (commitPendingNode) — verdict-quiet through the reveal, like
         // the loading window above (#3178).
-                if (!t.o?.De) return true;
+                if (!t.o?.Ue) return true;
     }
     return newQuestionInFlight(t);
 }
 
 function syncCompanions(e, t) {
-    if (e.o?.ye) updatePendingSignal(e);
-    if (e.o?.Ce) setSignal(e.o?.Ce, t);
+    if (e.o?.Le) updatePendingSignal(e);
+    if (e.o?.Qe) setSignal(e.o?.Qe, t);
 }
 
 function updatePendingSignal(e) {
-    if (e.o?.ye) {
-        setSignal(e.o?.ye, computePendingState(e));
+    if (e.o?.Le) {
+        setSignal(e.o?.Le, computePendingState(e));
     }
-    if (e.o?.Ce) updatePendingSignal(e.o?.Ce);
+    if (e.o?.Qe) updatePendingSignal(e.o?.Qe);
 }
 
 function updateChildCompanions(e) {
-    const t = e.o?.St;
+    const t = e.o?.Dt;
     if (t === undefined) return;
     for (const e of t) updatePendingSignal(e);
 }
@@ -208,9 +205,9 @@ function updateChildCompanions(e) {
     const visit = e => {
         if (i.has(e)) return;
         i.add(e);
-        if (e.o?.ye || e.o?.Ce) n(e);
-        for (let t = e.u; t !== null; t = t.ae) visit(t.ce);
-        for (let t = e.o?.i ?? null; t !== null; t = t.Se) {
+        if (e.o?.Le || e.o?.Qe) n(e);
+        for (let t = e.u; t !== null; t = t.Te) visit(t.Ie);
+        for (let t = e.o?.i ?? null; t !== null; t = t.Ee) {
             visit(t);
         }
     };
@@ -231,7 +228,7 @@ function updateChildCompanions(e) {
     if (suppressedProbes.size === 0) return;
     let t = false;
     for (const [n, i] of suppressedProbes) {
-        const r = n.Ae;
+        const r = n.ge;
         const s = r ? currentTransition(r) : null;
         if (!s) {
             suppressedProbes.delete(n);
@@ -239,11 +236,11 @@ function updateChildCompanions(e) {
         }
         if (s !== e) continue;
         suppressedProbes.delete(n);
-        const o = n.o?.ye?.o?.Je;
+        const o = n.o?.Le?.o?.Oe;
         for (const e of i) {
             if (e.ie & REACTIVE_DISPOSED) continue;
             e.ie |= REACTIVE_OPTIMISTIC_DIRTY;
-            if (o) assignOrMergeLane(e, o); else if (e.o !== null) e.o.Je = undefined;
+            if (o) assignOrMergeLane(e, o); else if (e.o !== null) e.o.Oe = undefined;
             enqueueSub(e);
             t = true;
         }
@@ -253,19 +250,19 @@ function updateChildCompanions(e) {
 
 function snapCompanionsToState(e) {
     suppressedProbes.size !== 0 && suppressedProbes.delete(e);
-    const t = e.o?.ye;
-    if (t && (t.o?.Pe === undefined || t.o?.Pe === NOT_PENDING)) {
+    const t = e.o?.Le;
+    if (t && (t.o?.be === undefined || t.o?.be === NOT_PENDING)) {
         const n = computePendingState(e);
-        if (t.be !== n || t.Re !== NOT_PENDING) {
-            t.be = n;
-            t.Re = NOT_PENDING;
+        if (t.me !== n || t.Ge !== NOT_PENDING) {
+            t.me = n;
+            t.Ge = NOT_PENDING;
             insertSubs(t);
             schedule();
         }
     }
-    const n = e.o?.Ce;
+    const n = e.o?.Qe;
     if (n && !(n.ie & REACTIVE_DISPOSED)) {
-        if ((n.o?.Pe === undefined || n.o?.Pe === NOT_PENDING) && n.Re === NOT_PENDING && !Object.is(n.be, e.be) && !(n.ie & (REACTIVE_DIRTY | REACTIVE_CHECK))) {
+        if ((n.o?.be === undefined || n.o?.be === NOT_PENDING) && n.Ge === NOT_PENDING && !Object.is(n.me, e.me) && !(n.ie & (REACTIVE_DIRTY | REACTIVE_CHECK))) {
             n.ie |= REACTIVE_DIRTY;
             insertIntoHeap(n, queueFor(n));
             insertSubs(n);
@@ -276,7 +273,7 @@ function snapCompanionsToState(e) {
 }
 
 function getLatestValueComputed(e) {
-    let t = e.o?.Ce;
+    let t = e.o?.Qe;
     // A shadow disposed while unobserved (its gated reader unmounted at a
     // landing) is a corpse: sync writes into it equality-swallow against its
     // frozen _value, and a later read revives it via recompute — clearing
@@ -293,16 +290,16 @@ function getLatestValueComputed(e) {
         setContextInternal(null);
  // Detach from owner so it isn't disposed with effects
                 t = optimisticComputed(() => read(e));
-        ext(e).Ce = t;
+        ext(e).Qe = t;
         e.T |= CONFIG_HAS_COMPANIONS;
         markFirewallChildCompanions(e);
-        ext(t).Tt = e;
+        ext(t).Gt = e;
  // Parent-child lane relationship
         // Backfill an in-flight write (mirrors getPendingSignal): the companion is
         // created lazily, possibly after the write was processed — syncCompanions
         // only pushes into companions that already exist, so the first latest()
         // read inside a held transition showed the committed value (#3041).
-                if (e.Re !== NOT_PENDING && !hasActiveOverride(e)) setSignal(t, e.Re);
+                if (e.Ge !== NOT_PENDING && !hasActiveOverride(e)) setSignal(t, e.Ge);
         setContextInternal(r);
         setPendingCheckActive(i);
         setLatestReadActive(n);
@@ -314,7 +311,7 @@ function getLatestValueComputed(e) {
     const t = getLatestValueComputed(e);
     const n = latestReadActive;
     setLatestReadActive(false);
-    const i = e.o?.Pe !== undefined && e.o?.Pe !== NOT_PENDING ? unwrapOverride(e.o?.Pe) : e.be;
+    const i = e.o?.be !== undefined && e.o?.be !== NOT_PENDING ? unwrapOverride(e.o?.be) : e.me;
     let r;
     try {
         // An untracked latest() read has no reading context, so read() never
@@ -323,7 +320,7 @@ function getLatestValueComputed(e) {
         // until the flush (#2922). Mirror the tracked-read pull here: mark the
         // queued staleness through the graph, then bring the shadow up to date.
         const e = queueFor(t);
-        if (t.Me >= e.Qe && !(t.ie & (REACTIVE_DISPOSED | REACTIVE_ZOMBIE))) {
+        if (t.Be >= e.Ke && !(t.ie & (REACTIVE_DISPOSED | REACTIVE_ZOMBIE))) {
             markHeap(e);
             // Suspend probe collection during the pull (mirrors pendingCheckRead's
             // prepare): a probe through latest() answers for the SHADOW — the
@@ -350,10 +347,10 @@ function getLatestValueComputed(e) {
         setLatestReadActive(n);
     }
     if (t.S & STATUS_PENDING) return i;
-    if (stale && currentOptimisticLane && t.o?.Je) {
-        const e = findLane(t.o?.Je);
+    if (stale && currentOptimisticLane && t.o?.Oe) {
+        const e = findLane(t.o?.Oe);
         const n = findLane(currentOptimisticLane);
-        if (e !== n && e.Oe.size > 0) {
+        if (e !== n && laneHeld(e)) {
             return i;
         }
     }
@@ -361,7 +358,7 @@ function getLatestValueComputed(e) {
     // speculative value in _pendingValue; a contextless read() only surfaces
     // _value. Overrides stay authoritative (A17), and stale readers keep the
     // other transition's committed view, matching read()'s own selection.
-        if (t.Re !== NOT_PENDING && !hasActiveOverride(t) && !(stale && t.Ae && activeTransition !== t.Ae)) return t.Re;
+        if (t.Ge !== NOT_PENDING && !hasActiveOverride(t) && !(stale && t.ge && activeTransition !== t.ge)) return t.Ge;
     return r;
 }
 
@@ -375,9 +372,9 @@ function getLatestValueComputed(e) {
  * so the `_fn` check is belt-and-braces for this call site.
  */ function latestShadowWithInitializedParent(e) {
     if (typeof e.oe !== "function") return false;
-    const t = e.o?.Tt;
+    const t = e.o?.Gt;
     if (t === undefined) return false;
-    const n = t.st || t;
+    const n = t.ce || t;
     return !(n.S & STATUS_UNINITIALIZED);
 }
 
@@ -413,9 +410,9 @@ function getLatestValueComputed(e) {
  * reader saw is an input, and pending remains the truth for every reader
  * (#3028).
  */ function heldAwaitingAsync(e) {
-    const t = e.Ae;
+    const t = e.ge;
     const n = t ? currentTransition(t) : activeTransition;
-    if (!n || n.sn) return false;
+    if (!n || n.ft) return false;
     // A plain staged write (a signal/store leaf — no _fn) held while an action
     // is still running is an INPUT to a computation still in flight (#3078):
     // the pairing rule must not suppress the verdict, or a memo recomputing
@@ -430,14 +427,14 @@ function getLatestValueComputed(e) {
     // action check above; the reporter scan below is for transition-held
     // writes whose source async is still computing.
         if (!t) return false;
-    for (const [e, t] of n._e) {
+    for (const [e, t] of n.Re) {
         if (t.size && e.S & STATUS_PENDING && e.o?._?.source === e) return true;
     }
     return false;
 }
 
 function recordFreshRead(e, t) {
-    if (pendingProbe !== null && e.Re !== NOT_PENDING && t === e.Re) {
+    if (pendingProbe !== null && e.Ge !== NOT_PENDING && t === e.Ge) {
         if (heldAwaitingAsync(e)) return;
         pendingProbe.freshReads.add(e);
     }
@@ -445,10 +442,10 @@ function recordFreshRead(e, t) {
 
 function applyReask(e, t) {
     const n = !!(e.S & STATUS_PENDING);
-    const i = t && !(n && !e.o?.De);
-    const r = n && (e.o?.De ?? false) !== i;
+    const i = t && !(n && !e.o?.Ue);
+    const r = n && (e.o?.Ue ?? false) !== i;
     // Allocation-free for the quiet case: false is the extension default.
-        if (i) ext(e).De = true; else if (e.o !== null) e.o.De = false;
+        if (i) ext(e).Ue = true; else if (e.o !== null) e.o.Ue = false;
     return r;
 }
 
@@ -529,26 +526,26 @@ function isPending(e) {
 // Hook installation (same late-binding pattern as GlobalQueue._update /
 // _propagateAffects): core call sites fire these behind the same guards the
 // direct calls used, so behavior is identical once this module loads.
-GlobalQueue.Ue = syncCompanions;
+GlobalQueue.pe = syncCompanions;
 
-GlobalQueue.de = updatePendingSignal;
+GlobalQueue.Ne = updatePendingSignal;
 
-GlobalQueue.me = updateChildCompanions;
+GlobalQueue.ke = updateChildCompanions;
 
 GlobalQueue.un = snapCompanionsToState;
 
-GlobalQueue.gt = latestRead;
+GlobalQueue.wt = latestRead;
 
-GlobalQueue.Ht = pendingCheckRead;
+GlobalQueue.Wt = pendingCheckRead;
 
-GlobalQueue.kt = recordFreshRead;
+GlobalQueue.jt = recordFreshRead;
 
-GlobalQueue.et = applyReask;
+GlobalQueue.st = applyReask;
 
 GlobalQueue.k = repollDownstreamVerdicts;
 
-GlobalQueue.Wt = witnessAffects;
+GlobalQueue.ri = witnessAffects;
 
-GlobalQueue.zt = wakeSuppressedProbes;
+GlobalQueue.si = wakeSuppressedProbes;
 
 export { isPending, latest };

package/dist/prod/index.js

@@ -36,14 +36,18 @@ export { createOptimisticStoreNext as createOptimisticStore } from "./store/next
 
 export { createProjectionNext as createProjection } from "./store/next/projection.js";
 
-export { merge, omit } from "./store/utils.js";
-
-export { patchableRaw, registerPatch, registerRowOps, registerSlotPatchNext as registerSlotPatch } from "./store/next/patch.js";
+export { merge, mergeSources, omit } from "./store/utils.js";
 
 export { storeHasFamily, storeHasOptimisticFamily, storeIsShallow } from "./store/next/store.js";
 
 export { storePath } from "./store/storePath.js";
 
-const DEV = undefined;
+/**
+ * Observe tier (diagnostics channel, attribution hook slot + interaction
+ * frame): dev and observe builds. The attribution engine itself is the
+ * `@solidjs/signals/attribution` entry.
+ */ const OBSERVE = undefined;
+
+/** Dev tier (devtools hooks, graph traversal, console reporting): dev builds only. */ const DEV = undefined;
 
-export { DEV };
+export { DEV, OBSERVE };