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

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

@@ -1,172 +0,0 @@
-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 };

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

@@ -1,331 +0,0 @@
-import { isEqual } from "../../core/core.js";
-
-import { projectionWriteActive } from "../../core/scheduler.js";
-
-import "../../core/invariants.js";
-
-import "../../core/verdict.js";
-
-import "../../core/effect.js";
-
-import { $TARGET, markRawIngest, isWrappable, rawValuesUsed, isRawValue, getWriteOverride } from "../store.js";
-
-import { materializePB, adoptPB, unwrapValue, notifyFold, targetsEqual, bumpDeep, notifyKeyValue, notifyKeyDiff, notifyFoldTail, hasAccessorFlag } from "./store.js";
-
-import { storeNextLookup, optHooks, ownedRaw } from "./target.js";
-
-/**
- * Store rewrite — reconcile, the adoption channel (INTERNALS-STORE-STATE.md
- * §3, decision 2026-08-16c). Reconcile never merge-writes: it adopts `next`
- * as the authoritative pending backing at every proxied level (pointer swap
- * folded at flush commit), notification riding the fold's descriptor diff.
- *
- * Structural optimizations (all kept, per 2026-08-17 morning ruling):
- * - Identity skip with completed proof: `incoming === backing && !owned` —
- *   sound because input is immutable by convention (R2a) and ownership marks
- *   the only writer the convention doesn't cover (us). Fixes FINDING-1.
- * - Reachability pruning: descent happens only where a child TARGET exists
- *   (proxies exist only where read) — never-subscribed subtrees are never
- *   walked (recon-snap R17), while a subscriber deep below an untracked path
- *   keeps its chain walkable because wrapping created the intermediate
- *   targets (recon-snap R16).
- * - Keyed matching ported semantics: key-matched rows keep proxy identity;
- *   key mismatch detaches (fresh proxy on next read, recon-snap R18);
- *   keyless items fall back positional; null/primitive slots are legal
- *   members (R11). Kind changes replace wholesale (R10).
- */ function reconcileNextState(e, t, n, o = false) {
-    if (t == null) throw new Error("");
-    const l = t?.[$TARGET];
-    if (l === undefined || l.px !== t) throw new Error("");
-    // Reconcile's diff walks need a REAL pending container — a prototype
-    // overlay (#3044) materializes to the clone path first (edge: reconcile
-    // inside a setter that already wrote this target).
-        if (l.ovl) materializePB(l);
-    let f = n === null ? null : typeof n === "string" ? e => e?.[n] : n;
-    // §7b chained backing: a projection derive returning a LIVE store proxy
-    // adopts the proxy itself as the backing — reads flow through the inner
-    // store's traps, so consumers subscribe to the inner graph and updates
-    // flow with no re-derive (#2941). The adoption diff still notifies THIS
-    // store's existing subscribers of the swap.
-        if (o && e !== t && e?.[$TARGET] !== undefined) {
-        const t = l.pb ?? l.v;
-        if (t === e) return;
- // already chained to this store
-                adoptPB(l, e);
-        return;
-    }
-    const i = unwrapValue(e);
-    if (f) {
-        // Root identity precondition — checked before ANY mutation, so a throwing
-        // reconcile is atomic by construction (RUL-12 ruling). Projections
-        // (replace=true) relax it: a root entity change merges in place — the
-        // root proxy is stable for life (proj R5/R11) — and children are NOT
-        // key-matched across the entity change (proj R7: keyFn drops to
-        // positional so old-entity subtrees never merge into the new entity's).
-        const e = l.pb ?? l.v;
-        const t = f(e);
-        if (t !== undefined && f(i) !== t) {
-            if (!o) throw new Error("");
-            // Entity change: wholesale swap. The root proxy is stable for life
-            // (proj R5) but NOTHING below survives — children are never matched
-            // across an entity change even when their own keys align (proj R7).
-            // Displaced-raw unregistration (proj R10): the outgoing raw stops
-            // resolving to this proxy; re-handed later it wraps fresh.
-                        (l.fam?.map ?? storeNextLookup).delete(l.pb ?? l.v);
-            adoptPB(l, i);
-            return;
-        }
-    }
-    // Tentative channel (§6b, RUL-5): a user-context reconcile on an optimistic
-    // family parks as engine overrides — values, membership, and length ride
-    // armed nodes (reverting with their transaction); committed raw is never
-    // touched. Key-matched rows keep proxy identity by descending into the
-    // existing child targets instead of overriding their parent slots.
-        if (l.fam?.opt === true && !projectionWriteActive && !getWriteOverride()) {
-        optHooks.applyTentative(l, i, f);
-        return;
-    }
-    applyAdopt(l, i, f, o);
-}
-
-function applyAdopt(e, t, n, o = false) {
-    const l = e.pb ?? e.v;
-    // The sound identity skip (O7): same reference AND we never diverged it.
-        if (t === l && !ownedRaw.has(l)) return;
-    const f = e.fam;
-    // §6b (R28): the diff's previous-arrangement baseline is the LANE VIEW —
-    // optimistic rows must be visible to key matching so a landing carrying the
-    // same key recycles their proxies. Raw `prev` keeps the identity/ownership
-    // roles above; only matching reads the view.
-        const i = f?.opt === true ? optHooks.optimisticView(e, l) : l;
-    const r = Array.isArray(t);
-    // Plain stores notify inline AFTER the descent (child registrations feed
-    // the fold diff's identity-preservation check); projections keep deferred
-    // folds (downstream holds can form later in the flush).
-        const u = f === null;
-    const s = e.s === true;
-    const a = e.v;
-    adoptPB(e, t, u);
-    // Shallow adoption: records are slot values — sticky raw-mark the incoming
-    // set (R41) and never descend; slot notification is the positional diff.
-        if (s) markRawIngest(t);
-    if (Array.isArray(i) !== r) {
-        if (u) notifyFold(e, a, t);
-        return;
-    }
-    if (r) {
-        const l = i;
-        const r = t;
-        // Fused array walk (eager mode): per-index notification rides the same
-        // loop as the descent (descend first — targetsEqual needs the child's
-        // re-registration, R9). Length, trailing removed indexes, and any other
-        // unvisited node keys land in the counted sweep below.
-                const c = u ? e.n : null;
-        let p = 0;
-        if (n && !s) {
-            // Positional-prefix fast path (legacy keyedMatch-walk parity): while
-            // rows key-match in place — the steady-state polling shape — descend
-            // directly with zero staging. The prevByKey map is built only for the
-            // misaligned remainder, and never at all on aligned ticks.
-            const i = l.length;
-            const u = r.length;
-            let s = false;
-            let d = 0;
-            for (const y = Math.min(i, u); d < y; d++) {
-                const i = r[d];
-                const u = l[d];
-                // Routing heuristic only (aligned vs keyed remainder) — both routes
-                // notify identically and descend() is the one authoritative
-                // validator, so bare typeof gates suffice here; full isWrappable
-                // per row was the walk's dominant residual cost.
-                                if (u !== i && !(u !== null && typeof u === "object" && i !== null && typeof i === "object" && n(u) === n(i))) break;
- // misaligned: fall to the keyed remainder below
-                // Identity skip inline (FINDING-1 guard), then descend the pair.
-                                if ((u !== i || i !== null && typeof i === "object" && ownedRaw.has(i)) && i !== null && typeof i === "object") descend(unwrapValue(u), i, n, f, o);
-                if (e.dk !== null && !s && !(i !== null && typeof i === "object" ? targetsEqual(u, i) : isEqual(u, i))) {
-                    bumpDeep(e);
-                    s = true;
-                }
-                if (c !== null) {
-                    const e = c[d];
-                    if (e !== undefined) {
-                        p++;
-                        notifyKeyValue(e, d, a[d], i, a, t);
-                    }
-                }
-            }
-            if (e.dk !== null && !s && d < r.length) bumpDeep(e);
-            let y = null;
-            for (;d < r.length; d++) {
-                const e = r[d];
-                // typeof gates route; descend validates (same contract as the prefix).
-                                if (e !== null && typeof e === "object") {
-                    const t = n(e);
-                    let i;
-                    if (t !== undefined) {
-                        if (y === null) {
-                            y = new Map;
-                            for (let e = 0; e < l.length; e++) {
-                                const t = unwrapValue(l[e]);
-                                if (t !== null && typeof t === "object") {
-                                    const e = n(t);
-                                    if (e !== undefined && !y.has(e)) y.set(e, t);
-                                }
-                            }
-                        }
-                        i = y.get(t);
-                    } else {
-                        i = unwrapValue(l[d]);
- // keyless item: positional fallback
-                                        }
-                    descend(i, e, n, f, o);
-                }
-                if (c !== null) {
-                    const e = c[d];
-                    if (e !== undefined) {
-                        p++;
-                        notifyKeyDiff(e, d, a, t, false);
-                    }
-                }
-            }
-        } else {
-            const i = Math.min(l.length, r.length);
-            const u = r.length;
-            let d = false;
-            for (let y = 0; y < u; y++) {
-                const u = r[y];
-                if (!s && y < i && u !== null && typeof u === "object") descend(unwrapValue(l[y]), u, n, f, o);
-                if (e.dk !== null && !d && !(u !== null && typeof u === "object" ? targetsEqual(l[y], u) : isEqual(l[y], u))) {
-                    bumpDeep(e);
-                    d = true;
-                }
-                if (c !== null) {
-                    const e = c[y];
-                    if (e !== undefined) {
-                        p++;
-                        notifyKeyDiff(e, y, a, t, false);
-                    }
-                }
-            }
-        }
-        if (u) {
-            if (c !== null && p < e.nc) {
-                for (const e of Reflect.ownKeys(c)) {
-                    // visited indexes are < nextRows.length; everything else sweeps
-                    const n = typeof e === "string" ? +e : NaN;
-                    if (!(n >= 0 && n < r.length)) notifyKeyDiff(c[e], e, a, t, false);
-                }
-            }
-            notifyFoldTail(e, a, t);
-        }
-        return;
-    } else {
-        // FUSED adoption walk (eager mode): one pass fetches each key's pair,
-        // descends, then notifies its node inline — descend runs FIRST so the
-        // child's re-registration is visible to targetsEqual (identity-preserved
-        // slots must not notify, R9). This replaces the notifyFold re-walk that
-        // doubled dbmon's diff cost. for-in covers own enumerable string keys
-        // with no key-array allocation; symbols get a pass only when present.
-        const l = u ? e.n : null;
-        let r = 0;
-        let c = false;
-        // The per-key body is inlined on purpose (legacy applyStateFast parity:
-        // an extracted helper costs a call per key on the hottest object-diff
-        // site). Reference-identical values early-continue BEFORE any other
-        // work — sound only with the ownership guard (FINDING-1: an owned
-        // backing is setter-diverged and must still diff).
-                for (const u in t) {
-            const p = t[u];
-            const d = a[u];
-            const y = p !== null && typeof p === "object";
-            if (d === p && (!y || !ownedRaw.has(p)) && (l === null || l[u] === undefined || !hasAccessorFlag(l[u]))) {
-                if (l !== null && l[u] !== undefined) r++;
-                continue;
-            }
-            if (y && !s) descend(unwrapValue(i[u]), p, n, f, o);
-            // Deep-witness (dk): value changes must notify even with NO per-key
-            // node — deep() subscribes one node per record. Checked after descend
-            // so in-place adoptions (same logical slot) don't bump; child records
-            // carry their own witness. One flag + null check when unused.
-                        if (e.dk !== null && !c && !(y ? targetsEqual(d, p) : isEqual(d, p))) {
-                bumpDeep(e);
-                c = true;
-            }
-            if (l !== null) {
-                const e = l[u];
-                if (e !== undefined) {
-                    r++;
-                    notifyKeyValue(e, u, d, p, a, t);
-                }
-            }
-        }
-        const p = Object.getOwnPropertySymbols(t);
-        for (let e = 0; e < p.length; e++) {
-            const u = p[e];
-            const c = t[u];
-            if (!s && c !== null && typeof c === "object") descend(unwrapValue(i[u]), c, n, f, o);
-            if (l !== null) {
-                const e = l[u];
-                if (e !== undefined) {
-                    r++;
-                    notifyKeyValue(e, u, a[u], c, a, t);
-                }
-            }
-        }
-        if (u) {
-            // Deleted-key nodes (in the map but absent from incoming) — counted
-            // fast-out: when every node was visited, skip the sweep entirely.
-            if (l !== null && r < e.nc) {
-                for (const e of Reflect.ownKeys(l)) {
-                    if (!hasOwnP.call(t, e)) notifyKeyDiff(l[e], e, a, t, false);
-                }
-            }
-            notifyFoldTail(e, a, t);
-        }
-        return;
-    }
-}
-
-const hasOwnP = Object.prototype.hasOwnProperty;
-
-function descend(e, t, n, o, l = false) {
-    if (e === null || typeof e !== "object" || t === null || typeof t !== "object") return;
-    // Lookup FIRST: a hit implies pv was wrappable and never raw-marked (only
-    // wrappables acquire targets; rawValues never wrap) — one WeakMap get
-    // replaces isWrappable(pv) + isRawValue(pv), and a miss prunes untracked
-    // subtrees before any further checks.
-        const f = (o?.map ?? storeNextLookup).get(e);
-    if (f === undefined) return;
- // nothing proxied below this pair
-    // The NEW side still validates fully: a frozen/platform/markRaw'd incoming
-    // value is a leaf for reconcile — replaced by reference, never recursed
-    // into (R42); the parent's slot notification covers the change.
-        if (!isWrappable(t)) return;
-    if (rawValuesUsed && isRawValue(t)) return;
-    t = unwrapValue(t);
-    // Kind change replaces wholesale, never merges (R10): a target's carrier
-    // class (array vs object) is fixed at creation, so the slot detaches and a
-    // fresh proxy of the right kind wraps the incoming value on next read.
-        if (Array.isArray(e) !== Array.isArray(t)) return;
-    if (n) {
-        const o = n(e);
-        const l = n(t);
-        // Key mismatch detaches: the slot takes the new entity; the old proxy
-        // keeps its (old) backing and a fresh proxy wraps the new value on read.
-                if (o !== undefined && l !== undefined && o !== l) return;
-    }
-    // Reachability pruning (§6d) is MODE-dependent, both pinned:
-    // - keyed matching descends only where subscriptions exist at/below (`d`) —
-    //   captured-but-unobserved proxies deliberately detach and go stale
-    //   (recon-snap R18; subscribing is what buys liveness);
-    // - positional (key: null) pairing preserves slot identity unconditionally
-    //   (recon-snap R8 — the fixed-shape dashboard pattern).
-    // Projection merges (replace mode) preserve key-matched identity
-    // UNCONDITIONALLY (proj R6: the slot keeps its proxy without needing a
-    // subscriber below); plain keyed reconcile detaches unobserved captures
-    // (recon-snap R18 — staleness is the pinned pruning contract).
-        if (!l && n !== null && !f.d) return;
-    applyAdopt(f, t, n, l);
-}
-
-export { reconcileNextState };