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

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

@@ -0,0 +1,385 @@
+import { computed, ext, setSignal, isEqual } from "../../core/core.js";
+
+import { CONFIG_AUTO_DISPOSE, STATUS_PENDING, NOT_PENDING, unwrapOverride, CONFIG_OPTIMISTIC } from "../../core/constants.js";
+
+import { GlobalQueue, insertSubs, schedule, globalQueue } from "../../core/scheduler.js";
+
+import "../../core/invariants.js";
+
+import "../../core/verdict.js";
+
+import "../../core/effect.js";
+
+import { installOptimisticEngine } from "../../core/optimistic.js";
+
+import { $TARGET, markRawIngest, setNextOptimisticViewResolver, isWrappable, rawValuesUsed, isRawValue } from "../store.js";
+
+import { runProjectionComputedNext } from "./projection.js";
+
+import { wrapNext, runAuthoritative, storeSetterNext, hasActiveOverride, unwrapValue, getNode, getHasNode, targetsEqual, getKeySetNode, bumpDeep } from "./store.js";
+
+import { setOptHooks } from "./target.js";
+
+/**
+ * Store rewrite — optimistic stores (§3/§7, RUL-3): no store-side layer, no
+ * backup snapshots. Nodes in an optimistic family are ARMED core signals
+ * (`_overrideValue` slot), so every user write rides the engine's
+ * optimisticWrite — per-transaction ownership, entanglement, reverts, and
+ * flash-at-flush are inherited, not reimplemented. Membership edits live on
+ * armed presence nodes (the §6 overlay), so structural optimism reverts with
+ * the same per-transaction granularity (FINDING-2's fix by construction).
+ *
+ * Derived form = an optimistic projection: the derive's recompute and its
+ * async commits run under projectionWriteActive (authoritative landings
+ * commit silently beneath any active overrides). The transitionBlocked
+ * store-half (#2951) is installed here for next-shaped targets, chaining the
+ * legacy/engine checks.
+ */ let blockedInstalled = false;
+
+function installNextBlockedHalf() {
+    if (blockedInstalled) return;
+    blockedInstalled = true;
+    // Late-bind the optimistic machinery into the plain store/reconcile paths
+    // (all call sites are fam?.opt-gated, so this always runs first) and the
+    // affects witness's view resolver.
+        setOptHooks({
+        notifyOptimisticWrites: notifyOptimisticWrites,
+        optimisticView: optimisticView,
+        applyTentative: applyTentative
+    });
+    setNextOptimisticViewResolver((e, t) => optimisticView(e, t));
+    // Scheduler flush tails call _clearOptimisticStores whenever tracked
+    // stores exist; next has no layer to clear — reverts are engine-native —
+    // so the hook only empties the batch set.
+        if (!GlobalQueue.Vt) {
+        GlobalQueue.Vt = e => {
+            e.clear();
+        };
+    }
+    const e = GlobalQueue.dn;
+    GlobalQueue.dn = t => {
+        for (const e of t.cn) {
+            const t = e?.[$TARGET];
+            const n = t?.fam?.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;
+        }
+        return e(t);
+    };
+}
+
+function familyHasLiveOverrides(e) {
+    const t = e.overlaid;
+    if (t === undefined || t.size === 0) return false;
+    for (const e of t) {
+        for (const t of [ e.n, e.h ]) {
+            if (t === null) continue;
+            for (const e of Reflect.ownKeys(t)) {
+                const n = t[e];
+                if (n.o?.De !== undefined && n.o?.De !== NOT_PENDING) return true;
+            }
+        }
+        if (e.k !== null && e.k.o?.De !== undefined && e.k.o?.De !== NOT_PENDING) return true;
+    }
+    t.clear();
+ // nothing live — drop the bookkeeping
+        return false;
+}
+
+function createOptimisticStoreNext(e, t, n) {
+    // Engine first (armed nodes need optimisticWrite installed before any
+    // node exists), then the next-shape hooks.
+    installOptimisticEngine();
+    installNextBlockedHalf();
+    const i = typeof e === "function";
+    if (!i && n === undefined) n = t;
+    const o = i ? t : e;
+    const r = {
+        map: new WeakMap,
+        node: null,
+        shallow: !!n?.shallow,
+        opt: true
+    };
+    const s = wrapNext(o, null, null, r);
+    r.px = s;
+    if (r.shallow) {
+        s[$TARGET].s = true;
+        markRawIngest(o);
+    }
+    if (i) {
+        const t = e;
+        // Async commits land outside the computed's sync body — re-apply the
+        // authoritative-write posture there too. Landings consume the family's
+        // tentative overrides (RUL-2: visible landed truth replaces optimism) —
+        // both the reconcile-channel commit and per-op post-await draft writes.
+                const consume = () => consumeOverridesNext(r);
+        const wrapCommit = e => {
+            runAuthoritative(e);
+            consume();
+        };
+        let i;
+        if (n?.seedLoadingValue) i = {
+            loadingValue: undefined
+        };
+        const o = computed(() => {
+            runAuthoritative(() => runProjectionComputedNext(s, t, n?.key === undefined ? "id" : n.key, wrapCommit, consume));
+        }, i);
+        o.T &= ~CONFIG_AUTO_DISPOSE;
+        r.node = o;
+    }
+    return [ s, e => storeSetterNext(s, e) ];
+}
+
+// ---- optimistic-only store machinery (moved from next/store.ts /
+// next/reconcile.ts so plain-store bundles tree-shake it) ----
+/** Diff the draft against the current OPTIMISTIC VIEW (committed + active
+ * 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
+    // 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?._e) globalQueue.initTransition(n._e);
+    const i = e.v;
+    const visible = (t, n) => {
+        const i = e.n?.[t];
+        return i !== undefined && hasActiveOverride(i) ? unwrapOverride(i.o?.De) : n;
+    };
+    const visiblePresent = t => {
+        const n = e.h?.[t];
+        return n !== undefined && hasActiveOverride(n) ? !!unwrapOverride(n.o?.De) : 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]);
+        if (!visiblePresent(n)) {
+            // Optimistic add: value node + presence node + membership bump.
+            setSignal(getNode(e, n, i[n]), () => s);
+            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 (r) o = true;
+            }
+        }
+    }
+    for (const n of Reflect.ownKeys(i)) {
+        if (r && n === "length") continue;
+        if (n in t || !visiblePresent(n)) continue;
+        // Optimistic delete: node reads undefined, presence flips, membership bumps.
+                setSignal(getNode(e, n, i[n]), () => undefined);
+        setSignal(getHasNode(e, n, true), false);
+        o = true;
+    }
+    if (r) {
+        const n = visible("length", i.length);
+        if (n !== t.length) {
+            setSignal(getNode(e, "length", n), () => t.length);
+            o = true;
+        }
+    }
+    if (o) setSignal(getKeySetNode(e), e => e + 1);
+    // Deep-witness: optimistic value writes notify deep() subscribers too
+    // (structural ones already ride the key-set bump above).
+        bumpDeep(e);
+    // Discard the draft — committed raw is untouched (revert target by
+    // construction). Register the root store for the scheduler's settle hooks
+    // and the target for landing consumption (RUL-2).
+        e.pb = null;
+    (e.fam.overlaid ??= new Set).add(e);
+    GlobalQueue.Nn?.(e.fam.px ?? e.px);
+}
+
+/**
+ * Landing consumption (RUL-2): fresh authoritative data supersedes every
+ * tentative override in the family. Mirrors legacy clearProjectionOverride —
+ * drop the override, clear lane/ownership, notify subscribers whose visible
+ * value changes (reversion effects go to regular queues via the projection
+ * write posture the caller holds).
+ */ function consumeOverridesNext(e) {
+    const t = e.overlaid;
+    if (t === undefined || t.size === 0) return;
+    runAuthoritative(() => {
+        for (const e of t) {
+            const drop = (e, t) => {
+                if (!hasActiveOverride(e)) return;
+                const n = unwrapOverride(e.o?.De);
+                // Full legacy reset (clearOptimisticOverride parity): the landing is
+                // authoritative NOW — fold committed into the node directly instead
+                // of riding a transaction's commit (whose queues may be stashed with
+                // the transaction parked; the wake would strand until it settles).
+                                ext(e).De = NOT_PENDING;
+                e.T |= CONFIG_OPTIMISTIC;
+                const i = e.o;
+                if (i) {
+                    i.Et = null;
+                    i.Be = undefined;
+                }
+                e.Pe = NOT_PENDING;
+                e.be = t;
+                if (!e.Ue || !e.Ue(n, t)) {
+                    insertSubs(e, true);
+                    schedule();
+                }
+            };
+            // Landing consumes STRUCTURAL optimism only (legacy layer parity):
+            // membership edits, array length, and the value overrides written WITH
+            // them (a key carrying an active presence override is an add/delete —
+            // classified BEFORE the adoption may have made the key exist in landed
+            // data). A pure value override on a key the landing carries stays with
+            // its owning transaction (rapid-toggle contract: a live action's edit
+            // of an existing entity rides on top of landed truth).
+                        const t = Array.isArray(e.v);
+            const n = e.h;
+            let i = null;
+            if (n !== null) {
+                for (const e of Reflect.ownKeys(n)) {
+                    if (hasActiveOverride(n[e])) (i ??= new Set).add(e);
+                }
+            }
+            const o = e.n;
+            if (o !== null) {
+                for (const n of Reflect.ownKeys(o)) {
+                    const r = i?.has(n) || !(n in e.v) || t && n === "length";
+                    if (!r) continue;
+                    drop(o[n], t && n === "length" ? e.v.length : e.v[n]);
+                }
+            }
+            if (n !== null) {
+                for (const t of Reflect.ownKeys(n)) drop(n[t], t in e.v);
+            }
+            if (e.k !== null && hasActiveOverride(e.k)) {
+                ext(e.k).De = NOT_PENDING;
+                e.k.T |= CONFIG_OPTIMISTIC;
+                const t = e.k.o;
+                if (t) {
+                    t.Et = null;
+                    t.Be = undefined;
+                }
+                insertSubs(e.k, true);
+                schedule();
+            }
+        }
+        t.clear();
+    });
+}
+
+/** Optimistic-view composition for snapshot/deep (O1: snapshot is the CURRENT
+ * view, lane values included; a fresh copy per call during pending windows —
+ * RUL-12). Returns `src` untouched when no override is active on `t`. */ function optimisticView(e, t) {
+    if (e.fam?.opt !== true) return t;
+    let n = null;
+    const ensure = () => n ??= Array.isArray(t) ? [ ...t ] : {
+        ...t
+    };
+    const i = e.n;
+    if (i !== null) {
+        for (const e of Reflect.ownKeys(i)) {
+            const n = i[e];
+            if (!hasActiveOverride(n)) continue;
+            const o = unwrapOverride(n.o?.De);
+            if (e === "length" && Array.isArray(t)) {
+                if (t.length !== o) ensure().length = o;
+            } else if (!isEqual(t[e], o)) ensure()[e] = o;
+        }
+    }
+    const o = e.h;
+    if (o !== null) {
+        for (const e of Reflect.ownKeys(o)) {
+            const i = o[e];
+            if (!hasActiveOverride(i)) continue;
+            const r = !!unwrapOverride(i.o?.De);
+            if (!r && e in (n ?? t)) delete ensure()[e];
+        }
+    }
+    return n ?? t;
+}
+
+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;
+ // kind change at root: flat overrides below
+        const l = [];
+    const u = s ? [ ...t ] : shallowWithSymbols(t);
+    const match = (e, t) => {
+        if (!isWrappable(e) || !isWrappable(t)) return null;
+        if (rawValuesUsed && (isRawValue(e) || isRawValue(t))) return null;
+        if (Array.isArray(e) !== Array.isArray(t)) return null;
+        if (n) {
+            const i = n(e);
+            const o = n(t);
+            if (i !== undefined && o !== undefined && i !== o) return null;
+        }
+        return r.get(unwrapValue(e)) ?? null;
+    };
+    if (s) {
+        const e = o;
+        let i = null;
+        for (let o = 0; o < t.length; o++) {
+            const r = t[o];
+            if (!isWrappable(r)) continue;
+            let s;
+            if (n) {
+                const t = n(r);
+                if (t !== undefined) {
+                    if (i === null) {
+                        i = new Map;
+                        for (let t = 0; t < e.length; t++) {
+                            const o = unwrapValue(e[t]);
+                            if (isWrappable(o)) {
+                                const e = n(o);
+                                if (e !== undefined && !i.has(e)) i.set(e, o);
+                            }
+                        }
+                    }
+                    s = i.get(t);
+                } else s = unwrapValue(e[o]);
+            } else s = unwrapValue(e[o]);
+            const c = match(s, r);
+            if (c !== null) {
+                // Keep the existing row in the slot (identity preserved); recurse.
+                u[o] = unwrapValue(s);
+                l.push([ c, r ]);
+            }
+        }
+    } else {
+        for (const e of Reflect.ownKeys(t)) {
+            const n = unwrapValue(o[e]);
+            const i = t[e];
+            const r = match(n, i);
+            if (r !== null) {
+                u[e] = n;
+                l.push([ r, i ]);
+            }
+        }
+    }
+    // Flat overrides for this level (adds, removals, moved slots, length, leaf
+    // values) — preserve any live user draft backing across the call.
+        const c = e.pb;
+    e.pb = null;
+    notifyOptimisticWrites(e, u);
+    e.pb = c;
+    for (let e = 0; e < l.length; e++) applyTentative(l[e][0], unwrapValue(l[e][1]), n);
+}
+
+function shallowWithSymbols(e) {
+    const t = {};
+    for (const n of Reflect.ownKeys(e)) t[n] = e[n];
+    return t;
+}
+
+export { consumeOverridesNext, createOptimisticStoreNext, notifyOptimisticWrites, optimisticView };

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

@@ -0,0 +1,172 @@
+import { computed, suppressComputedRecompute } from "../../core/core.js";
+
+import { getOwner } from "../../core/owner.js";
+
+import { setProjectionWriteActive, projectionWriteActive } from "../../core/scheduler.js";
+
+import { handleAsync } from "../../core/async.js";
+
+import "../../core/verdict.js";
+
+import "../../core/effect.js";
+
+import { CONFIG_AUTO_DISPOSE } from "../../core/constants.js";
+
+import { $TARGET, markRawIngest, STORE_VALUE, setWriteOverride } from "../store.js";
+
+import { reconcileNextState } from "./reconcile.js";
+
+import { wrapNext, storeSetterNext } from "./store.js";
+
+/**
+ * Store rewrite — projections (§7/§7b): a projection is a computed store.
+ * The derive runs inside a computed whose recompute merges its output into
+ * the projection's backing through the adoption channel (replace-mode root:
+ * entity changes merge in place, the root proxy is stable for life). Children
+ * wrap into the projection's own FAMILY (writes land here, never in a source
+ * family), and every family node carries the projection computed as its
+ * firewall — reads link the derive's status and lifecycle natively. The §6c
+ * status gate in the traps makes an uninitialized async derive's seed
+ * unobservable through every read surface.
+ *
+ * Mirrors the legacy runProjectionComputed shape (shadow runs for open
+ * loading windows, handleAsync landings, commit-through-setter) on next
+ * primitives; the generic draft write-traps are reused from the legacy
+ * module unchanged.
+ */ function createWriteTraps(e, t) {
+    // Save/restore, never hard-reset: the draft can be driven from inside an
+    // enclosing authoritative-write scope (next-store optimistic derives), and
+    // a hard `false` would clobber it mid-derive.
+    const r = {
+        get(e, t) {
+            let o;
+            const i = projectionWriteActive;
+            setWriteOverride(true);
+            setProjectionWriteActive(true);
+            try {
+                o = e[t];
+            } finally {
+                setWriteOverride(false);
+                setProjectionWriteActive(i);
+            }
+            if (t === $TARGET) return o;
+            return typeof o === "object" && o !== null ? new Proxy(o, r) : o;
+        },
+        has(e, t) {
+            let r;
+            const o = projectionWriteActive;
+            setWriteOverride(true);
+            setProjectionWriteActive(true);
+            try {
+                r = t in e;
+            } finally {
+                setWriteOverride(false);
+                setProjectionWriteActive(o);
+            }
+            return r;
+        },
+        set(r, o, i) {
+            if (e && !e()) return true;
+            const n = projectionWriteActive;
+            setWriteOverride(true);
+            setProjectionWriteActive(true);
+            try {
+                r[o] = i;
+                t?.();
+            } finally {
+                setWriteOverride(false);
+                setProjectionWriteActive(n);
+            }
+            return true;
+        },
+        deleteProperty(r, o) {
+            if (e && !e()) return true;
+            const i = projectionWriteActive;
+            setWriteOverride(true);
+            setProjectionWriteActive(true);
+            try {
+                delete r[o];
+                t?.();
+            } finally {
+                setWriteOverride(false);
+                setProjectionWriteActive(i);
+            }
+            return true;
+        }
+    };
+    return r;
+}
+
+function createProjectionNextInternal(e, t, r) {
+    const o = {
+        map: new WeakMap,
+        node: null,
+        shallow: !!r?.shallow
+    };
+    const i = wrapNext(t, null, null, o);
+    if (o.shallow) {
+        // Shallow projection: the root is the only wrapped level — slot values
+        // serve raw, ingests sticky raw-mark (same t.s machinery as plain).
+        i[$TARGET].s = true;
+        markRawIngest(t);
+    }
+    let n;
+    if (r?.seedLoadingValue) n = {
+        loadingValue: undefined
+    };
+    const c = computed(() => {
+        if (!o.node) o.node = getOwner();
+        runProjectionComputedNext(i, e, r?.key === undefined ? "id" : r.key);
+    }, n);
+    c.T &= ~CONFIG_AUTO_DISPOSE;
+    o.node = c;
+    return {
+        store: i,
+        node: c
+    };
+}
+
+function createProjectionNext(e, t, r) {
+    return createProjectionNextInternal(e, t, r).store;
+}
+
+/** Derived writable store (legacy parity): a projection whose public setter
+ * masks the recompute for the tick (core R31 — the manual write wins over a
+ * same-flush dependency change). */ function createStoreDerivedNext(e, t, r) {
+    const {store: o, node: i} = createProjectionNextInternal(e, t, r);
+    return [ o, e => {
+        // Mark the projection as manually written before notifying nodes.
+        suppressComputedRecompute(i);
+        storeSetterNext(o, e);
+    } ];
+}
+
+function runProjectionComputedNext(e, t, r, o, i) {
+    const n = getOwner();
+    let c = false;
+    let s;
+    // Open loading window (seedLoadingValue): the observable store IS commit #0
+    // for the whole first flight — the derive works a detached shadow of the
+    // seed so draft writes cannot tear through to readers (#2988). Every commit
+    // point reconciles the shadow through the normal commit path.
+        const u = n.Ie ? JSON.parse(JSON.stringify(e[$TARGET][STORE_VALUE])) : null;
+    const l = new Proxy(e, createWriteTraps(() => !c || n.o?.Ee === s, i));
+    storeSetterNext(l, i => {
+        s = t(u ?? i);
+        c = true;
+        const commit = t => {
+            // Shadow run: commit a detached snapshot, never the shadow itself
+            // (adoption takes the value by identity — handing it the live shadow
+            // would fuse the draft to the observable store).
+            if (u && (t === undefined || t === u)) t = JSON.parse(JSON.stringify(u));
+            if (t === i || t === undefined) return;
+            const write = () => storeSetterNext(e, e => reconcileNextState(t, e, r, true), false);
+            o ? o(write) : write();
+        };
+        const l = handleAsync(n, s, commit);
+        if (!n.Ie) commit(l);
+    }, false);
+    return n;
+}
+
+export { createProjectionNext, createStoreDerivedNext, runProjectionComputedNext };