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

package/dist/prod/core/effect.js

@@ -14,7 +14,7 @@ import { GlobalQueue, haltReactivity } from "./scheduler.js";
     const r = !!f?.user;
     const R = createEffectNode(t, e, E, r ? EFFECT_USER : EFFECT_RENDER, f);
     recompute(R, true);
-    !f?.defer && (R.Re === EFFECT_USER || f?.schedule ? R.C.enqueue(R.Re, runEffect.bind(null, R)) : runEffect(R));
+    !f?.defer && (R.ge === EFFECT_USER || f?.schedule ? R.C.enqueue(R.ge, runEffect.bind(null, R)) : runEffect(R));
 }
 
 function notifyEffectStatus(t, e) {
@@ -23,7 +23,7 @@ function notifyEffectStatus(t, e) {
     const f = e !== undefined ? e : this.o?._;
     if (E & STATUS_ERROR) {
         this.C.notify(this, STATUS_PENDING, 0);
-        if (this.Re === EFFECT_USER) {
+        if (this.ge === EFFECT_USER) {
             // The error handler is the error arm of the effect phase (#2840 ruling):
             // queue it like the effect function. It runs in the same imperative,
             // writable scope, throws escalate the same way, and a held transition
@@ -34,8 +34,8 @@ function notifyEffectStatus(t, e) {
             // `status` arg without node-state writes) don't queue: the status
             // re-propagates unblocked at commit.
             if (this.S & STATUS_ERROR) {
-                this.Xe = true;
-                this.C.enqueue(this.Re, this.et ??= runEffect.bind(null, this));
+                this.tt = true;
+                this.C.enqueue(this.ge, this.nt ??= runEffect.bind(null, this));
             }
             return;
         }
@@ -43,13 +43,13 @@ function notifyEffectStatus(t, e) {
             haltReactivity(unwrapStatusError(f));
             throw f;
         }
-    } else if (this.Re === EFFECT_RENDER) {
+    } else if (this.ge === EFFECT_RENDER) {
         this.C.notify(this, STATUS_PENDING | STATUS_ERROR, E, f);
     }
 }
 
 function runEffect(t) {
-    if (!t.Xe || t.ie & REACTIVE_DISPOSED) return;
+    if (!t.tt || t.ie & REACTIVE_DISPOSED) return;
     // Error arm (#2840), user effects only: a compute-phase error that is still
     // the node's settled state at effect time runs the bundle's error handler in
     // this same imperative, writable scope. Unwrap the StatusError used for
@@ -60,14 +60,14 @@ function runEffect(t) {
     // Render effects bypass: their errors route to boundaries synchronously in
     // notifyEffectStatus, and a runner queued by an earlier valueChanged in the
     // same flush must not be hijacked by a later-arriving error status.
-        if (t.S & STATUS_ERROR && t.Re === EFFECT_USER) {
+        if (t.S & STATUS_ERROR && t.ge === EFFECT_USER) {
         const e = unwrapStatusError(t.o?._);
-        t.dt = t.be;
-        t.Xe = false;
+        t.At = t.be;
+        t.tt = false;
         try {
-            t.St ? t.St(e, () => {
-                const e = t.At;
-                t.At = undefined;
+            t.Ct ? t.Ct(e, () => {
+                const e = t.Rt;
+                t.Rt = undefined;
                 e?.();
             }) : console.error(e);
         } catch (e) {
@@ -78,14 +78,14 @@ function runEffect(t) {
         }
         return;
     }
-    const e = t.At;
-    t.At = undefined;
+    const e = t.Rt;
+    t.Rt = undefined;
     try {
         e?.();
-        const E = t.Tt(t.be, t.dt);
+        const E = t.Ot(t.be, t.At);
         if (false && E !== undefined && typeof E !== "function") ;
         // The final cleanup is invoked by disposeChildren at true disposal.
-                t.At = E;
+                t.Rt = E;
     } catch (e) {
         ext(t)._ = new StatusError(t, e);
         t.S |= STATUS_ERROR;
@@ -94,12 +94,12 @@ function runEffect(t) {
             throw e;
         }
     } finally {
-        t.dt = t.be;
-        t.Xe = false;
+        t.At = t.be;
+        t.tt = false;
     }
 }
 
-GlobalQueue.tt = runEffect;
+GlobalQueue.it = runEffect;
 
 /**
  * Internal tracked effect - bypasses heap, goes directly to effect queue.
@@ -107,30 +107,30 @@ GlobalQueue.tt = runEffect;
  * Uses stale reads.
  */ function trackedEffect(t, e) {
     const run = () => {
-        if (!E.Xe || E.ie & REACTIVE_DISPOSED) return;
+        if (!E.tt || E.ie & REACTIVE_DISPOSED) return;
         try {
-            E.Xe = false;
+            E.tt = false;
             recompute(E);
         } finally {}
     };
     const E = computed(() => {
-        const e = E.At;
-        E.At = undefined;
+        const e = E.Rt;
+        E.Rt = undefined;
         e?.();
         const f = staleValues(t);
-        E.At = f;
+        E.Rt = f;
     }, {
         ...e,
         lazy: true
     });
-    E.At = undefined;
+    E.Rt = undefined;
     E.T = E.T & ~CONFIG_AUTO_DISPOSE | CONFIG_CHILDREN_FORBIDDEN;
-    E.Xe = true;
-    E.Re = EFFECT_TRACKED;
+    E.tt = true;
+    E.ge = EFFECT_TRACKED;
     // Status dispatch rides the SHARED notifier (statusNotifierOf keys off
     // _type): its error arm is behavior-identical to the closure that used to
     // live here, without the per-node NodeExtension allocation.
-        E.Ut = run;
+        E.yt = run;
     E.C.enqueue(EFFECT_USER, run);
 }
 

package/dist/prod/core/error.js

@@ -53,6 +53,18 @@ class StatusError extends Error {
     return r instanceof StatusError ? r.cause : r;
 }
 
+/**
+ * Rejection value of `until(fn, { timeout })` when the predicate does not turn
+ * truthy within the window. Inside an `action()`, the rejection is thrown back
+ * in at the `yield` point — catchable there, or the action fails and its
+ * optimistic state reverts.
+ */ class TimeoutError extends Error {
+    constructor(r = "Timed out waiting for condition") {
+        super(r);
+        this.name = "TimeoutError";
+    }
+}
+
 class NoOwnerError extends Error {
     constructor() {
         super("");
@@ -65,4 +77,4 @@ class ContextNotFoundError extends Error {
     }
 }
 
-export { ContextNotFoundError, NoOwnerError, NotReadyError, StatusError, unwrapStatusError };
+export { ContextNotFoundError, NoOwnerError, NotReadyError, StatusError, TimeoutError, unwrapStatusError };

package/dist/prod/core/external.js

@@ -64,8 +64,8 @@ function externalUntrack(e) {
 // removed on reset) so core's null checks stay equivalent to the old
 // `externalSourceConfig` truthiness checks.
 function syncExternalHooks() {
-    GlobalQueue.Rt = externalSourceConfig ? wireExternalSource : null;
-    GlobalQueue.Gt = externalSourceConfig ? externalUntrack : null;
+    GlobalQueue.Pt = externalSourceConfig ? wireExternalSource : null;
+    GlobalQueue.ht = externalSourceConfig ? externalUntrack : null;
 }
 
 function enableExternalSource(e) {

package/dist/prod/core/graph.js

@@ -8,15 +8,15 @@ import { bumpNotifyEpoch } from "./scheduler.js";
 
 // https://github.com/stackblitz/alien-signals/blob/v2.0.3/src/system.ts#L100
 function unlinkSubs(e) {
-    const n = e.ut;
-    const l = e.it;
+    const n = e.ot;
+    const l = e.lt;
     const o = e.ae;
     const u = e.en;
-    if (o !== null) o.en = u; else n.rt = u;
+    if (o !== null) o.en = u; else n._t = u;
     if (u !== null) u.ae = o; else {
         n.u = o;
         if (o === null) {
-            n.o?.ft?.();
+            n.o?.Et?.();
             // No more subscribers; only tear down if CONFIG_AUTO_DISPOSE is set.
             // A pending node is exempt: its in-flight async work (or the
             // transition holding it) is an observer — tearing down would orphan
@@ -31,13 +31,13 @@ function unlinkSubs(e) {
 }
 
 function trimStaleDeps(e) {
-    const n = e.Ye;
-    let l = n !== null ? n.it : e.nt;
+    const n = e.je;
+    let l = n !== null ? n.lt : e.ut;
     if (l !== null) {
         do {
             l = unlinkSubs(l);
         } while (l !== null);
-        if (n !== null) n.it = null; else e.nt = null;
+        if (n !== null) n.lt = null; else e.ut = null;
     }
 }
 
@@ -46,13 +46,13 @@ function trimStaleDeps(e) {
 // and skipping early also avoids adding one (hidden-class churn) via the
 // null-out below.
 function clearDeps(e) {
-    let n = e.nt;
+    let n = e.ut;
     if (!n) return;
     do {
         n = unlinkSubs(n);
     } while (n !== null);
-    e.nt = null;
-    e.Ye = null;
+    e.ut = null;
+    e.je = null;
 }
 
 function unobserved(e) {
@@ -104,20 +104,20 @@ function link(e, n, l = false) {
     // not relabel the value dependency as probe-only — the value read is what
     // real-error propagation and affects() coverage key off, regardless of
     // read order within the computation.
-    const o = n.Ye;
-    if (o !== null && o.ut === e) {
-        o.me &&= l;
+    const o = n.je;
+    if (o !== null && o.ot === e) {
+        o.ve &&= l;
         return;
     }
     let u = null;
     const t = n.ie & REACTIVE_RECOMPUTING_DEPS;
     if (t) {
-        u = o !== null ? o.it : n.nt;
-        if (u !== null && u.ut === e) {
-            u.nn = n.Ze;
-            n.Ye = u;
+        u = o !== null ? o.lt : n.ut;
+        if (u !== null && u.ot === e) {
+            u.Ft = n.Ke;
+            n.je = u;
             // First touch of this pass: the previous pass's label is stale.
-                        u.me = l;
+                        u.ve = l;
             return;
         }
     }
@@ -126,23 +126,23 @@ function link(e, n, l = false) {
     // [deps.._depsTail] prefix — the O(1) equivalent of scanning the dep list
     // (the old alien-signals `isValidLink` walk, O(n²) when a computation
     // re-reads earlier deps non-consecutively, e.g. store leaf reads).
-        const s = e.rt;
-    if (s !== null && s.ce === n && (!t || s.nn === n.Ze)) {
+        const s = e._t;
+    if (s !== null && s.ce === n && (!t || s.Ft === n.Ke)) {
         // Gen-matched during a recompute = repeat touch this pass (AND); outside
         // a recompute there is no pass boundary, so the latest read labels it.
-        if (t) s.me &&= l; else s.me = l;
+        if (t) s.ve &&= l; else s.ve = l;
         return;
     }
-    const r = n.Ye = e.rt = {
-        ut: e,
+    const r = n.je = e._t = {
+        ot: e,
         ce: n,
-        it: u,
+        lt: u,
         en: s,
         ae: null,
-        nn: n.Ze,
-        me: l
+        Ft: n.Ke,
+        ve: l
     };
-    if (o !== null) o.it = r; else n.nt = r;
+    if (o !== null) o.lt = r; else n.ut = r;
     if (s !== null) s.ae = r; else e.u = r;
     // New subscriber edge: staged-rewrite skips (§12d) must not miss it.
         bumpNotifyEpoch();

package/dist/prod/core/heap.js

@@ -13,29 +13,29 @@ import { zombieQueue, dirtyQueue } from "./scheduler.js";
  * the heap and go directly to their effect queue; everything else is inserted
  * into its own (zombie-flag-routed) heap with the `_min` cursor pulled down.
  */ function enqueueSub(e) {
-    if (e.Re === EFFECT_TRACKED) {
+    if (e.ge === EFFECT_TRACKED) {
         const E = e;
-        if (!E.Xe) {
-            E.Xe = true;
-            E.C.enqueue(EFFECT_USER, E.Ut);
+        if (!E.tt) {
+            E.tt = true;
+            E.C.enqueue(EFFECT_USER, E.yt);
         }
         return;
     }
     const E = queueFor(e);
-    if (E.xe > e.Le) E.xe = e.Le;
+    if (E.Qe > e.Me) E.Qe = e.Me;
     insertIntoHeap(e, E);
 }
 
 function actualInsertIntoHeap(e, E) {
-    const t = (e.ke?.Ct ? e.ke.Ot?.Le : e.ke?.Le) ?? -1;
-    if (t >= e.Le) e.Le = t + 1;
-    const n = e.Le;
+    const t = (e.ke?.Gt ? e.ke.Dt?.Me : e.ke?.Me) ?? -1;
+    if (t >= e.Me) e.Me = t + 1;
+    const n = e.Me;
     const I = E.eE[n];
     if (I === undefined) E.eE[n] = e; else {
-        const E = I.st;
-        E.ot = e;
-        e.st = E;
-        I.st = e;
+        const E = I.ct;
+        E.rt = e;
+        e.ct = E;
+        I.ct = e;
     }
     if (n > E.EE) E.EE = n;
 }
@@ -71,23 +71,23 @@ function deleteFromHeap(e, E) {
     const t = e.ie;
     if (!(t & (REACTIVE_IN_HEAP | REACTIVE_IN_HEAP_HEIGHT))) return;
     e.ie = t & -25;
-    const n = e.Le;
-    if (e.st === e) E.eE[n] = undefined; else {
-        const t = e.ot;
+    const n = e.Me;
+    if (e.ct === e) E.eE[n] = undefined; else {
+        const t = e.rt;
         const I = E.eE[n];
         const o = t ?? I;
-        if (e === I) E.eE[n] = t; else e.st.ot = t;
-        o.st = e.st;
+        if (e === I) E.eE[n] = t; else e.ct.rt = t;
+        o.ct = e.ct;
     }
-    e.st = e;
-    e.ot = undefined;
+    e.ct = e;
+    e.rt = undefined;
 }
 
 function markHeap(e) {
     if (e.tE) return;
     e.tE = true;
     for (let E = 0; E <= e.EE; E++) {
-        for (let t = e.eE[E]; t !== undefined; t = t.ot) {
+        for (let t = e.eE[E]; t !== undefined; t = t.rt) {
             if (t.ie & REACTIVE_IN_HEAP) markNode(t);
         }
     }
@@ -114,11 +114,11 @@ function markNode(e, E = REACTIVE_DIRTY) {
 
 function runHeap(e, E) {
     e.tE = false;
-    for (e.xe = 0; e.xe <= e.EE; e.xe++) {
-        let t = e.eE[e.xe];
+    for (e.Qe = 0; e.Qe <= e.EE; e.Qe++) {
+        let t = e.eE[e.Qe];
         while (t !== undefined) {
             if (t.ie & REACTIVE_IN_HEAP) E(t); else adjustHeight(t, e);
-            t = e.eE[e.xe];
+            t = e.eE[e.Qe];
         }
     }
     e.EE = 0;
@@ -126,14 +126,14 @@ function runHeap(e, E) {
 
 function adjustHeight(e, E) {
     deleteFromHeap(e, E);
-    let t = e.Le;
-    for (let E = e.nt; E; E = E.it) {
-        const e = E.ut;
-        const n = e.lt || e;
-        if (n.oe && n.Le >= t) t = n.Le + 1;
+    let t = e.Me;
+    for (let E = e.ut; E; E = E.lt) {
+        const e = E.ot;
+        const n = e.st || e;
+        if (n.oe && n.Me >= t) t = n.Me + 1;
     }
-    if (e.Le !== t) {
-        e.Le = t;
+    if (e.Me !== t) {
+        e.Me = t;
         for (let E = e.u; E !== null; E = E.ae) {
             // Route each subscriber by its own zombie flag, mirroring the
             // post-recompute height-adjust path. Inserting into the running `heap`

package/dist/prod/core/lanes.js

@@ -1,4 +1,4 @@
-import { NOT_PENDING, CONFIG_HAS_LANE } from "./constants.js";
+import { CONFIG_HAS_LANE, NOT_PENDING } from "./constants.js";
 
 import { ext } from "./core.js";
 
@@ -20,16 +20,16 @@ const activeLanes = new Set;
     }
     // Detect parent lane: _parentSource chains from pendingSignal → pendingValueComputed → original.
     // The child lane should not merge with the parent lane.
-        const i = n.o?.Et;
-    const t = i?.o?.Be;
+        const i = n.o?.Tt;
+    const t = i?.o?.Je;
     const r = t ? findLane(t) : null;
     e = {
-        tn: n,
-        Ae: new Set,
-        rn: [ [], [] ],
-        an: null,
-        _e: activeTransition,
-        sn: r
+        nn: n,
+        Oe: new Set,
+        tn: [ [], [] ],
+        rn: null,
+        Ae: activeTransition,
+        an: r
     };
     signalLanes.set(n, e);
     activeLanes.add(e);
@@ -39,8 +39,8 @@ const activeLanes = new Set;
     // parent-child is a property of the nodes, not of write order — otherwise
     // the owner's write merges the companion's subscribers into this lane and
     // their effects wait on its async instead of flushing immediately.
-        adoptCompanionLane(n.o?.Ge, e);
-    adoptCompanionLane(n.o?.ge, e);
+        adoptCompanionLane(n.o?.ye, e);
+    adoptCompanionLane(n.o?.Ce, e);
     return e;
 }
 
@@ -51,13 +51,13 @@ function adoptCompanionLane(n, e) {
     const t = findLane(i);
     // Only the companion's own unmerged root is safely re-parentable: a root
     // that absorbed other lanes carries work that is not a child of this owner.
-        if (t !== e && t.tn === n && !t.sn) t.sn = e;
+        if (t !== e && t.nn === n && !t.an) t.an = e;
 }
 
 /**
  * Union-find: find the root lane.
  */ function findLane(n) {
-    while (n.an) n = n.an;
+    while (n.rn) n = n.rn;
     return n;
 }
 
@@ -67,27 +67,27 @@ function adoptCompanionLane(n, e) {
     n = findLane(n);
     e = findLane(e);
     if (n === e) return n;
-    e.an = n;
+    e.rn = n;
     // Move (not copy) the merged lane's work: after the merge all routing goes
     // through findLane() to the root, so anything left behind here is dead —
     // and anything *added* here later is a routing bug (INV-5).
-        for (const i of e.Ae) n.Ae.add(i);
-    e.Ae.clear();
-    n.rn[0].push(...e.rn[0]);
-    n.rn[1].push(...e.rn[1]);
-    e.rn[0].length = 0;
-    e.rn[1].length = 0;
+        for (const i of e.Oe) n.Oe.add(i);
+    e.Oe.clear();
+    n.tn[0].push(...e.tn[0]);
+    n.tn[1].push(...e.tn[1]);
+    e.tn[0].length = 0;
+    e.tn[1].length = 0;
     return n;
 }
 
 /**
  * Resolve a node's lane: follow union-find chain, verify active, clear if stale.
  */ function resolveLane(n) {
-    const e = n.o?.Be;
+    const e = n.o?.Je;
     if (!e) return undefined;
     const i = findLane(e);
     if (activeLanes.has(i)) return i;
-    if (n.o !== null) n.o.Be = undefined;
+    if (n.o !== null) n.o.Je = undefined;
     return undefined;
 }
 
@@ -99,17 +99,17 @@ function resolveTransition(n) {
     // reader. Chase merge chains; a dead owner settled through another path.
     if (hasActiveOverride(n) && n.o?.Nt) {
         const e = ext(n).Nt = currentTransition(n.o?.Nt);
-        if (e.fn !== true) return e;
+        if (e.sn !== true) return e;
         if (n.o !== null) n.o.Nt = null;
     }
-    return resolveLane(n)?._e ?? n._e;
+    return resolveLane(n)?.Ae ?? n.Ae;
 }
 
 /**
  * Check if a node has an active optimistic override.
  */ function hasActiveOverride(n) {
     const e = n.o;
-    return e !== null && e.De !== undefined && e.De !== NOT_PENDING;
+    return e !== null && e.Pe !== undefined && e.Pe !== NOT_PENDING;
 }
 
 /**
@@ -117,13 +117,13 @@ function resolveTransition(n) {
  * a different active lane), merge unless the node has an active override.
  */ function assignOrMergeLane(n, e) {
     const i = findLane(e);
-    const t = n.o?.Be;
+    const t = n.o?.Je;
     if (t) {
         // If the subscriber's lane was merged into another lane, it's stale —
         // replace it with the new source lane instead of following the merge chain
         // (which would incorrectly merge the new lane into the old group)
-        if (t.an) {
-            ext(n).Be = e;
+        if (t.rn) {
+            ext(n).Je = e;
             n.T |= CONFIG_HAS_LANE;
             return;
         }
@@ -132,15 +132,15 @@ function resolveTransition(n) {
             if (r !== i && !hasActiveOverride(n)) {
                 // Parent-child lanes stay independent so isPending resolves without
                 // waiting for the parent's async. The child keeps ownership.
-                if (i.sn && findLane(i.sn) === r) {
-                    ext(n).Be = e;
+                if (i.an && findLane(i.an) === r) {
+                    ext(n).Je = e;
                     n.T |= CONFIG_HAS_LANE;
-                } else if (r.sn && findLane(r.sn) === i) ; else mergeLanes(i, r);
+                } else if (r.an && findLane(r.an) === i) ; else mergeLanes(i, r);
             }
             return;
         }
     }
-    ext(n).Be = e;
+    ext(n).Je = e;
     n.T |= CONFIG_HAS_LANE;
 }