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

package/dist/prod/store/next/optimistic.js

@@ -2,7 +2,9 @@ import { CONFIG_AUTO_DISPOSE, STATUS_PENDING, NOT_PENDING, CONFIG_OPTIMISTIC, CO
 
 import { computed, setSignal, isEqual } from "../../core/core.js";
 
-import { activeTransition, GlobalQueue, runAsTransitionBatch, globalQueue, currentTransition } from "../../core/scheduler.js";
+import { getOwner } from "../../core/owner.js";
+
+import { activeTransition, GlobalQueue, currentTransition, globalQueue, createTransition, runAsTransitionBatch } from "../../core/scheduler.js";
 
 import "../../core/invariants.js";
 
@@ -108,14 +110,22 @@ function installNextBlockedHalf() {
     const e = GlobalQueue.dn;
     GlobalQueue.dn = t => {
         for (const e of t.En) {
-            const t = e?.[$TARGET];
-            const n = t?.fam?.node;
+            const n = e?.[$TARGET];
+            const i = n?.fam;
+            const o = i?.node;
             // The hold exists to keep optimistic state alive until the store's own
             // truth lands (#2951). Once the family carries NO live overrides (a
             // landing consumed them, or they never existed), a pending firewall is
             // no reason to park the transaction — blocking then leaks it forever
             // when the in-flight question is never answered (undisposed fixtures).
-                        if (n != null && n.S & STATUS_PENDING && familyHasLiveOverrides(t.fam)) return true;
+                        if (o == null || !(o.S & STATUS_PENDING)) continue;
+            // Ownership is declared (#3146): only the flight's OWN transaction
+            // parks on the flight (the #2951 anchor routed the bare write there).
+            // A transaction that merely brushed the store never waits for truth
+            // it does not carry.
+                        const r = i.ft != null ? liveTransition(i.ft) : null;
+            if (r !== null && r !== currentTransition(t)) continue;
+            if (familyHasLiveOverrides(i)) return true;
         }
         return e(t);
     };
@@ -129,10 +139,10 @@ function familyHasLiveOverrides(e) {
             if (t === null) continue;
             for (const e of Reflect.ownKeys(t)) {
                 const n = t[e];
-                if (n.o?.Oe !== undefined && n.o?.Oe !== NOT_PENDING) return true;
+                if (n.o?.Pe !== undefined && n.o?.Pe !== NOT_PENDING) return true;
             }
         }
-        if (e.k !== null && e.k.o?.Oe !== undefined && e.k.o?.Oe !== NOT_PENDING) return true;
+        if (e.k !== null && e.k.o?.Pe !== undefined && e.k.o?.Pe !== NOT_PENDING) return true;
     }
     t.clear();
  // nothing live — drop the bookkeeping
@@ -153,26 +163,47 @@ function createOptimisticStoreNext(e, t, n) {
         shallow: !!n?.shallow,
         opt: true
     };
-    const s = wrapNext(o, null, null, r);
-    r.px = s;
+    const l = wrapNext(o, null, null, r);
+    r.px = l;
     // Same key resolution the projection channels use ("id" default) — replay's
     // satisfaction rule reads it off the family.
-        const l = n?.key === undefined ? "id" : n.key;
-    r.key = typeof l === "function" ? l : l === null ? null : e => isWrappable(e) ? e[l] : undefined;
+        const s = n?.key === undefined ? "id" : n.key;
+    r.key = typeof s === "function" ? s : s === null ? null : e => isWrappable(e) ? e[s] : undefined;
     if (r.shallow) {
-        s[$TARGET].s = true;
+        l[$TARGET].s = true;
         markRawIngest(o);
     }
     if (i) {
         const t = e;
+        // #3146: an async settle event belongs to the flight's OWN transaction.
+        // A live declared one re-enters (a merge if the generic settle path
+        // already entered a graph-stamped stranger — the landing supersedes any
+        // recompute deriving from that stranger's world); a dead one renews (per
+        // A18(1) each arrival reveals on its own schedule, so per-yield
+        // transactions die with their commit and the next settle event opens the
+        // flight's next one — still declared, never anonymous). An UNDECLARED
+        // flight (loading window) keeps the ambient reveal (#2933: the loading
+        // rail is transaction-invisible).
+                const enterFlightTransition = () => {
+            const e = r.ft;
+            if (e == null) return;
+            let t = liveTransition(e);
+            if (t === null) r.ft = t = createTransition();
+            r.node.Ae = t;
+            globalQueue.initTransition(t);
+        };
         // Landing router (#3164 fold ruling): while a transaction retains
         // optimistic edits on this family, truth landings stage INTO it and
         // reveal atomically at settle; with no retainer they commit immediately
         // under the authoritative posture (async commits land outside the
-        // computed's sync body, so the posture is re-applied here).
+        // computed's sync body, so the posture is re-applied here) — inside the
+        // flight-owned transaction (#3146). Sync commits (the derive's body,
+        // owner is the firewall itself) reveal with their own recompute's flush.
                 const wrapCommit = (e, t) => {
             const n = retainingTransition(r);
-            if (n === null) runAuthoritative(e); else stageLanding(r, n, t);
+            if (n !== null) return void stageLanding(r, n, t);
+            if (getOwner() !== r.node) enterFlightTransition();
+            runAuthoritative(e);
         };
         // Draft writes (the derive mutating its draft, sync body and post-await
         // continuations alike) are the same truth channel per-operation: bind
@@ -184,24 +215,61 @@ function createOptimisticStoreNext(e, t, n) {
             const t = retainingTransition(r);
             if (t === null) e(); else runFolded(t, e);
         };
+        // Flight declaration (#3146): a recompute that registered a truth-flight
+        // OWNS its transaction. The ask's transaction is recorded on the family
+        // (created by the flight's own pending throw when none was ambient, the
+        // causing write's/refresh's when one was — graph-driven causality) and
+        // the firewall is stamped so every settle path resolves the flight's
+        // transaction by construction, not by whatever last brushed the node.
+        // When the ask took none (a dead stale stamp — the previous flight's,
+        // cleared nowhere — bare-returns the pre-throw entry), the flight opens
+        // its own here, same activation point as the pre-throw's creation: the
+        // ambient batch (the causing write, same-tick bare optimism) adopts into
+        // it exactly as it would have there, and the pending notification that
+        // follows this unwind registers observers against it. The flight
+        // also registers as its own async reporter: the transaction lives
+        // exactly as long as the question is unanswered, observed or not — the
+        // #2951 refetch-hold no longer depends on a tracked observer having
+        // happened to register one. Loading-window flights declare nothing
+        // (#2933: the loading rail is transaction-invisible); a sync run clears
+        // the declaration.
+                const declareFlight = e => {
+            if (e.o?.Ie == null) {
+                if (!e.Ne) r.ft = null;
+                return;
+            }
+            if (e.Ne) return;
+            let t = activeTransition;
+            if (t === null) globalQueue.initTransition(t = createTransition());
+            r.ft = t;
+            e.Ae = t;
+            let n = t._e.get(e);
+            if (n === undefined) t._e.set(e, n = new Set);
+            n.add(e);
+        };
         let i;
         if (n?.seedLoadingValue) i = {
             loadingValue: undefined
         };
         const o = computed(() => {
-            runAuthoritative(() => runProjectionComputedNext(s, t, n?.key === undefined ? "id" : n.key, wrapCommit, aroundDraftWrite));
+            const e = getOwner();
+            try {
+                runAuthoritative(() => runProjectionComputedNext(l, t, n?.key === undefined ? "id" : n.key, wrapCommit, aroundDraftWrite));
+            } finally {
+                declareFlight(e);
+            }
         }, i);
         o.T &= ~CONFIG_AUTO_DISPOSE;
         r.node = o;
     }
-    return [ s, e => {
+    return [ l, e => {
         // Retention ledger (#3164): record the owning transaction so landings
         // know to fold. Captured at entry — the action machinery has the
         // transaction ambient while user code runs; a bare write with no
         // transaction retains nothing (it rides the flight's own transition
         // per #2951 and dies with it).
         const t = activeTransition;
-        storeSetterNext(s, e);
+        storeSetterNext(l, e);
         if (t !== null) (r.rt ??= new Set).add(t);
     } ];
 }
@@ -281,8 +349,8 @@ function createOptimisticStoreNext(e, t, n) {
                 if (!isWrappable(i)) continue;
                 const r = n(i);
                 if (r === undefined) continue;
-                const s = (o ??= new Map).get(r);
-                if (s === undefined) o.set(r, [ i ]); else s.push(i);
+                const l = (o ??= new Map).get(r);
+                if (l === undefined) o.set(r, [ i ]); else l.push(i);
             }
             // Echo adoption: an optimistic structural add whose key the landing
             // confirms must keep its raw (and so its proxy — list drivers keep the
@@ -292,35 +360,35 @@ function createOptimisticStoreNext(e, t, n) {
             // keys; overlay rows only extend coverage. Adopted raws enter staged
             // truth; at settle the override reverts and the reveal re-seats the
             // same raw.
-                        const s = e[$TARGET]?.n;
-            if (s != null) {
-                for (const e of Reflect.ownKeys(s)) {
-                    const t = s[e];
+                        const l = e[$TARGET]?.n;
+            if (l != null) {
+                for (const e of Reflect.ownKeys(l)) {
+                    const t = l[e];
                     if (!hasActiveOverride(t)) continue;
-                    const i = unwrapValue(unwrapOverride(t.o.Oe));
+                    const i = unwrapValue(unwrapOverride(t.o.Pe));
                     if (!isWrappable(i)) continue;
                     const r = n(i);
                     if (r === undefined) continue;
-                    const l = (o ??= new Map).get(r);
-                    if (l === undefined) o.set(r, [ i ]); else l.push(i);
+                    const s = (o ??= new Map).get(r);
+                    if (s === undefined) o.set(r, [ i ]); else s.push(i);
                 }
             }
             for (let r = 0; r < i; r++) {
                 const i = t[r];
-                let s;
+                let l;
                 if (isWrappable(i) && o !== null) {
                     const e = n(i);
                     if (e !== undefined) {
                         for (const [t, n] of o) {
                             if (!sameKey(t, e)) continue;
-                            s = n.shift();
+                            l = n.shift();
                             if (n.length === 0) o.delete(t);
                             break;
                         }
                     }
                 }
-                if (s !== undefined) {
-                    if (unwrapValue(e[r]) !== s) e[r] = s;
+                if (l !== undefined) {
+                    if (unwrapValue(e[r]) !== l) e[r] = l;
                     stagedApply(e[r], i, n);
                 } else {
                     const t = unwrapValue(e[r]);
@@ -343,13 +411,13 @@ function createOptimisticStoreNext(e, t, n) {
         for (const o of Reflect.ownKeys(t)) {
         if (i && o === "length") continue;
         const r = t[o];
-        const s = unwrapValue(e[o]);
-        if (s === r) continue;
-        if (isWrappable(r) && isWrappable(s) && Array.isArray(r) === Array.isArray(s)) {
+        const l = unwrapValue(e[o]);
+        if (l === r) continue;
+        if (isWrappable(r) && isWrappable(l) && Array.isArray(r) === Array.isArray(l)) {
             // Different-keyed entities never merge (tentative-channel parity):
             // the incoming object replaces the slot wholesale.
             if (n !== null) {
-                const t = n(s);
+                const t = n(l);
                 const i = n(r);
                 if (t !== undefined && i !== undefined && !sameKey(t, i)) {
                     e[o] = r;
@@ -357,7 +425,7 @@ function createOptimisticStoreNext(e, t, n) {
                 }
             }
             stagedApply(e[o], r, n);
-        } else if (!isEqual(s, r) && !targetsEqual(s, r)) {
+        } else if (!isEqual(l, r) && !targetsEqual(l, r)) {
             e[o] = r;
         }
     }
@@ -373,13 +441,18 @@ function createOptimisticStoreNext(e, t, n) {
  * overrides — the same view the draft was seeded from) and emit engine writes
  * for exactly the changed keys. Visible-view diffing keeps no-op writes from
  * entangling lanes (RUL-10 / opt R38). */ function notifyOptimisticWrites(e, t) {
-    // A bare write while the store's own truth is in flight rides THAT
-    // transaction (#2951, legacy parity): entangle the firewall's transition so
-    // the override survives until the refetch settles instead of flash-reverting
+    // A bare write while the store's own truth is in flight rides the FLIGHT'S
+    // OWN transaction (#2951 via the #3146 declaration): entangle it so the
+    // override survives until the refetch settles instead of flash-reverting
     // at plain flush end. The blocked-check store-half keeps that transaction
-    // from settling while the firewall is pending.
-    const n = e.fam?.node;
-    if (n?.Ae) globalQueue.initTransition(n.Ae);
+    // from settling while the firewall is pending. Declared ownership replaces
+    // the old circumstantial route through the firewall's `_transition` stamp,
+    // which was whatever last brushed the node.
+    const n = e.fam?.ft;
+    if (n != null) {
+        const e = liveTransition(n);
+        if (e !== null) globalQueue.initTransition(e);
+    }
     const i = e.v;
     // Patch channel (override-application site): the draft IS the intended
     // visible state; prev is the view before these overrides apply. Bypasses
@@ -398,26 +471,26 @@ function createOptimisticStoreNext(e, t, n) {
     }
     const visible = (t, n) => {
         const i = e.n?.[t];
-        return i !== undefined && hasActiveOverride(i) ? unwrapOverride(i.o?.Oe) : n;
+        return i !== undefined && hasActiveOverride(i) ? unwrapOverride(i.o?.Pe) : n;
     };
     const visiblePresent = t => {
         const n = e.h?.[t];
-        return n !== undefined && hasActiveOverride(n) ? !!unwrapOverride(n.o?.Oe) : t in i;
+        return n !== undefined && hasActiveOverride(n) ? !!unwrapOverride(n.o?.Pe) : t in i;
     };
     let o = false;
     const r = Array.isArray(t);
     for (const n of Reflect.ownKeys(t)) {
         if (r && n === "length") continue;
-        const s = unwrapValue(t[n]);
+        const l = unwrapValue(t[n]);
         if (!visiblePresent(n)) {
             // Optimistic add: value node + presence node + membership bump.
-            setSignal(getNode(e, n, i[n]), () => s);
+            setSignal(getNode(e, n, i[n]), () => l);
             setSignal(getHasNode(e, n, n in i), true);
             o = true;
         } else {
             const t = visible(n, i[n]);
-            if (!isEqual(t, s) && !targetsEqual(t, s)) {
-                setSignal(getNode(e, n, t), () => s);
+            if (!isEqual(t, l) && !targetsEqual(t, l)) {
+                setSignal(getNode(e, n, t), () => l);
                 if (r) o = true;
             }
         }
@@ -467,7 +540,7 @@ function createOptimisticStoreNext(e, t, n) {
         for (const e of Reflect.ownKeys(i)) {
             const n = i[e];
             if (!hasActiveOverride(n)) continue;
-            const o = unwrapOverride(n.o?.Oe);
+            const o = unwrapOverride(n.o?.Pe);
             if (e === "length" && Array.isArray(t)) {
                 if (t.length !== o) ensure().length = o;
             } else if (!isEqual(t[e], o)) ensure()[e] = o;
@@ -478,7 +551,7 @@ function createOptimisticStoreNext(e, t, n) {
         for (const e of Reflect.ownKeys(o)) {
             const i = o[e];
             if (!hasActiveOverride(i)) continue;
-            const r = !!unwrapOverride(i.o?.Oe);
+            const r = !!unwrapOverride(i.o?.Pe);
             if (!r && e in (n ?? t)) delete ensure()[e];
         }
     }
@@ -489,11 +562,11 @@ function applyTentative(e, t, n) {
     const i = e.pb ?? e.v;
     const o = optimisticView(e, i);
     const r = e.fam.map;
-    const s = Array.isArray(t);
-    if (Array.isArray(o) !== s) return;
+    const l = Array.isArray(t);
+    if (Array.isArray(o) !== l) return;
  // kind change at root: flat overrides below
-        const l = [];
-    const u = s ? [ ...t ] : shallowWithSymbols(t);
+        const s = [];
+    const u = l ? [ ...t ] : shallowWithSymbols(t);
     const match = (e, t) => {
         if (!isWrappable(e) || !isWrappable(t)) return null;
         if (rawValuesUsed && (isRawValue(e) || isRawValue(t))) return null;
@@ -507,13 +580,13 @@ function applyTentative(e, t, n) {
         }
         return r.get(unwrapValue(e)) ?? null;
     };
-    if (s) {
+    if (l) {
         const e = o;
         let i = null;
         for (let o = 0; o < t.length; o++) {
             const r = t[o];
             if (!isWrappable(r)) continue;
-            let s;
+            let l;
             if (n) {
                 const t = n(r);
                 if (t !== undefined) {
@@ -533,20 +606,20 @@ function applyTentative(e, t, n) {
                         }
                     }
                     const o = i.get(t);
-                    if (o === undefined) s = undefined; else if (Array.isArray(o)) {
-                        s = unwrapValue(e[o.shift()]);
+                    if (o === undefined) l = undefined; else if (Array.isArray(o)) {
+                        l = unwrapValue(e[o.shift()]);
                         if (o.length === 1) i.set(t, o[0]);
                     } else {
-                        s = unwrapValue(e[o]);
+                        l = unwrapValue(e[o]);
                         i.delete(t);
                     }
-                } else s = unwrapValue(e[o]);
-            } else s = unwrapValue(e[o]);
-            const a = match(s, r);
+                } else l = unwrapValue(e[o]);
+            } else l = unwrapValue(e[o]);
+            const a = match(l, r);
             if (a !== null) {
                 // Keep the existing row in the slot (identity preserved); recurse.
-                u[o] = unwrapValue(s);
-                l.push([ a, r ]);
+                u[o] = unwrapValue(l);
+                s.push([ a, r ]);
             }
         }
     } else {
@@ -556,7 +629,7 @@ function applyTentative(e, t, n) {
             const r = match(n, i);
             if (r !== null) {
                 u[e] = n;
-                l.push([ r, i ]);
+                s.push([ r, i ]);
             }
         }
     }
@@ -566,7 +639,7 @@ function applyTentative(e, t, n) {
     e.pb = null;
     notifyOptimisticWrites(e, u);
     e.pb = a;
-    for (let e = 0; e < l.length; e++) applyTentative(l[e][0], unwrapValue(l[e][1]), n);
+    for (let e = 0; e < s.length; e++) applyTentative(s[e][0], unwrapValue(s[e][1]), n);
 }
 
 function shallowWithSymbols(e) {

package/dist/prod/store/next/projection.js

@@ -12,11 +12,11 @@ import "../../core/effect.js";
 
 import { CONFIG_AUTO_DISPOSE } from "../../core/constants.js";
 
-import { $TARGET, markRawIngest, STORE_VALUE, setWriteOverride } from "../store.js";
+import { $TARGET, STORE_VALUE, markRawIngest, setWriteOverride } from "../store.js";
 
 import { reconcileNextState } from "./reconcile.js";
 
-import { wrapNext, storeSetterNext } from "./store.js";
+import { storeSetterNext, wrapNext } from "./store.js";
 
 /**
  * Store rewrite — projections (§7/§7b): a projection is a computed store.