@solidjs/signals 2.0.0-rc.0 → 2.0.0-rc.1

package/dist/prod/core/scheduler.js

@@ -59,13 +59,9 @@ let projectionWriteActive = false;
 // releasing the slot in the parent store's node map.
 const transientStoreNodes = new Set;
 
-function registerTransientStoreNode(e) {
-    transientStoreNodes.add(e);
-}
-
 function canUseSimpleSyncFlush(e) {
     const t = e.m;
-    return transitions.size === 0 && activeLanes.size === 0 && e.vt.length === 0 && t.Me.length === 0 && t.A.length === 0 && t.cn.size === 0 && transientStoreNodes.size === 0;
+    return transitions.size === 0 && activeLanes.size === 0 && e.vt.length === 0 && t.Me.length === 0 && t.A.length === 0 && t.dn.size === 0 && transientStoreNodes.size === 0;
 }
 
 function sweepTransientStoreNodes() {
@@ -75,8 +71,8 @@ function sweepTransientStoreNodes() {
             transientStoreNodes.delete(e);
             continue;
         }
-        if (e.De !== NOT_PENDING) continue;
-        if (e._e !== undefined && e._e !== NOT_PENDING) continue;
+        if (e._e !== NOT_PENDING) continue;
+        if (e.De !== undefined && e.De !== NOT_PENDING) continue;
         // A live affects() mark keeps the node addressable: sweeping it would
         // detach the refcount from the slot (a fresh probe would upsert a new,
         // unmarked node for the same property).
@@ -114,7 +110,7 @@ function setProjectionWriteActive(e) {
         Ie: new Map,
         Me: [],
         A: [],
-        cn: new Set,
+        dn: new Set,
         ie: [],
         yt: {
             bt: [ [], [] ],
@@ -143,7 +139,7 @@ function mergeTransitionState(e, t) {
         e.A.push(...t.A);
         t.A.length = 0;
     }
-    for (const i of t.cn) e.cn.add(i);
+    for (const i of t.dn) e.dn.add(i);
     for (const [i, n] of t.Ie) {
         let t = e.Ie.get(i);
         if (!t) e.Ie.set(i, t = new Set);
@@ -159,7 +155,7 @@ function schedule() {
     }
     if (scheduled) return;
     scheduled = true;
-    if (!syncDepth && !globalQueue.gt && !projectionWriteActive) queueMicrotask(flush);
+    if (!syncDepth && !globalQueue.cn && !projectionWriteActive) queueMicrotask(flush);
 }
 
 /**
@@ -193,24 +189,24 @@ function notifyHalted() {
 let queueRunToken = 0;
 
 class Queue {
-    ke=null;
+    Fe=null;
     bt=[ [], [] ];
     vt=[];
     kt=0;
     created=clock;
     addChild(e) {
         this.vt.push(e);
-        e.ke = this;
+        e.Fe = this;
     }
     removeChild(e) {
         const t = this.vt.indexOf(e);
         if (t >= 0) {
             this.vt.splice(t, 1);
-            e.ke = null;
+            e.Fe = null;
         }
     }
     notify(e, t, i, n) {
-        if (this.ke) return this.ke.notify(e, t, i, n);
+        if (this.Fe) return this.Fe.notify(e, t, i, n);
         return false;
     }
     run(e) {
@@ -282,14 +278,14 @@ class Queue {
 }
 
 class GlobalQueue extends Queue {
-    gt=false;
+    cn=false;
     // The current transaction-shaped batch: a plain ambient batch while no
     // transition is active, the active transition itself after initTransition.
     m=createBatch();
     static Ce;
     static me;
     static et;
-    static Dt=null;
+    static gt=null;
     // Store-side hook: drops a keyless affects() mark's identity scope when the
     // carrier node's last registration releases (wired by store.ts, mirroring
     // _clearOptimisticStore).
@@ -303,7 +299,7 @@ class GlobalQueue extends Queue {
     static h=null;
     // External-source bridge (wired by enableExternalSource(); null while no
     // config is active — including after _resetExternalSourceConfig()).
-    static It=null;
+    static dt=null;
     static St=null;
     // Verdict-layer hooks (wired by verdict.ts when isPending()/latest() are
     // imported; null in apps that never use them). Call sites either guard for
@@ -313,12 +309,12 @@ class GlobalQueue extends Queue {
     // isPending()/latest()).
     static Pe=null;
     static Se=null;
-    static Oe=null;
+    static Ge=null;
     static un=null;
     static At=null;
     static Ct=null;
-    static ht=null;
-    static Be=null;
+    static Pt=null;
+    static $e=null;
     static k=null;
     static Lt=null;
     // Optimistic-engine hooks (wired by core/optimistic.ts via
@@ -331,18 +327,18 @@ class GlobalQueue extends Queue {
     static Gt=null;
     static En=null;
     static Tn=null;
-    static dn=null;
     static In=null;
+    static Nn=null;
     static Rt=null;
     static Ot=null;
-    static Pt=null;
+    static Dt=null;
     static je=null;
-    static $e=null;
     static ze=null;
-    static Nn=null;
+    static Be=null;
+    static Qn=null;
     flush() {
-        if (this.gt) return;
-        this.gt = true;
+        if (this.cn) return;
+        this.cn = true;
         try {
             if (false) ;
             runHeap(dirtyQueue, GlobalQueue.Ce);
@@ -368,8 +364,8 @@ class GlobalQueue extends Queue {
                                         if (this.m === e) currentBatch = this.m = createBatch();
                     // Run lane effects immediately (before stashing) - lanes with no pending async
                                         if (activeLanes.size) {
-                        GlobalQueue.In(EFFECT_RENDER);
-                        GlobalQueue.In(EFFECT_USER);
+                        GlobalQueue.Nn(EFFECT_RENDER);
+                        GlobalQueue.Nn(EFFECT_USER);
                     }
                     this.stashQueues(e.yt);
                     clock++;
@@ -398,7 +394,7 @@ class GlobalQueue extends Queue {
                     e.Qt = i.Qt;
                     e.Me = i.Me;
                     e.A = i.A;
-                    e.cn = i.cn;
+                    e.dn = i.dn;
                     currentBatch = this.m = e;
                 }
             } else {
@@ -417,15 +413,15 @@ class GlobalQueue extends Queue {
             // Check if finalization added items to the heap (from optimistic reversion)
                         scheduled = dirtyQueue.EE >= dirtyQueue.Ve;
             // Run lane effects first (for ready lanes), then regular effects
-                        activeLanes.size && GlobalQueue.In(EFFECT_RENDER);
+                        activeLanes.size && GlobalQueue.Nn(EFFECT_RENDER);
             this.run(EFFECT_RENDER);
-            activeLanes.size && GlobalQueue.In(EFFECT_USER);
+            activeLanes.size && GlobalQueue.Nn(EFFECT_USER);
             this.run(EFFECT_USER);
             if (false) ;
             if (false && !scheduled && !activeTransition && transitions.size === 0 && activeLanes.size === 0) ;
             if (false) ;
         } finally {
-            this.gt = false;
+            this.cn = false;
         }
     }
     notify(e, t, i, n) {
@@ -485,7 +481,7 @@ class GlobalQueue extends Queue {
                 activeTransition.Me.push(i);
             }
             if (t.A.length) activeTransition.A.push(...t.A);
-            for (const e of t.cn) activeTransition.cn.add(e);
+            for (const e of t.dn) activeTransition.dn.add(e);
             // Gated readers recorded against the ambient batch move with it: their
             // replay-at-commit now happens at the transaction's completion.
                         if (t.ln.size) {
@@ -517,9 +513,9 @@ function insertSubs(e, t = false) {
     // Get source lane: prefer node's own lane over current context
     // This is important for isPending signals which need their own lane to flush immediately
     const i = e.Ke || currentOptimisticLane;
-    const n = e.Le !== undefined;
+    const n = e.xe !== undefined;
     const s = reaskArmed;
-    for (let r = e.o; r !== null; r = r.le) {
+    for (let r = e.o; r !== null; r = r.ue) {
         // A value-change notification is a new question for the subscriber: any
         // pending re-ask mark (refresh) it carried is superseded.
         if (s) r.fe.se &= ~REACTIVE_REASK;
@@ -542,16 +538,16 @@ function insertSubs(e, t = false) {
 function commitPendingNode(e) {
     const t = e;
     if (!t.ce) {
-        if (e.De !== NOT_PENDING) {
-            e.Ue = e.De;
-            e.De = NOT_PENDING;
+        if (e._e !== NOT_PENDING) {
+            e.be = e._e;
+            e._e = NOT_PENDING;
         }
-        if (e.ge || e.pe) GlobalQueue.un(e);
+        if (e.Oe || e.ge) GlobalQueue.un(e);
         return;
     }
-    if (e.De !== NOT_PENDING) {
-        e.Ue = e.De;
-        e.De = NOT_PENDING;
+    if (e._e !== NOT_PENDING) {
+        e.be = e._e;
+        e._e = NOT_PENDING;
         // Set _modified for effects, but not for tracked effects (they handle their own scheduling)
                 if (e.Re && e.Re !== EFFECT_TRACKED) e.Je = true;
     }
@@ -562,7 +558,18 @@ function commitPendingNode(e) {
     t.se &= ~REACTIVE_MANUAL_WRITE;
     if (!(t.S & STATUS_PENDING)) t.S &= ~STATUS_UNINITIALIZED;
     if (t.We !== null || t.Qe !== null) GlobalQueue.me(t, false, true);
-    if (e.ge || e.pe) GlobalQueue.un(e);
+    if (e.Oe || e.ge) GlobalQueue.un(e);
+}
+
+// Store commit hook (INTERNALS-STORE-STATE.md §3): installed by the store
+// module at init (same treeshakeable pattern as _resolveOptimistic /
+// _clearOptimisticStores). Folds committed store-node values into their
+// backing objects at the same moment pending values commit — the single
+// mutation point of the owned-raw model.
+let storeCommitHook = null;
+
+function setStoreCommitHook(e) {
+    storeCommitHook = e;
 }
 
 function commitPendingNodes() {
@@ -571,6 +578,7 @@ function commitPendingNodes() {
         commitPendingNode(e[t]);
     }
     e.length = 0;
+    storeCommitHook?.();
 }
 
 function finalizePureQueue(e = null, t = false) {
@@ -617,10 +625,10 @@ function finalizePureQueue(e = null, t = false) {
         // hook; the hook iterates, clears, and schedules (keeping the loop out of
         // core lets esbuild shake it — rollup already folds the null guard). The
         // completing transition scopes the clear to its own layer keys (#2899).
-                if (t.cn.size) GlobalQueue.Dt(t.cn, e);
+                if (t.dn.size) GlobalQueue.gt(t.dn, e);
         sweepTransientStoreNodes();
         // Lanes only enter activeLanes through the engine's getOrCreateLane.
-                if (activeLanes.size) GlobalQueue.dn(e);
+                if (activeLanes.size) GlobalQueue.In(e);
     }
 }
 
@@ -677,7 +685,7 @@ function flush(e) {
             }
         }
     }
-    if (globalQueue.gt) {
+    if (globalQueue.cn) {
         return;
     }
     if (halted) return;
@@ -746,4 +754,4 @@ function runInTransition(e, t) {
     }
 }
 
-export { GlobalQueue, Queue, activeAffectsMarks, activeLanes, activeTransition, armReaskClear, assignOrMergeLane, clock, currentTransition, dirtyQueue, enforceLoadingBoundary, finalizePureQueue, findLane, flush, globalQueue, haltReactivity, insertSubs, projectionWriteActive, queuePendingNode, registerTransientStoreNode, resetErrorHalt, runInTransition, schedule, setProjectionWriteActive, shiftAffectsMarks, zombieQueue };
+export { GlobalQueue, Queue, activeAffectsMarks, activeLanes, activeTransition, armReaskClear, assignOrMergeLane, clock, currentTransition, dirtyQueue, enforceLoadingBoundary, finalizePureQueue, findLane, flush, globalQueue, haltReactivity, insertSubs, projectionWriteActive, queuePendingNode, resetErrorHalt, runInTransition, schedule, setProjectionWriteActive, setStoreCommitHook, shiftAffectsMarks, storeCommitHook, zombieQueue };

package/dist/prod/core/verdict.js

@@ -32,15 +32,15 @@ let pendingProbe = null;
  * Get or create the pending signal for a node (lazy).
  * Used by isPending() to track pending state reactively.
  */ function getPendingSignal(e) {
-    if (!e.ge) {
+    if (!e.Oe) {
         // Start false, write true if pending - ensures reversion returns to false
-        e.ge = optimisticSignal(false, {
+        e.Oe = optimisticSignal(false, {
             ownedWrite: true
         });
-        e.ge.nn = e;
-        if (computePendingState(e)) setSignal(e.ge, true);
+        e.Oe.nn = e;
+        if (computePendingState(e)) setSignal(e.Oe, true);
     }
-    return e.ge;
+    return e.Oe;
 }
 
 function collectPendingSources(e) {
@@ -89,7 +89,7 @@ function collectPendingSources(e) {
     const r = i.se & REACTIVE_RECOMPUTING_DEPS ? i.Ye : undefined;
     if (r !== null) {
         for (let e = i.tt ?? null; e !== null; e = e.nt) {
-            if (!e.Ge && markWalk(e.it, t)) return true;
+            if (!e.ye && markWalk(e.it, t)) return true;
             if (e === r) break;
         }
     }
@@ -102,10 +102,10 @@ function collectPendingSources(e) {
 
 function quietPending(e) {
     if (e.oe) {
-        for (const t of e.oe) if (!t.he) return false;
+        for (const t of e.oe) if (!t.pe) return false;
         return true;
     }
-    return e.he;
+    return e.pe;
 }
 
 // NOTE: a loadingValue node's open loading window (_loading) is verdict-quiet
@@ -132,35 +132,35 @@ function computePendingState(e) {
         const n = t.lt || t;
         return newQuestionInFlight(n);
     }
-    if (n && e.De !== NOT_PENDING && !hasActiveOverride(e)) {
+    if (n && e._e !== NOT_PENDING && !hasActiveOverride(e)) {
         return !!(n.se & REACTIVE_MANUAL_WRITE) || !n.Te && !(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.De !== NOT_PENDING && !(t.S & STATUS_UNINITIALIZED) && !t.Ee) {
-        if (hasActiveOverride(e)) return !e.be || !e.be(e.De, unwrapOverride(e._e));
+        if (e._e !== NOT_PENDING && !(t.S & STATUS_UNINITIALIZED) && !t.Ee) {
+        if (hasActiveOverride(e)) return !e.Ue || !e.Ue(e._e, unwrapOverride(e.De));
         return true;
     }
     return newQuestionInFlight(t);
 }
 
 function syncCompanions(e, t) {
-    if (e.ge) updatePendingSignal(e);
-    if (e.pe) setSignal(e.pe, t);
+    if (e.Oe) updatePendingSignal(e);
+    if (e.ge) setSignal(e.ge, t);
 }
 
 function updatePendingSignal(e) {
-    if (e.ge) {
-        setSignal(e.ge, computePendingState(e));
+    if (e.Oe) {
+        setSignal(e.Oe, computePendingState(e));
     }
-    if (e.pe) updatePendingSignal(e.pe);
+    if (e.ge) updatePendingSignal(e.ge);
 }
 
 function updateChildCompanions(e) {
     for (let t = e.u; t !== null; t = t.ae) {
-        if (t.ge || t.pe) updatePendingSignal(t);
+        if (t.Oe || t.ge) updatePendingSignal(t);
     }
 }
 
@@ -178,8 +178,8 @@ function updateChildCompanions(e) {
     const visit = e => {
         if (i.has(e)) return;
         i.add(e);
-        if (e.ge || e.pe) n(e);
-        for (let t = e.o; t !== null; t = t.le) visit(t.fe);
+        if (e.Oe || e.ge) n(e);
+        for (let t = e.o; t !== null; t = t.ue) visit(t.fe);
         for (let t = e.u ?? null; t !== null; t = t.ae) {
             visit(t);
         }
@@ -188,20 +188,20 @@ function updateChildCompanions(e) {
 }
 
 function snapCompanionsToState(e) {
-    const t = e.ge;
-    if (t && (t._e === undefined || t._e === NOT_PENDING)) {
+    const t = e.Oe;
+    if (t && (t.De === undefined || t.De === NOT_PENDING)) {
         const n = computePendingState(e);
-        if (t.Ue !== n || t.De !== NOT_PENDING) {
-            t.Ue = n;
-            t.De = NOT_PENDING;
+        if (t.be !== n || t._e !== NOT_PENDING) {
+            t.be = n;
+            t._e = NOT_PENDING;
             t.de = clock;
             insertSubs(t);
             schedule();
         }
     }
-    const n = e.pe;
+    const n = e.ge;
     if (n && !(n.se & REACTIVE_DISPOSED)) {
-        if ((n._e === undefined || n._e === NOT_PENDING) && n.De === NOT_PENDING && !Object.is(n.Ue, e.Ue) && !(n.se & (REACTIVE_DIRTY | REACTIVE_CHECK))) {
+        if ((n.De === undefined || n.De === NOT_PENDING) && n._e === NOT_PENDING && !Object.is(n.be, e.be) && !(n.se & (REACTIVE_DIRTY | REACTIVE_CHECK))) {
             n.se |= REACTIVE_DIRTY;
             insertIntoHeap(n, queueFor(n));
             insertSubs(n);
@@ -212,7 +212,7 @@ function snapCompanionsToState(e) {
 }
 
 function getLatestValueComputed(e) {
-    if (!e.pe) {
+    if (!e.ge) {
         const t = latestReadActive;
         setLatestReadActive(false);
         const n = pendingCheckActive;
@@ -220,21 +220,21 @@ function getLatestValueComputed(e) {
         const i = context;
         setContextInternal(null);
  // Detach from owner so it isn't disposed with effects
-                e.pe = optimisticComputed(() => read(e));
-        e.pe.nn = e;
+                e.ge = optimisticComputed(() => read(e));
+        e.ge.nn = e;
  // Parent-child lane relationship
                 setContextInternal(i);
         setPendingCheckActive(n);
         setLatestReadActive(t);
     }
-    return e.pe;
+    return e.ge;
 }
 
 /** The latest()-mode read path, installed as GlobalQueue._latestRead. */ function latestRead(e) {
     const t = getLatestValueComputed(e);
     const n = latestReadActive;
     setLatestReadActive(false);
-    const i = e._e !== undefined && e._e !== NOT_PENDING ? unwrapOverride(e._e) : e.Ue;
+    const i = e.De !== undefined && e.De !== NOT_PENDING ? unwrapOverride(e.De) : e.be;
     let r;
     try {
         // An untracked latest() read has no reading context, so read() never
@@ -243,7 +243,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.xe >= e.Ve && !(t.se & (REACTIVE_DISPOSED | REACTIVE_ZOMBIE))) {
+        if (t.Le >= e.Ve && !(t.se & (REACTIVE_DISPOSED | REACTIVE_ZOMBIE))) {
             markHeap(e);
             prepareComputed(t, true);
         }
@@ -266,7 +266,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.De !== NOT_PENDING && !hasActiveOverride(t) && !(stale && t.Ne && activeTransition !== t.Ne)) return t.De;
+        if (t._e !== NOT_PENDING && !hasActiveOverride(t) && !(stale && t.Ne && activeTransition !== t.Ne)) return t._e;
     return r;
 }
 
@@ -285,14 +285,14 @@ function getLatestValueComputed(e) {
 }
 
 function recordFreshRead(e, t) {
-    if (pendingProbe !== null && e.De !== NOT_PENDING && t === e.De) pendingProbe.freshReads.add(e);
+    if (pendingProbe !== null && e._e !== NOT_PENDING && t === e._e) pendingProbe.freshReads.add(e);
 }
 
 function applyReask(e, t) {
     const n = !!(e.S & STATUS_PENDING);
-    const i = t && !(n && !e.he);
-    const r = n && e.he !== i;
-    e.he = i;
+    const i = t && !(n && !e.pe);
+    const r = n && e.pe !== i;
+    e.pe = i;
     return r;
 }
 
@@ -350,7 +350,7 @@ GlobalQueue.Pe = syncCompanions;
 
 GlobalQueue.Se = updatePendingSignal;
 
-GlobalQueue.Oe = updateChildCompanions;
+GlobalQueue.Ge = updateChildCompanions;
 
 GlobalQueue.un = snapCompanionsToState;
 
@@ -358,9 +358,9 @@ GlobalQueue.At = latestRead;
 
 GlobalQueue.Ct = pendingCheckRead;
 
-GlobalQueue.ht = recordFreshRead;
+GlobalQueue.Pt = recordFreshRead;
 
-GlobalQueue.Be = applyReask;
+GlobalQueue.$e = applyReask;
 
 GlobalQueue.k = repollDownstreamVerdicts;
 

package/dist/prod/index.js

@@ -26,19 +26,19 @@ export { affects } from "./affects.js";
 
 export { mapArray, repeat } from "./map.js";
 
-export { $PROXY, $TARGET, $TRACK, createStore, isWrappable } from "./store/store.js";
+export { createStore, deep, reconcile, snapshot } from "./store/index.js";
 
-export { createProjection } from "./store/projection.js";
+export { createErrorBoundary, createLoadingBoundary, createRevealOrder, flatten } from "./boundaries.js";
 
-export { createOptimisticStore } from "./store/optimistic.js";
+export { $PROXY, $TARGET, $TRACK, isWrappable } from "./store/store.js";
 
-export { reconcile } from "./store/reconcile.js";
+export { createOptimisticStoreNext as createOptimisticStore } from "./store/next/optimistic.js";
 
-export { storePath } from "./store/storePath.js";
+export { createProjectionNext as createProjection } from "./store/next/projection.js";
 
-export { deep, merge, omit, snapshot } from "./store/utils.js";
+export { merge, omit } from "./store/utils.js";
 
-export { createErrorBoundary, createLoadingBoundary, createRevealOrder, flatten } from "./boundaries.js";
+export { storePath } from "./store/storePath.js";
 
 const DEV = undefined;