@solidjs/signals 2.0.0-rc.14 → 2.0.0-rc.15

package/dist/prod/core/effect.js

@@ -22,16 +22,16 @@ import { globalQueue, schedule, GlobalQueue, haltReactivity } from "./scheduler.
     // staged); the flush's commit replays this effect. Its first run is not this
     // creation's (A29). A lane's node likewise: its run is the lane's, queued
     // by the pass and released at the reveal (lanes.ts).
-        !E?.defer && r.Ae === NOT_PENDING && !r.m?.ke?.Z && (r.i === EFFECT_USER || E?.schedule ? globalQueue.enqueue(r.i, runEffect.bind(null, r)) : runEffect(r, r.i));
+        !E?.defer && r.Oe === NOT_PENDING && !r.m?.He?.B && (r.u === EFFECT_USER || E?.schedule ? globalQueue.enqueue(r.u, runEffect.bind(null, r)) : runEffect(r, r.u));
 }
 
 function notifyEffectStatus(e, t) {
     // Use passed values if provided, otherwise read from node
-    const u = e !== undefined ? e : this.G;
-    const E = t !== undefined ? t : this.m?.V;
+    const u = e !== undefined ? e : this.S;
+    const E = t !== undefined ? t : this.m?.F;
     if (u & STATUS_ERROR) {
         globalQueue.notify(this, STATUS_PENDING, 0);
-        if (this.i === EFFECT_USER) {
+        if (this.u === 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 and throws escalate the same way. No payload is queued — the node already carries `_statusFlags`/`_error`,
@@ -39,9 +39,9 @@ function notifyEffectStatus(e, t) {
             // phase takes the success arm instead. Blocked forwards (explicit
             // `status` arg without node-state writes) don't queue: the status
             // re-propagates unblocked at commit.
-            if (this.G & STATUS_ERROR) {
-                this.Fe = true;
-                globalQueue.enqueue(this.i, this.J ??= runEffect.bind(null, this));
+            if (this.S & STATUS_ERROR) {
+                this.Ge = true;
+                globalQueue.enqueue(this.u, this.Y ??= runEffect.bind(null, this));
             }
             return;
         }
@@ -49,13 +49,13 @@ function notifyEffectStatus(e, t) {
             haltReactivity(unwrapStatusError(E));
             throw E;
         }
-    } else if (this.i === EFFECT_RENDER) {
+    } else if (this.u === EFFECT_RENDER) {
         globalQueue.notify(this, STATUS_PENDING | STATUS_ERROR, u, E);
     }
 }
 
 function runEffect(e, t) {
-    if (!e.Fe || e.R & REACTIVE_DISPOSED) return;
+    if (!e.Ge || e.R & REACTIVE_DISPOSED) return;
     // A queued run behind a fallback (boundaries.ts) waits for the reveal: a
     // user effect's, which would read a DOM that is not attached, and a render
     // effect's update too (maintainer, 2026-10-02: "we held the queue but let
@@ -64,7 +64,7 @@ function runEffect(e, t) {
     // hidden subtree. The synchronous first render on creation is not a queued
     // run and goes through. `_modified` stays set; the boundary re-queues the
     // run (`release`).
-        if (GlobalQueue.de && GlobalQueue.de(e)) return;
+        if (GlobalQueue.Ee && GlobalQueue.Ee(e)) 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
@@ -75,14 +75,14 @@ function runEffect(e, 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 (e.G & STATUS_ERROR && e.i === EFFECT_USER) {
-        const t = unwrapStatusError(e.m?.V);
-        e.Ze = e.pe;
-        e.Fe = false;
+        if (e.S & STATUS_ERROR && e.u === EFFECT_USER) {
+        const t = unwrapStatusError(e.m?.F);
+        e.be = e.Ae;
+        e.Ge = false;
         try {
-            e.it ? e.it(t, () => {
-                const t = e.lt;
-                e.lt = undefined;
+            e.ut ? e.ut(t, () => {
+                const t = e.st;
+                e.st = undefined;
                 t?.();
             }) : console.error(t);
         } catch (t) {
@@ -95,25 +95,25 @@ function runEffect(e, t) {
     }
     // Captured before the callback: its own throw errors the node below, but
     // the compute pass that produced `_value` was clean, so its tail still goes.
-        const u = e.m?.V == null;
-    const E = e.lt;
-    e.lt = undefined;
+        const u = e.m?.F == null;
+    const E = e.st;
+    e.st = undefined;
     try {
         E?.();
-        const t = e.st(e.pe, e.Ze);
+        const t = e.Et(e.Ae, e.be);
         if (false && t !== undefined && typeof t !== "function") ;
         // The final cleanup is invoked by disposeChildren at true disposal.
-                e.lt = t;
+                e.st = t;
     } catch (t) {
-        ext(e).V = new StatusError(e, t);
-        e.G |= STATUS_ERROR;
+        ext(e).F = new StatusError(e, t);
+        e.S |= STATUS_ERROR;
         if (!globalQueue.notify(e, STATUS_ERROR, STATUS_ERROR)) {
             haltReactivity(t);
             throw t;
         }
     } finally {
-        e.Ze = e.pe;
-        e.Fe = false;
+        e.be = e.Ae;
+        e.Ge = false;
         // The run applied: this is the frame now, so the dependency tail the
         // compute pass left linked goes (A30, #3438 — `recompute` defers an
         // effect's trim while a run is owed; the twin of `commitPendingNode`'s
@@ -123,7 +123,7 @@ function runEffect(e, t) {
     }
 }
 
-GlobalQueue.X = runEffect;
+GlobalQueue.q = runEffect;
 
 /**
  * Internal tracked effect - bypasses heap, goes directly to effect queue.
@@ -134,31 +134,31 @@ GlobalQueue.X = runEffect;
         // `_modified` is NOT redundant with the heap: the heap dedups within a
         // pass, but several passes in one flush each enqueue `_run` into the same
         // user queue, and this gate is what collapses them into one run.
-        if (!u.Fe || u.R & REACTIVE_DISPOSED) return;
-        if (GlobalQueue.de && GlobalQueue.de(u)) return;
+        if (!u.Ge || u.R & REACTIVE_DISPOSED) return;
+        if (GlobalQueue.Ee && GlobalQueue.Ee(u)) return;
         try {
-            u.Fe = false;
+            u.Ge = false;
             recompute(u);
         } finally {}
     };
     const u = computed(() => {
-        const t = u.lt;
-        u.lt = undefined;
+        const t = u.st;
+        u.st = undefined;
         t?.();
         const E = staleValues(e);
-        u.lt = E;
+        u.st = E;
     }, {
         ...t,
         lazy: true
     });
-    u.lt = undefined;
-    u.u = u.u & ~CONFIG_AUTO_DISPOSE | CONFIG_CHILDREN_FORBIDDEN;
-    u.Fe = true;
-    u.i = EFFECT_TRACKED;
+    u.st = undefined;
+    u.i = u.i & ~CONFIG_AUTO_DISPOSE | CONFIG_CHILDREN_FORBIDDEN;
+    u.Ge = true;
+    u.u = 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.
-        u.q = run;
+        u.M = run;
     // The first run rides the heap like every wake (GlobalQueue._update), so a
     // tracked effect created inside a render-effect callback runs after that
     // pass's staged writes commit, not before.

package/dist/prod/core/external.js

@@ -46,11 +46,11 @@ function wireExternalSource(e) {
         equals: false,
         ownedWrite: true
     });
-    const r = externalSourceConfig.factory(e.re, () => {
+    const r = externalSourceConfig.factory(e.ee, () => {
         setSignal(n, undefined);
     });
     cleanup(() => r.dispose());
-    e.re = e => {
+    e.ee = e => {
         read(n);
         return r.track(e);
     };
@@ -64,8 +64,8 @@ function externalUntrack(e) {
 // removed on reset) so core's presence checks stay equivalent to the old
 // `externalSourceConfig` truthiness checks.
 function syncExternalHooks() {
-    GlobalQueue._t = externalSourceConfig ? wireExternalSource : undefined;
-    GlobalQueue.It = externalSourceConfig ? externalUntrack : undefined;
+    GlobalQueue.it = externalSourceConfig ? wireExternalSource : undefined;
+    GlobalQueue._t = externalSourceConfig ? externalUntrack : undefined;
 }
 
 function enableExternalSource(e) {

package/dist/prod/core/graph.js

@@ -1,4 +1,4 @@
-import { CONFIG_AUTO_DISPOSE, STATUS_PENDING, REACTIVE_DISPOSED, REACTIVE_ZOMBIE, CONFIG_SLOT_NODE, REACTIVE_RECOMPUTING_DEPS } from "./constants.js";
+import { CONFIG_AUTO_DISPOSE, STATUS_PENDING, REACTIVE_DISPOSED, REACTIVE_ZOMBIE, REACTIVE_RECOMPUTING_DEPS, CONFIG_SLOT_NODE } from "./constants.js";
 
 import { deleteFromHeap } from "./heap.js";
 
@@ -18,16 +18,16 @@ function setSlotUnobserved(e) {
 // https://github.com/stackblitz/alien-signals/blob/v2.0.3/src/system.ts#L100
 function unlinkSubs(e) {
     const n = e.I;
-    const o = e.p;
-    const l = e.l;
+    const o = e._;
+    const l = e.o;
     const t = e.en;
-    if (l !== null) l.en = t; else n.qe = t;
-    if (t !== null) t.l = l; else {
+    if (l !== null) l.en = t; else n.Ye = t;
+    if (t !== null) t.o = l; else {
         n.t = l;
         if (l === null) {
             // Store slot nodes dispatch to the ONE shared hook — no per-node
             // unobserved closure, no NodeExtension to hold it.
-            if (n.u & CONFIG_SLOT_NODE) slotUnobservedHook(n); else n.m?.Xe?.();
+            if (n.i & CONFIG_SLOT_NODE) slotUnobservedHook(n); else n.m?.Je?.();
             // No more subscribers; only tear down if CONFIG_AUTO_DISPOSE is set.
             // A pending node is exempt: its in-flight async work is an observer —
             // tearing down would orphan the work and re-execute it on the next
@@ -35,20 +35,20 @@ function unlinkSubs(e) {
             // observer releases (the untracked-read dormancy sweep guards on
             // pending identically).
                         const e = n;
-            e.re && e.u & CONFIG_AUTO_DISPOSE && !(e.R & REACTIVE_ZOMBIE) && !(e.G & STATUS_PENDING) && unobserved(e);
+            e.ee && e.i & CONFIG_AUTO_DISPOSE && !(e.R & REACTIVE_ZOMBIE) && !(e.S & STATUS_PENDING) && unobserved(e);
         }
     }
     return o;
 }
 
 function trimStaleDeps(e) {
-    const n = e.S;
-    let o = n !== null ? n.p : e._;
+    const n = e.G;
+    let o = n !== null ? n._ : e.p;
     if (o !== null) {
         do {
             o = unlinkSubs(o);
         } while (o !== null);
-        if (n !== null) n.p = null; else e._ = null;
+        if (n !== null) n._ = null; else e.p = null;
     }
 }
 
@@ -57,13 +57,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._;
+    let n = e.p;
     if (!n) return;
     do {
         n = unlinkSubs(n);
     } while (n !== null);
-    e._ = null;
-    e.S = null;
+    e.p = null;
+    e.G = null;
 }
 
 function unobserved(e) {
@@ -101,7 +101,7 @@ function sweepDormant() {
         // is an observer; the settle path re-runs last-one-out), lost its
         // AUTO_DISPOSE bit (owner teardown strips it, #3024), or already been
         // torn down.
-        if (!e.t && e.u & CONFIG_AUTO_DISPOSE && !(e.G & STATUS_PENDING) && !(e.R & (REACTIVE_DISPOSED | REACTIVE_ZOMBIE))) {
+        if (!e.t && e.i & CONFIG_AUTO_DISPOSE && !(e.S & STATUS_PENDING) && !(e.R & (REACTIVE_DISPOSED | REACTIVE_ZOMBIE))) {
             unobserved(e);
         }
     }
@@ -110,15 +110,15 @@ function sweepDormant() {
 
 // https://github.com/stackblitz/alien-signals/blob/v2.0.3/src/system.ts#L52
 function link(e, n) {
-    const o = n.S;
+    const o = n.G;
     if (o !== null && o.I === e) return;
     let l = null;
     const t = n.R & REACTIVE_RECOMPUTING_DEPS;
     if (t) {
-        l = o !== null ? o.p : n._;
+        l = o !== null ? o._ : n.p;
         if (l !== null && l.I === e) {
-            l.Ue = n.Ge;
-            n.S = l;
+            l.Pe = n.pe;
+            n.G = l;
             return;
         }
     }
@@ -127,18 +127,18 @@ function link(e, n) {
     // [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.qe;
-    if (s !== null && s.o === n && (!t || s.Ue === n.Ge)) return;
-    const u = n.S = e.qe = {
+        const s = e.Ye;
+    if (s !== null && s.l === n && (!t || s.Pe === n.pe)) return;
+    const u = n.G = e.Ye = {
         I: e,
-        o: n,
-        p: l,
+        l: n,
+        _: l,
         en: s,
-        l: null,
-        Ue: n.Ge
+        o: null,
+        Pe: n.pe
     };
-    if (o !== null) o.p = u; else n._ = u;
-    if (s !== null) s.l = u; else e.t = u;
+    if (o !== null) o._ = u; else n.p = u;
+    if (s !== null) s.o = u; else e.t = u;
     // New subscriber edge: staged-rewrite skips (§12d) must not miss it.
         bumpNotifyEpoch();
 }

package/dist/prod/core/heap.js

@@ -11,22 +11,22 @@ import { dirtyQueue } from "./scheduler.js";
  * callback to the user queue once the pass has committed (see
  * GlobalQueue._update, #3291).
  */ function enqueueSub(e) {
-    if (dirtyQueue.He > e.Le) dirtyQueue.He = e.Le;
+    if (dirtyQueue.Ue > e.me) dirtyQueue.Ue = e.me;
     insertIntoHeap(e, dirtyQueue);
 }
 
 function actualInsertIntoHeap(e, t) {
-    const E = (e._parent?.Et ? e._parent.ut?.Le : e._parent?.Le) ?? -1;
-    if (E >= e.Le) e.Le = E + 1;
-    const n = e.Le;
+    const E = (e._parent?.$e ? e._parent.et?.me : e._parent?.me) ?? -1;
+    if (E >= e.me) e.me = E + 1;
+    const n = e.me;
     const I = t.Ht[n];
     if (I === undefined) t.Ht[n] = e; else {
-        const t = I.Ke;
+        const t = I.we;
         t.je = e;
-        e.Ke = t;
-        I.Ke = e;
+        e.we = t;
+        I.we = e;
     }
-    if (n > t.At) t.At = n;
+    if (n > t.ft) t.ft = n;
 }
 
 function insertIntoHeap(e, t) {
@@ -49,7 +49,7 @@ function insertIntoHeap(e, t) {
         // parked in the heap for a synchronous mount (each row writing a ref
         // signal its effect subscribes to), mounting N rows was O(N²) (#3350).
         // markNode's own guard skips an already-DIRTY node.
-                if (t.C) markNode(e);
+                if (t.N) markNode(e);
     }
     if (!(E & REACTIVE_IN_HEAP_HEIGHT)) actualInsertIntoHeap(e, t);
 }
@@ -65,22 +65,22 @@ function deleteFromHeap(e, t) {
     const E = e.R;
     if (!(E & (REACTIVE_IN_HEAP | REACTIVE_IN_HEAP_HEIGHT))) return;
     e.R = E & -25;
-    const n = e.Le;
-    if (e.Ke === e) t.Ht[n] = undefined; else {
+    const n = e.me;
+    if (e.we === e) t.Ht[n] = undefined; else {
         const E = e.je;
         const I = t.Ht[n];
         const i = E ?? I;
-        if (e === I) t.Ht[n] = E; else e.Ke.je = E;
-        i.Ke = e.Ke;
+        if (e === I) t.Ht[n] = E; else e.we.je = E;
+        i.we = e.we;
     }
-    e.Ke = e;
+    e.we = e;
     e.je = undefined;
 }
 
 function markHeap(e) {
-    if (e.C) return;
-    e.C = true;
-    for (let t = 0; t <= e.At; t++) {
+    if (e.N) return;
+    e.N = true;
+    for (let t = 0; t <= e.ft; t++) {
         for (let E = e.Ht[t]; E !== undefined; E = E.je) {
             if (E.R & REACTIVE_IN_HEAP) markNode(E);
         }
@@ -91,33 +91,33 @@ function markNode(e, t = REACTIVE_DIRTY) {
     const E = e.R;
     if ((E & (REACTIVE_CHECK | REACTIVE_DIRTY)) >= t) return;
     e.R = E & -4 | t;
-    for (let t = e.t; t !== null; t = t.l) {
-        markNode(t.o, REACTIVE_CHECK);
+    for (let t = e.t; t !== null; t = t.o) {
+        markNode(t.l, REACTIVE_CHECK);
     }
 }
 
 function runHeap(e, t) {
-    e.C = false;
-    for (e.He = 0; e.He <= e.At; e.He++) {
-        let E = e.Ht[e.He];
+    e.N = false;
+    for (e.Ue = 0; e.Ue <= e.ft; e.Ue++) {
+        let E = e.Ht[e.Ue];
         while (E !== undefined) {
             if (E.R & REACTIVE_IN_HEAP) t(E); else adjustHeight(E, e);
-            E = e.Ht[e.He];
+            E = e.Ht[e.Ue];
         }
     }
-    e.At = 0;
+    e.ft = 0;
 }
 
 function adjustHeight(e, t) {
     deleteFromHeap(e, t);
-    let E = e.Le;
-    for (let t = e._; t; t = t.p) {
+    let E = e.me;
+    for (let t = e.p; t; t = t._) {
         const e = t.I;
-        if (e.re && e.Le >= E) E = e.Le + 1;
+        if (e.ee && e.me >= E) E = e.me + 1;
     }
-    if (e.Le !== E) {
-        e.Le = E;
-        for (let E = e.t; E !== null; E = E.l) insertIntoHeapHeight(E.o, t);
+    if (e.me !== E) {
+        e.me = E;
+        for (let E = e.t; E !== null; E = E.o) insertIntoHeapHeight(E.l, t);
     }
 }