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

package/dist/prod/core/effect.js

@@ -1,6 +1,6 @@
 import { REACTIVE_DISPOSED, STATUS_ERROR, EFFECT_USER, CONFIG_AUTO_DISPOSE, CONFIG_CHILDREN_FORBIDDEN, EFFECT_TRACKED, STATUS_PENDING, EFFECT_RENDER } from "./constants.js";
 
-import { createEffectNode, recompute, computed, staleValues } from "./core.js";
+import { ext, createEffectNode, recompute, computed, staleValues } from "./core.js";
 
 import { unwrapStatusError, StatusError } from "./error.js";
 
@@ -10,18 +10,18 @@ import { GlobalQueue, haltReactivity } from "./scheduler.js";
  * Effects are the leaf nodes of our reactive graph. When their sources change, they are
  * automatically added to the queue of effects to re-execute, which will cause them to fetch their
  * sources and recompute
- */ function effect(t, E, e, R) {
+ */ function effect(t, e, E, R) {
     const r = !!R?.user;
-    const f = createEffectNode(t, E, e, r ? EFFECT_USER : EFFECT_RENDER, notifyEffectStatus, R);
+    const f = createEffectNode(t, e, E, r ? EFFECT_USER : EFFECT_RENDER, notifyEffectStatus, R);
     recompute(f, true);
     !R?.defer && (f.Re === EFFECT_USER || R?.schedule ? f.C.enqueue(f.Re, runEffect.bind(null, f)) : runEffect(f));
 }
 
-function notifyEffectStatus(t, E) {
+function notifyEffectStatus(t, e) {
     // Use passed values if provided, otherwise read from node
-    const e = t !== undefined ? t : this.S;
-    const R = E !== undefined ? E : this._;
-    if (e & STATUS_ERROR) {
+    const E = t !== undefined ? t : this.S;
+    const R = e !== undefined ? e : this.o?._;
+    if (E & STATUS_ERROR) {
         this.C.notify(this, STATUS_PENDING, 0);
         if (this.Re === EFFECT_USER) {
             // The error handler is the error arm of the effect phase (#2840 ruling):
@@ -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.Je = true;
-                this.C.enqueue(this.Re, this.Xe ??= runEffect.bind(null, this));
+                this.Xe = true;
+                this.C.enqueue(this.Re, this.et ??= runEffect.bind(null, this));
             }
             return;
         }
@@ -44,12 +44,12 @@ function notifyEffectStatus(t, E) {
             throw R;
         }
     } else if (this.Re === EFFECT_RENDER) {
-        this.C.notify(this, STATUS_PENDING | STATUS_ERROR, e, R);
+        this.C.notify(this, STATUS_PENDING | STATUS_ERROR, E, R);
     }
 }
 
 function runEffect(t) {
-    if (!t.Je || t.se & REACTIVE_DISPOSED) return;
+    if (!t.Xe || 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
@@ -61,85 +61,85 @@ function runEffect(t) {
     // 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) {
-        const E = unwrapStatusError(t._);
-        t._t = t.Ue;
-        t.Je = false;
+        const e = unwrapStatusError(t.o?._);
+        t.Tt = t.be;
+        t.Xe = false;
         try {
-            t.Et ? t.Et(E, () => {
-                const E = t.Tt;
-                t.Tt = undefined;
-                E?.();
-            }) : console.error(E);
-        } catch (E) {
+            t.St ? t.St(e, () => {
+                const e = t.At;
+                t.At = undefined;
+                e?.();
+            }) : console.error(e);
+        } catch (e) {
             if (!t.C.notify(t, STATUS_ERROR, STATUS_ERROR)) {
-                haltReactivity(E);
-                throw E;
+                haltReactivity(e);
+                throw e;
             }
         }
         return;
     }
-    const E = t.Tt;
-    t.Tt = undefined;
+    const e = t.At;
+    t.At = undefined;
     try {
-        E?.();
-        const e = t.ft(t.Ue, t._t);
-        if (false && e !== undefined && typeof e !== "function") ;
+        e?.();
+        const E = t.dt(t.be, t.Tt);
+        if (false && E !== undefined && typeof E !== "function") ;
         // The final cleanup is invoked by disposeChildren at true disposal.
-                t.Tt = e;
-    } catch (E) {
-        t._ = new StatusError(t, E);
+                t.At = E;
+    } catch (e) {
+        ext(t)._ = new StatusError(t, e);
         t.S |= STATUS_ERROR;
         if (!t.C.notify(t, STATUS_ERROR, STATUS_ERROR)) {
-            haltReactivity(E);
-            throw E;
+            haltReactivity(e);
+            throw e;
         }
     } finally {
-        t._t = t.Ue;
-        t.Je = false;
+        t.Tt = t.be;
+        t.Xe = false;
     }
 }
 
-GlobalQueue.et = runEffect;
+GlobalQueue.tt = runEffect;
 
 /**
  * Internal tracked effect - bypasses heap, goes directly to effect queue.
  * Runs as a leaf owner: child primitives and onCleanup are forbidden (false throws).
  * Uses stale reads.
- */ function trackedEffect(t, E) {
+ */ function trackedEffect(t, e) {
     const run = () => {
-        if (!e.Je || e.se & REACTIVE_DISPOSED) return;
+        if (!E.Xe || E.ie & REACTIVE_DISPOSED) return;
         try {
-            e.Je = false;
-            recompute(e);
+            E.Xe = false;
+            recompute(E);
         } finally {}
     };
-    const e = computed(() => {
-        const E = e.Tt;
-        e.Tt = undefined;
-        E?.();
+    const E = computed(() => {
+        const e = E.At;
+        E.At = undefined;
+        e?.();
         const R = staleValues(t);
-        e.Tt = R;
+        E.At = R;
     }, {
-        ...E,
+        ...e,
         lazy: true
     });
-    e.Tt = undefined;
-    e.T = e.T & ~CONFIG_AUTO_DISPOSE | CONFIG_CHILDREN_FORBIDDEN;
-    e.Je = true;
-    e.Re = EFFECT_TRACKED;
-    e.i = (t, E) => {
-        const R = t !== undefined ? t : e.S;
+    E.At = undefined;
+    E.T = E.T & ~CONFIG_AUTO_DISPOSE | CONFIG_CHILDREN_FORBIDDEN;
+    E.Xe = true;
+    E.Re = EFFECT_TRACKED;
+    ext(E).A = (t, e) => {
+        const R = t !== undefined ? t : E.S;
         if (R & STATUS_ERROR) {
-            e.C.notify(e, STATUS_PENDING, 0);
-            const t = E !== undefined ? E : e._;
-            if (!e.C.notify(e, STATUS_ERROR, STATUS_ERROR)) {
+            E.C.notify(E, STATUS_PENDING, 0);
+            const t = e !== undefined ? e : E.o?._;
+            if (!E.C.notify(E, STATUS_ERROR, STATUS_ERROR)) {
                 haltReactivity(unwrapStatusError(t));
                 throw t;
             }
         }
     };
-    e.Ft = run;
-    e.C.enqueue(EFFECT_USER, run);
+    E.Ut = run;
+    E.C.enqueue(EFFECT_USER, run);
 }
 
 export { effect, trackedEffect };

package/dist/prod/core/external.js

@@ -46,11 +46,11 @@ function wireExternalSource(e) {
         equals: false,
         ownedWrite: true
     });
-    const r = externalSourceConfig.factory(e.ce, () => {
+    const r = externalSourceConfig.factory(e.Se, () => {
         setSignal(n, undefined);
     });
     cleanup(() => r.dispose());
-    e.ce = e => {
+    e.Se = e => {
         read(n);
         return r.track(e);
     };
@@ -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.It = externalSourceConfig ? wireExternalSource : null;
-    GlobalQueue.St = externalSourceConfig ? externalUntrack : null;
+    GlobalQueue.Rt = externalSourceConfig ? wireExternalSource : null;
+    GlobalQueue.Gt = externalSourceConfig ? externalUntrack : null;
 }
 
 function enableExternalSource(e) {

package/dist/prod/core/graph.js

@@ -4,75 +4,84 @@ import { deleteFromHeap, queueFor } from "./heap.js";
 
 import { disposeChildren } from "./owner.js";
 
-import "./scheduler.js";
+import { bumpNotifyEpoch } from "./scheduler.js";
 
 // https://github.com/stackblitz/alien-signals/blob/v2.0.3/src/system.ts#L100
-function unlinkSubs(l) {
-    const n = l.it;
-    const e = l.nt;
-    const u = l.le;
-    const s = l.ll;
-    if (u !== null) u.ll = s; else n.rt = s;
-    if (s !== null) s.le = u; else {
-        n.o = u;
+function unlinkSubs(e) {
+    const l = e.ut;
+    const n = e.it;
+    const u = e.fe;
+    const s = e.el;
+    if (u !== null) u.el = s; else l.rt = s;
+    if (s !== null) s.fe = u; else {
+        l.u = u;
         if (u === null) {
-            n.ut?.();
+            l.o?.ft?.();
             // 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
             // the work and re-execute it on the next read. The settle path runs
             // this same last-one-out check when that observer releases (the
             // untracked-read dispose in core.ts guards on pending identically).
-                        const l = n;
-            l.ce && l.T & CONFIG_AUTO_DISPOSE && !(l.se & REACTIVE_ZOMBIE) && !(l.S & STATUS_PENDING) && unobserved(l);
+                        const e = l;
+            e.Se && e.T & CONFIG_AUTO_DISPOSE && !(e.ie & REACTIVE_ZOMBIE) && !(e.S & STATUS_PENDING) && unobserved(e);
         }
     }
-    return e;
+    return n;
 }
 
-function trimStaleDeps(l) {
-    const n = l.Ye;
-    let e = n !== null ? n.nt : l.tt;
-    if (e !== null) {
+function trimStaleDeps(e) {
+    const l = e.Ye;
+    let n = l !== null ? l.it : e.nt;
+    if (n !== null) {
         do {
-            e = unlinkSubs(e);
-        } while (e !== null);
-        if (n !== null) n.nt = null; else l.tt = null;
+            n = unlinkSubs(n);
+        } while (n !== null);
+        if (l !== null) l.it = null; else e.nt = null;
     }
 }
 
-function unobserved(l) {
-    deleteFromHeap(l, queueFor(l));
-    let n = l.tt;
-    while (n !== null) {
-        n = unlinkSubs(n);
-    }
-    l.tt = null;
-    l.Ye = null;
-    disposeChildren(l, true);
+// Shared by unobserved() and the disposeChildren child loop. The truthy guard
+// (not `!== null`) matters: plain Owners in a child chain have no _deps field,
+// and skipping early also avoids adding one (hidden-class churn) via the
+// null-out below.
+function clearDeps(e) {
+    let l = e.nt;
+    if (!l) return;
+    do {
+        l = unlinkSubs(l);
+    } while (l !== null);
+    e.nt = null;
+    e.Ye = null;
+}
+
+function unobserved(e) {
+    deleteFromHeap(e, queueFor(e));
+    clearDeps(e);
+    disposeChildren(e, true);
 }
 
 // https://github.com/stackblitz/alien-signals/blob/v2.0.3/src/system.ts#L52
-function link(l, n, e = false) {
+function link(e, l, n = false) {
     // Repeat touches within one pass AND-combine `_pendingObserver`: a probe
     // read (`isPending(() => x())`) beside a value read of the same dep must
     // 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 u = n.Ye;
-    if (u !== null && u.it === l) {
-        u.Ge &&= e;
+    const u = l.Ye;
+    if (u !== null && u.ut === e) {
+        u.me &&= n;
         return;
     }
     let s = null;
-    const t = n.se & REACTIVE_RECOMPUTING_DEPS;
-    if (t) {
-        s = u !== null ? u.nt : n.tt;
-        if (s !== null && s.it === l) {
-            s.nl = n.Ze;
-            n.Ye = s;
+    const o = l.ie & REACTIVE_RECOMPUTING_DEPS;
+    if (o) {
+        s = u !== null ? u.it : l.nt;
+        if (s !== null && s.ut === e) {
+            s.ll = l.Ze;
+            l.Ye = s;
             // First touch of this pass: the previous pass's label is stale.
-                        s.Ge = e;
+                        s.me = n;
             return;
         }
     }
@@ -81,24 +90,26 @@ function link(l, n, e = 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 i = l.rt;
-    if (i !== null && i.fe === n && (!t || i.nl === n.Ze)) {
+        const t = e.rt;
+    if (t !== null && t.ae === l && (!o || t.ll === l.Ze)) {
         // 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) i.Ge &&= e; else i.Ge = e;
+        if (o) t.me &&= n; else t.me = n;
         return;
     }
-    const o = n.Ye = l.rt = {
-        it: l,
-        fe: n,
-        nt: s,
-        ll: i,
-        le: null,
-        nl: n.Ze,
-        Ge: e
+    const i = l.Ye = e.rt = {
+        ut: e,
+        ae: l,
+        it: s,
+        el: t,
+        fe: null,
+        ll: l.Ze,
+        me: n
     };
-    if (u !== null) u.nt = o; else n.tt = o;
-    if (i !== null) i.le = o; else l.o = o;
+    if (u !== null) u.it = i; else l.nt = i;
+    if (t !== null) t.fe = i; else e.u = i;
+    // New subscriber edge: staged-rewrite skips (§12d) must not miss it.
+        bumpNotifyEpoch();
 }
 
-export { link, trimStaleDeps, unlinkSubs, unobserved };
+export { clearDeps, link, trimStaleDeps, unlinkSubs, unobserved };

package/dist/prod/core/heap.js

@@ -1,9 +1,11 @@
-import { REACTIVE_IN_HEAP, REACTIVE_IN_HEAP_HEIGHT, EFFECT_TRACKED, EFFECT_USER, REACTIVE_RECOMPUTING_DEPS, REACTIVE_MANUAL_WRITE, REACTIVE_ZOMBIE, REACTIVE_CHECK, REACTIVE_DIRTY } from "./constants.js";
+import "./core.js";
+
+import { REACTIVE_IN_HEAP, REACTIVE_IN_HEAP_HEIGHT, EFFECT_TRACKED, EFFECT_USER, REACTIVE_RECOMPUTING_DEPS, REACTIVE_MANUAL_WRITE, REACTIVE_ZOMBIE, REACTIVE_CHECK, REACTIVE_DIRTY, CONFIG_FW_CHILDREN } from "./constants.js";
 
 import { zombieQueue, dirtyQueue } from "./scheduler.js";
 
 /** The queue a node belongs to, picked from its own zombie flag. */ function queueFor(e) {
-    return e.se & REACTIVE_ZOMBIE ? zombieQueue : dirtyQueue;
+    return e.ie & REACTIVE_ZOMBIE ? zombieQueue : dirtyQueue;
 }
 
 /**
@@ -13,21 +15,21 @@ import { zombieQueue, dirtyQueue } from "./scheduler.js";
  */ function enqueueSub(e) {
     if (e.Re === EFFECT_TRACKED) {
         const E = e;
-        if (!E.Je) {
-            E.Je = true;
-            E.C.enqueue(EFFECT_USER, E.Ft);
+        if (!E.Xe) {
+            E.Xe = true;
+            E.C.enqueue(EFFECT_USER, E.Ut);
         }
         return;
     }
     const E = queueFor(e);
-    if (E.Ve > e.xe) E.Ve = e.xe;
+    if (E.xe > e.Le) E.xe = e.Le;
     insertIntoHeap(e, E);
 }
 
 function actualInsertIntoHeap(e, E) {
-    const t = (e.ke?.Nt ? e.ke.dt?.xe : e.ke?.xe) ?? -1;
-    if (t >= e.xe) e.xe = t + 1;
-    const n = e.xe;
+    const t = (e.ve?.Ct ? e.ve.Ot?.Le : e.ve?.Le) ?? -1;
+    if (t >= e.Le) e.Le = t + 1;
+    const n = e.Le;
     const I = E.eE[n];
     if (I === undefined) E.eE[n] = e; else {
         const E = I.st;
@@ -39,12 +41,15 @@ function actualInsertIntoHeap(e, E) {
 }
 
 function insertIntoHeap(e, E) {
-    let t = e.se;
-    if (t & (REACTIVE_IN_HEAP | REACTIVE_RECOMPUTING_DEPS | REACTIVE_MANUAL_WRITE)) return;
+    let t = e.ie;
+    // RECOMPUTING refusals are not always losses: a genuinely missed wake (a
+    // write to a link this pass already validated) is latched link-side in
+    // insertSubs as REACTIVE_MISSED_WAKE for recompute's tail (#3037).
+        if (t & (REACTIVE_IN_HEAP | REACTIVE_RECOMPUTING_DEPS | REACTIVE_MANUAL_WRITE)) return;
     if (t & REACTIVE_CHECK) {
-        e.se = t & -4 | REACTIVE_DIRTY | REACTIVE_IN_HEAP;
+        e.ie = t & -4 | REACTIVE_DIRTY | REACTIVE_IN_HEAP;
     } else {
-        e.se = t | REACTIVE_IN_HEAP;
+        e.ie = t | REACTIVE_IN_HEAP;
         // An unmarked node entering a marked heap invalidates the markHeap memo:
         // `_marked` is only reset by runHeap, so a write between two mid-tick
         // pulls (read-time markHeap + updateIfNecessary) would otherwise leave
@@ -56,17 +61,17 @@ function insertIntoHeap(e, E) {
 }
 
 function insertIntoHeapHeight(e, E) {
-    let t = e.se;
+    let t = e.ie;
     if (t & (REACTIVE_IN_HEAP | REACTIVE_RECOMPUTING_DEPS | REACTIVE_IN_HEAP_HEIGHT | REACTIVE_MANUAL_WRITE)) return;
-    e.se = t | REACTIVE_IN_HEAP_HEIGHT;
+    e.ie = t | REACTIVE_IN_HEAP_HEIGHT;
     actualInsertIntoHeap(e, E);
 }
 
 function deleteFromHeap(e, E) {
-    const t = e.se;
+    const t = e.ie;
     if (!(t & (REACTIVE_IN_HEAP | REACTIVE_IN_HEAP_HEIGHT))) return;
-    e.se = t & -25;
-    const n = e.xe;
+    e.ie = t & -25;
+    const n = e.Le;
     if (e.st === e) E.eE[n] = undefined; else {
         const t = e.ot;
         const I = E.eE[n];
@@ -83,22 +88,25 @@ function markHeap(e) {
     e.tE = true;
     for (let E = 0; E <= e.EE; E++) {
         for (let t = e.eE[E]; t !== undefined; t = t.ot) {
-            if (t.se & REACTIVE_IN_HEAP) markNode(t);
+            if (t.ie & REACTIVE_IN_HEAP) markNode(t);
         }
     }
 }
 
 function markNode(e, E = REACTIVE_DIRTY) {
-    const t = e.se;
+    const t = e.ie;
     if ((t & (REACTIVE_CHECK | REACTIVE_DIRTY)) >= E) return;
-    e.se = t & -4 | E;
-    for (let E = e.o; E !== null; E = E.le) {
-        markNode(E.fe, REACTIVE_CHECK);
+    e.ie = t & -4 | E;
+    for (let E = e.u; E !== null; E = E.fe) {
+        markNode(E.ae, REACTIVE_CHECK);
     }
-    if (e.u !== null) {
-        for (let E = e.u; E !== null; E = E.ae) {
-            for (let e = E.o; e !== null; e = e.le) {
-                markNode(e.fe, REACTIVE_CHECK);
+    // Firewall children (projection machinery only): gate the cold-extension
+    // deref on the config bit — markNode runs per sub edge per write, and an
+    // unconditional _x chase here taxed every propagation (diamond -22%).
+        if (e.T & CONFIG_FW_CHILDREN) {
+        for (let E = e.o.l; E !== null; E = E.ce) {
+            for (let e = E.u; e !== null; e = e.fe) {
+                markNode(e.ae, REACTIVE_CHECK);
             }
         }
     }
@@ -106,11 +114,11 @@ function markNode(e, E = REACTIVE_DIRTY) {
 
 function runHeap(e, E) {
     e.tE = false;
-    for (e.Ve = 0; e.Ve <= e.EE; e.Ve++) {
-        let t = e.eE[e.Ve];
+    for (e.xe = 0; e.xe <= e.EE; e.xe++) {
+        let t = e.eE[e.xe];
         while (t !== undefined) {
-            if (t.se & REACTIVE_IN_HEAP) E(t); else adjustHeight(t, e);
-            t = e.eE[e.Ve];
+            if (t.ie & REACTIVE_IN_HEAP) E(t); else adjustHeight(t, e);
+            t = e.eE[e.xe];
         }
     }
     e.EE = 0;
@@ -118,21 +126,21 @@ function runHeap(e, E) {
 
 function adjustHeight(e, E) {
     deleteFromHeap(e, E);
-    let t = e.xe;
-    for (let E = e.tt; E; E = E.nt) {
-        const e = E.it;
+    let t = e.Le;
+    for (let E = e.nt; E; E = E.it) {
+        const e = E.ut;
         const n = e.lt || e;
-        if (n.ce && n.xe >= t) t = n.xe + 1;
+        if (n.Se && n.Le >= t) t = n.Le + 1;
     }
-    if (e.xe !== t) {
-        e.xe = t;
-        for (let E = e.o; E !== null; E = E.le) {
+    if (e.Le !== t) {
+        e.Le = t;
+        for (let E = e.u; E !== null; E = E.fe) {
             // Route each subscriber by its own zombie flag, mirroring the
             // post-recompute height-adjust path. Inserting into the running `heap`
             // unconditionally can park a zombie in `dirtyQueue` (or a live node in
             // `zombieQueue`), breaking the flag/queue invariant `deleteFromHeap`
             // relies on — the same corruption class as #2759.
-            insertIntoHeapHeight(E.fe, queueFor(E.fe));
+            insertIntoHeapHeight(E.ae, queueFor(E.ae));
         }
     }
 }

package/dist/prod/core/invariants.js

@@ -1,3 +1,5 @@
+import "./core.js";
+
 /**
  * INV-2: a node with an *active* override must be registered for reversion in
  * the queue's or a transition's `_optimisticNodes`. An unregistered active
@@ -6,8 +8,7 @@
  * (There is no revert-target requirement: authoritative values commit
  * silently into `_value` under the override mask — A17 — so reverting is
  * just dropping the override.)
- */
-function devCheckActiveOverrides(e) {
+ */ function devCheckActiveOverrides(e) {
     return;
 }