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

package/dist/observe/core/dev.js

@@ -149,7 +149,7 @@ let hasExclusions = false;
 
 function isExcluded(e) {
     if (!hasExclusions || !e) return false;
-    let n = "_parent" in e ? e : e.H ?? null;
+    let n = "_parent" in e ? e : e.L ?? null;
     for (;n !== null; n = n._parent) {
         const e = markedOwners.get(n);
         if (e !== undefined) return e;
@@ -175,7 +175,7 @@ const DEV = undefined;
  * Public as `OBSERVE.ownerPath`; the core's own sites import it directly.
  */ function ownerPath(e) {
     if (!e) return undefined;
-    let n = "_parent" in e ? e : e.H ?? null;
+    let n = "_parent" in e ? e : e.L ?? null;
     const t = [];
     for (;n !== null; n = n._parent) {
         const e = n._name;
@@ -246,7 +246,7 @@ const DEV = undefined;
  * locate signal subjects. The per-owner `_signals` list and the devtools
  * `onGraph` hook are dev-tier — the observe build pays one property write.
  */ function registerGraph(e, n) {
-    e.H = n;
+    e.L = n;
 }
 
 /**

package/dist/observe/core/effect.js

@@ -26,16 +26,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).
-        !o?.defer && r.Ae === NOT_PENDING && !r.m?._t?.Z && (r.i === EFFECT_USER || o?.schedule ? globalQueue.enqueue(r.i, runEffect.bind(null, r)) : runEffect(r, r.i));
+        !o?.defer && r.Oe === NOT_PENDING && !r.m?._t?.B && (r.u === EFFECT_USER || o?.schedule ? globalQueue.enqueue(r.u, runEffect.bind(null, r)) : runEffect(r, r.u));
 }
 
 function notifyEffectStatus(t, e) {
     // Use passed values if provided, otherwise read from node
-    const u = t !== undefined ? t : this.G;
-    const o = e !== undefined ? e : this.m?.v;
+    const u = t !== undefined ? t : this.S;
+    const o = e !== undefined ? e : 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`,
@@ -43,9 +43,9 @@ function notifyEffectStatus(t, e) {
             // 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) {
+            if (this.S & STATUS_ERROR) {
                 this.lt = true;
-                globalQueue.enqueue(this.i, this.J ??= runEffect.bind(null, this));
+                globalQueue.enqueue(this.u, this.Y ??= runEffect.bind(null, this));
             }
             return;
         }
@@ -53,7 +53,7 @@ function notifyEffectStatus(t, e) {
             haltReactivity(unwrapStatusError(o));
             throw o;
         }
-    } else if (this.i === EFFECT_RENDER) {
+    } else if (this.u === EFFECT_RENDER) {
         globalQueue.notify(this, STATUS_PENDING | STATUS_ERROR, u, o);
     }
 }
@@ -68,7 +68,7 @@ function runEffect(t, e) {
     // 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(t)) return;
+        if (GlobalQueue.Ee && GlobalQueue.Ee(t)) 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
@@ -79,9 +79,9 @@ function runEffect(t, e) {
     // 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.G & STATUS_ERROR && t.i === EFFECT_USER) {
-        const e = unwrapStatusError(t.m?.v);
-        t.Nt = t.pe;
+        if (t.S & STATUS_ERROR && t.u === EFFECT_USER) {
+        const e = unwrapStatusError(t.m?.F);
+        t.Nt = t.Ae;
         t.lt = false;
         try {
             t.Lt ? t.Lt(e, () => {
@@ -99,7 +99,7 @@ function runEffect(t, e) {
     }
     // 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 = t.m?.v == null;
+        const u = t.m?.F == null;
     // Observe tier, like its `effectRunEnd` twin below: the frame the engine
     // opens here is what stamps the callback's writes as the effect's (the
     // cascade an observer reports) and what times the callback (the `effect`
@@ -109,19 +109,19 @@ function runEffect(t, e) {
     t.kt = undefined;
     try {
         o?.();
-        const e = t.Ut(t.pe, t.Nt);
+        const e = t.Ut(t.Ae, t.Nt);
         if (false && e !== undefined && typeof e !== "function") ;
         // The final cleanup is invoked by disposeChildren at true disposal.
                 t.kt = e;
     } catch (e) {
-        ext(t).v = new StatusError(t, e);
-        t.G |= STATUS_ERROR;
+        ext(t).F = new StatusError(t, e);
+        t.S |= STATUS_ERROR;
         if (!globalQueue.notify(t, STATUS_ERROR, STATUS_ERROR)) {
             haltReactivity(e);
             throw e;
         }
     } finally {
-        t.Nt = t.pe;
+        t.Nt = t.Ae;
         t.lt = false;
         // The run applied: this is the frame now, so the dependency tail the
         // compute pass left linked goes (A30, #3438 — `recompute` defers an
@@ -135,7 +135,7 @@ function runEffect(t, e) {
         if (attrHooks !== null) attrHooks.effectRunEnd(t);
 }
 
-GlobalQueue.X = runEffect;
+GlobalQueue.q = runEffect;
 
 /**
  * Internal tracked effect - bypasses heap, goes directly to effect queue.
@@ -147,7 +147,7 @@ GlobalQueue.X = runEffect;
         // 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.lt || u.R & REACTIVE_DISPOSED) return;
-        if (GlobalQueue.de && GlobalQueue.de(u)) return;
+        if (GlobalQueue.Ee && GlobalQueue.Ee(u)) return;
         try {
             u.lt = false;
             recompute(u);
@@ -164,16 +164,16 @@ GlobalQueue.X = runEffect;
         lazy: true
     });
     u.kt = undefined;
-    u.u = u.u & ~CONFIG_AUTO_DISPOSE | CONFIG_CHILDREN_FORBIDDEN;
+    u.i = u.i & ~CONFIG_AUTO_DISPOSE | CONFIG_CHILDREN_FORBIDDEN;
     u.lt = true;
-    u.i = EFFECT_TRACKED;
+    u.u = EFFECT_TRACKED;
     // Observe-tier label: the computed literal defaulted its `_name` slot to
     // "computed"; relabel by kind (a store into the slot, not a new field).
         if (e?.name === undefined) u._name = "trackedEffect";
     // 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/observe/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);
     };

package/dist/observe/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.ln;
     if (l !== null) l.ln = t; else n.Dt = t;
-    if (t !== null) t.l = l; else {
+    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?.Ft?.();
+            if (n.i & CONFIG_SLOT_NODE) slotUnobservedHook(n); else n.m?.Ft?.();
             // 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.p;
+    let o = n !== null ? n._ : e.G;
     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.G = 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.G;
     if (!n) return;
     do {
         n = unlinkSubs(n);
     } while (n !== null);
-    e._ = null;
-    e.S = null;
+    e.G = null;
+    e.p = 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.p;
     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.G;
         if (l !== null && l.I === e) {
-            l.Ue = n.he;
-            n.S = l;
+            l.Pe = n.pe;
+            n.p = l;
             return;
         }
     }
@@ -128,17 +128,17 @@ function link(e, n) {
     // (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.Dt;
-    if (s !== null && s.o === n && (!t || s.Ue === n.he)) return;
-    const u = n.S = e.Dt = {
+    if (s !== null && s.l === n && (!t || s.Pe === n.pe)) return;
+    const u = n.p = e.Dt = {
         I: e,
-        o: n,
-        p: l,
+        l: n,
+        _: l,
         ln: s,
-        l: null,
-        Ue: n.he
+        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.G = 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/observe/core/heap.js

@@ -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);
 }
@@ -78,8 +78,8 @@ function deleteFromHeap(e, t) {
 }
 
 function markHeap(e) {
-    if (e.C) return;
-    e.C = true;
+    if (e.N) return;
+    e.N = true;
     for (let t = 0; t <= e.Kt; t++) {
         for (let E = e.jt[t]; E !== undefined; E = E.Ot) {
             if (E.R & REACTIVE_IN_HEAP) markNode(E);
@@ -91,13 +91,13 @@ 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;
+    e.N = false;
     for (e.ut = 0; e.ut <= e.Kt; e.ut++) {
         let E = e.jt[e.ut];
         while (E !== undefined) {
@@ -111,13 +111,13 @@ function runHeap(e, t) {
 function adjustHeight(e, t) {
     deleteFromHeap(e, t);
     let E = e.it;
-    for (let t = e._; t; t = t.p) {
+    for (let t = e.G; t; t = t._) {
         const e = t.I;
-        if (e.re && e.it >= E) E = e.it + 1;
+        if (e.ee && e.it >= E) E = e.it + 1;
     }
     if (e.it !== E) {
         e.it = E;
-        for (let E = e.t; E !== null; E = E.l) insertIntoHeapHeight(E.o, t);
+        for (let E = e.t; E !== null; E = E.o) insertIntoHeapHeight(E.l, t);
     }
 }