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

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.ie ?? null;
+    let n = "_parent" in e ? e : e.H ?? 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.ie ?? null;
+    let n = "_parent" in e ? e : e.H ?? 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.ie = n;
+    e.H = n;
 }
 
 /**

package/dist/observe/core/effect.js

@@ -1,6 +1,6 @@
-import { REACTIVE_DISPOSED, LANE_RUN, STATUS_ERROR, EFFECT_USER, NOT_PENDING, CONFIG_AUTO_DISPOSE, CONFIG_CHILDREN_FORBIDDEN, EFFECT_TRACKED, EFFECT_RENDER, STATUS_PENDING } from "./constants.js";
+import { NOT_PENDING, EFFECT_USER, CONFIG_AUTO_DISPOSE, CONFIG_CHILDREN_FORBIDDEN, EFFECT_TRACKED, EFFECT_RENDER, REACTIVE_DISPOSED, STATUS_ERROR, STATUS_PENDING } from "./constants.js";
 
-import { setEffectStatusNotify, ext, createEffectNode, recompute, computed, staleValues } from "./core.js";
+import { createEffectNode, recompute, computed, staleValues, ext, setEffectStatusNotify } from "./core.js";
 
 import { attrHooks } from "./attribution-hooks.js";
 
@@ -12,75 +12,63 @@ import { trimStaleDeps } from "./graph.js";
 
 import { enqueueSub } from "./heap.js";
 
-import { GlobalQueue, currentTransition, activeTransition, haltReactivity, schedule } from "./scheduler.js";
+import { globalQueue, schedule, 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, r, E) {
-    const i = !!E?.user;
-    const n = createEffectNode(t, e, r, i ? EFFECT_USER : EFFECT_RENDER, E);
-    recompute(n, true);
-    // A first pass that derived from a live transaction's staged world was
-    // staged into that transaction (recompute: born held); the transaction's
-    // commit replays this effect. Its first run is not this creation's (A29).
-        !E?.defer && n._e === NOT_PENDING && (n.He === EFFECT_USER || E?.schedule ? n.T.enqueue(n.He, runEffect.bind(null, n)) : runEffect(n, LANE_RUN));
+ */ function effect(t, e, u, o) {
+    const E = !!o?.user;
+    const r = createEffectNode(t, e, u, E ? EFFECT_USER : EFFECT_RENDER, o);
+    recompute(r, true);
+    // A first pass that read a staged value was staged itself (recompute: born
+    // 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));
 }
 
 function notifyEffectStatus(t, e) {
     // Use passed values if provided, otherwise read from node
-    const r = t !== undefined ? t : this.S;
-    const E = e !== undefined ? e : this.o?._;
-    if (r & STATUS_ERROR) {
-        this.T.notify(this, STATUS_PENDING, 0);
-        if (this.He === EFFECT_USER) {
+    const u = t !== undefined ? t : this.G;
+    const o = e !== undefined ? e : this.m?.v;
+    if (u & STATUS_ERROR) {
+        globalQueue.notify(this, STATUS_PENDING, 0);
+        if (this.i === 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
-            // (or optimistic lane) defers it exactly as it defers the success arm.
-            // No payload is queued — the node already carries `_statusFlags`/`_error`,
+            // writable scope and throws escalate the same way. No payload is queued — the node already carries `_statusFlags`/`_error`,
             // and the runner dispatches on them, so a recovery before the effect
             // 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.S & STATUS_ERROR) {
-                this.it = true;
-                this.T.enqueue(this.He, this.Ct ??= runEffect.bind(null, this));
+            if (this.G & STATUS_ERROR) {
+                this.lt = true;
+                globalQueue.enqueue(this.i, this.J ??= runEffect.bind(null, this));
             }
             return;
         }
-        if (!this.T.notify(this, STATUS_ERROR, STATUS_ERROR)) {
-            haltReactivity(unwrapStatusError(E));
-            throw E;
+        if (!globalQueue.notify(this, STATUS_ERROR, STATUS_ERROR)) {
+            haltReactivity(unwrapStatusError(o));
+            throw o;
         }
-    } else if (this.He === EFFECT_RENDER) {
-        this.T.notify(this, STATUS_PENDING | STATUS_ERROR, r, E);
+    } else if (this.i === EFFECT_RENDER) {
+        globalQueue.notify(this, STATUS_PENDING | STATUS_ERROR, u, o);
     }
 }
 
 function runEffect(t, e) {
-    if (!t.it || t.oe & REACTIVE_DISPOSED) return;
-    // Ownership (#3319): a value computed under a transaction is applied by that
-    // transaction's commit. The ordinary effect phase runs with a transaction
-    // active only when the flush's finalize ENTERED one (every other path parks
-    // or settles first): leave a run owned by a still-held transaction queued —
-    // `_modified` stays set — and the next gate stashes it with the owner.
-    // Mainline-owned runs (null) apply now. Lanes are exempt by design (they
-    // apply their own effects ahead of their transaction — the optimistic view)
-    // and mark their runs with LANE_RUN.
-    
-    // Lane exemption has one exception (#3331): a lane runner for an effect that
-    // no longer rides a lane — its optimistic source was superseded, so the lane
-    // has no optimistic view left to apply, and the value this effect now
-    // carries (or will, once its plain recompute lands) belongs to the still-held
-    // transaction. Hand the run to the regular queue, where the transaction's
-    // gate stashes it with the owner. Lane-less runners with no live owner
-    // (reverts, wake-only lanes) apply now.
-        if (t.Gt !== null && !currentTransition(t.Gt).Dt && (e & LANE_RUN ? !t.o?.Ce : activeTransition !== null)) {
-        t.T.enqueue(t.He, t.Ct);
-        return;
-    }
+    if (!t.lt || t.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
+    // the sync renders through… we definitely shouldn't be showing portals
+    // early") — a Portal's or head-tag's render effect writes outside the
+    // 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;
     // 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
@@ -91,18 +79,18 @@ 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.S & STATUS_ERROR && t.He === EFFECT_USER) {
-        const e = unwrapStatusError(t.o?._);
-        t.Mt = t.ce;
-        t.it = false;
+        if (t.G & STATUS_ERROR && t.i === EFFECT_USER) {
+        const e = unwrapStatusError(t.m?.v);
+        t.Nt = t.pe;
+        t.lt = false;
         try {
-            t.Wt ? t.Wt(e, () => {
-                const e = t.qt;
-                t.qt = undefined;
+            t.Lt ? t.Lt(e, () => {
+                const e = t.kt;
+                t.kt = undefined;
                 e?.();
             }) : console.error(e);
         } catch (e) {
-            if (!t.T.notify(t, STATUS_ERROR, STATUS_ERROR)) {
+            if (!globalQueue.notify(t, STATUS_ERROR, STATUS_ERROR)) {
                 haltReactivity(e);
                 throw e;
             }
@@ -111,43 +99,43 @@ 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 r = t.o?._ == null;
+        const u = t.m?.v == 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`
     // record) — facts a production observer needs, not only a dev console.
         if (attrHooks !== null) attrHooks.effectRunStart(t);
-    const E = t.qt;
-    t.qt = undefined;
+    const o = t.kt;
+    t.kt = undefined;
     try {
-        E?.();
-        const e = t.wt(t.ce, t.Mt);
+        o?.();
+        const e = t.Ut(t.pe, t.Nt);
         if (false && e !== undefined && typeof e !== "function") ;
         // The final cleanup is invoked by disposeChildren at true disposal.
-                t.qt = e;
+                t.kt = e;
     } catch (e) {
-        ext(t)._ = new StatusError(t, e);
-        t.S |= STATUS_ERROR;
-        if (!t.T.notify(t, STATUS_ERROR, STATUS_ERROR)) {
+        ext(t).v = new StatusError(t, e);
+        t.G |= STATUS_ERROR;
+        if (!globalQueue.notify(t, STATUS_ERROR, STATUS_ERROR)) {
             haltReactivity(e);
             throw e;
         }
     } finally {
-        t.Mt = t.ce;
-        t.it = false;
+        t.Nt = t.pe;
+        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
         // effect's trim while a run is owed; the twin of `commitPendingNode`'s
         // trim for a staged pass). An errored compute kept its full list with
         // `_depsTail` marking where it stopped; leave it, as the commit does.
-                if (r) trimStaleDeps(t);
+                if (u) trimStaleDeps(t);
     }
     // Outside the try (see the rule in attribution-hooks.ts). Reached whether or
     // not the callback threw — a throw that escapes the catch above halts.
         if (attrHooks !== null) attrHooks.effectRunEnd(t);
 }
 
-GlobalQueue.Rt = runEffect;
+GlobalQueue.X = runEffect;
 
 /**
  * Internal tracked effect - bypasses heap, goes directly to effect queue.
@@ -156,39 +144,40 @@ GlobalQueue.Rt = runEffect;
  */ function trackedEffect(t, e) {
     const run = () => {
         // `_modified` is NOT redundant with the heap: the heap dedups within a
-        // pass, but a held transition's passes each enqueue `_run` into the same
-        // user queue, and this gate is what collapses them into one run at commit.
-        if (!r.it || r.oe & REACTIVE_DISPOSED) return;
+        // 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;
         try {
-            r.it = false;
-            recompute(r);
+            u.lt = false;
+            recompute(u);
         } finally {}
     };
-    const r = computed(() => {
-        const e = r.qt;
-        r.qt = undefined;
+    const u = computed(() => {
+        const e = u.kt;
+        u.kt = undefined;
         e?.();
-        const E = staleValues(t);
-        r.qt = E;
+        const o = staleValues(t);
+        u.kt = o;
     }, {
         ...e,
         lazy: true
     });
-    r.qt = undefined;
-    r.C = r.C & ~CONFIG_AUTO_DISPOSE | CONFIG_CHILDREN_FORBIDDEN;
-    r.it = true;
-    r.He = EFFECT_TRACKED;
+    u.kt = undefined;
+    u.u = u.u & ~CONFIG_AUTO_DISPOSE | CONFIG_CHILDREN_FORBIDDEN;
+    u.lt = true;
+    u.i = 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) r._name = "trackedEffect";
+        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.
-        r.lt = run;
+        u.q = 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.
-        enqueueSub(r);
+        enqueueSub(u);
     schedule();
 }
 

package/dist/observe/core/external.js

@@ -46,11 +46,11 @@ function wireExternalSource(e) {
         equals: false,
         ownedWrite: true
     });
-    const r = externalSourceConfig.factory(e.Se, () => {
+    const r = externalSourceConfig.factory(e.re, () => {
         setSignal(n, undefined);
     });
     cleanup(() => r.dispose());
-    e.Se = e => {
+    e.re = e => {
         read(n);
         return r.track(e);
     };
@@ -61,11 +61,11 @@ function externalUntrack(e) {
 }
 
 // The hooks mirror the config's liveness exactly (installed on enable,
-// removed on reset) so core's null checks stay equivalent to the old
+// removed on reset) so core's presence checks stay equivalent to the old
 // `externalSourceConfig` truthiness checks.
 function syncExternalHooks() {
-    GlobalQueue.Bt = externalSourceConfig ? wireExternalSource : null;
-    GlobalQueue.Jt = externalSourceConfig ? externalUntrack : null;
+    GlobalQueue.xt = externalSourceConfig ? wireExternalSource : undefined;
+    GlobalQueue.Wt = externalSourceConfig ? externalUntrack : undefined;
 }
 
 function enableExternalSource(e) {

package/dist/observe/core/graph.js

@@ -1,47 +1,54 @@
 import { CONFIG_AUTO_DISPOSE, STATUS_PENDING, REACTIVE_DISPOSED, REACTIVE_ZOMBIE, CONFIG_SLOT_NODE, REACTIVE_RECOMPUTING_DEPS } from "./constants.js";
 
-import { slotUnobservedHook } from "./core.js";
-
-import { deleteFromHeap, queueFor } from "./heap.js";
+import { deleteFromHeap } from "./heap.js";
 
 import { disposeChildren } from "./owner.js";
 
-import { bumpNotifyEpoch } from "./scheduler.js";
+import { bumpNotifyEpoch, dirtyQueue } from "./scheduler.js";
+
+/** The store's shared slot-node release handler (store/store.ts installs it
+ * once) — a live binding read directly by the sweep site: no wrapper frame,
+ * no null check (a CONFIG_SLOT_NODE node existing implies the store module
+ * loaded and registered it). */ let slotUnobservedHook;
+
+function setSlotUnobserved(e) {
+    slotUnobservedHook = e;
+}
 
 // https://github.com/stackblitz/alien-signals/blob/v2.0.3/src/system.ts#L100
 function unlinkSubs(e) {
-    const n = e.De;
-    const l = e.Ie;
-    const o = e.Pe;
-    const s = e.jn;
-    if (o !== null) o.jn = s; else n.Ht = s;
-    if (s !== null) s.Pe = o; else {
-        n.u = o;
-        if (o === null) {
-            // Slot nodes (store leaves) dispatch to the ONE shared hook — no
-            // per-node unobserved closure, no NodeExtension to hold it.
-            if (n.C & CONFIG_SLOT_NODE) slotUnobservedHook(n); else n.o?.bt?.();
+    const n = e.I;
+    const o = e.p;
+    const l = e.l;
+    const t = e.ln;
+    if (l !== null) l.ln = t; else n.Dt = t;
+    if (t !== null) t.l = 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?.();
             // 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 dormancy sweep guards on pending identically).
+            // 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
+            // read. The settle path runs this same last-one-out check when that
+            // observer releases (the untracked-read dormancy sweep guards on
+            // pending identically).
                         const e = n;
-            e.Se && e.C & CONFIG_AUTO_DISPOSE && !(e.oe & REACTIVE_ZOMBIE) && !(e.S & STATUS_PENDING) && unobserved(e);
+            e.re && e.u & CONFIG_AUTO_DISPOSE && !(e.R & REACTIVE_ZOMBIE) && !(e.G & STATUS_PENDING) && unobserved(e);
         }
     }
-    return l;
+    return o;
 }
 
 function trimStaleDeps(e) {
-    const n = e.Je;
-    let l = n !== null ? n.Ie : e.Ee;
-    if (l !== null) {
+    const n = e.S;
+    let o = n !== null ? n.p : e._;
+    if (o !== null) {
         do {
-            l = unlinkSubs(l);
-        } while (l !== null);
-        if (n !== null) n.Ie = null; else e.Ee = null;
+            o = unlinkSubs(o);
+        } while (o !== null);
+        if (n !== null) n.p = null; else e._ = null;
     }
 }
 
@@ -50,17 +57,17 @@ function trimStaleDeps(e) {
 // and skipping early also avoids adding one (hidden-class churn) via the
 // null-out below.
 function clearDeps(e) {
-    let n = e.Ee;
+    let n = e._;
     if (!n) return;
     do {
         n = unlinkSubs(n);
     } while (n !== null);
-    e.Ee = null;
-    e.Je = null;
+    e._ = null;
+    e.S = null;
 }
 
 function unobserved(e) {
-    deleteFromHeap(e, queueFor(e));
+    deleteFromHeap(e, dirtyQueue);
     clearDeps(e);
     disposeChildren(e, true);
 }
@@ -94,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.u && e.C & CONFIG_AUTO_DISPOSE && !(e.S & STATUS_PENDING) && !(e.oe & (REACTIVE_DISPOSED | REACTIVE_ZOMBIE))) {
+        if (!e.t && e.u & CONFIG_AUTO_DISPOSE && !(e.G & STATUS_PENDING) && !(e.R & (REACTIVE_DISPOSED | REACTIVE_ZOMBIE))) {
             unobserved(e);
         }
     }
@@ -102,26 +109,16 @@ function sweepDormant() {
 }
 
 // https://github.com/stackblitz/alien-signals/blob/v2.0.3/src/system.ts#L52
-function link(e, n, l = 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 o = n.Je;
-    if (o !== null && o.De === e) {
-        o.Be &&= l;
-        return;
-    }
-    let s = null;
-    const t = n.oe & REACTIVE_RECOMPUTING_DEPS;
+function link(e, n) {
+    const o = n.S;
+    if (o !== null && o.I === e) return;
+    let l = null;
+    const t = n.R & REACTIVE_RECOMPUTING_DEPS;
     if (t) {
-        s = o !== null ? o.Ie : n.Ee;
-        if (s !== null && s.De === e) {
-            s.Ze = n.We;
-            n.Je = s;
-            // First touch of this pass: the previous pass's label is stale.
-                        s.Be = l;
+        l = o !== null ? o.p : n._;
+        if (l !== null && l.I === e) {
+            l.Ue = n.he;
+            n.S = l;
             return;
         }
     }
@@ -130,26 +127,20 @@ 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 r = e.Ht;
-    if (r !== null && r.Ae === n && (!t || r.Ze === n.We)) {
-        // 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) r.Be &&= l; else r.Be = l;
-        return;
-    }
-    const u = n.Je = e.Ht = {
-        De: e,
-        Ae: n,
-        Ie: s,
-        jn: r,
-        Pe: null,
-        Ze: n.We,
-        Be: l
+        const s = e.Dt;
+    if (s !== null && s.o === n && (!t || s.Ue === n.he)) return;
+    const u = n.S = e.Dt = {
+        I: e,
+        o: n,
+        p: l,
+        ln: s,
+        l: null,
+        Ue: n.he
     };
-    if (o !== null) o.Ie = u; else n.Ee = u;
-    if (r !== null) r.Pe = u; else e.u = u;
+    if (o !== null) o.p = u; else n._ = u;
+    if (s !== null) s.l = u; else e.t = u;
     // New subscriber edge: staged-rewrite skips (§12d) must not miss it.
         bumpNotifyEpoch();
 }
 
-export { clearDeps, dormantNodes, link, sweepDormant, trimStaleDeps, unlinkSubs, unobserved };
+export { clearDeps, dormantNodes, link, setSlotUnobserved, slotUnobservedHook, sweepDormant, trimStaleDeps, unlinkSubs, unobserved };