@solidjs/signals 2.0.0-beta.18 → 2.0.0-beta.20

package/dist/prod/store/store.js

@@ -0,0 +1,870 @@
+import { $REFRESH, STORE_SNAPSHOT_PROPS, NOT_PENDING, unwrapOverride, STATUS_UNINITIALIZED, STATUS_PENDING, NO_SNAPSHOT } from "../core/constants.js";
+
+import { suppressComputedRecompute, isEqual, signal, pendingCheckActive, untrack, setSignal, read, snapshotCaptureActive, snapshotSources } from "../core/core.js";
+
+import { DEV } from "../core/dev.js";
+
+import { NotReadyError } from "../core/error.js";
+
+import { getObserver } from "../core/owner.js";
+
+import { GlobalQueue, registerTransientStoreNode, projectionWriteActive, activeTransition, globalQueue } from "../core/scheduler.js";
+
+import "../core/invariants.js";
+
+import "../core/verdict.js";
+
+import "../core/effect.js";
+
+import { createProjectionInternal } from "./projection.js";
+
+/**
+ * Brand symbols used internally by the store proxy / projection plumbing.
+ * Cross-package wiring; not part of the user-facing API.
+ *
+ * @internal
+ */ const $TRACK = Symbol(0), $TARGET = Symbol(0), $PROXY = Symbol(0), $DELETED = Symbol(0), 
+// Node-map slot carrying a record-level `affects()` mark: any read through
+// the record witnesses it into the active isPending() probe.
+$AFFECTS = Symbol(0);
+
+const STORE_VALUE = "v", STORE_OVERRIDE = "o", STORE_OPTIMISTIC_OVERRIDE = "x", STORE_NODE = "n", STORE_HAS = "h", STORE_CUSTOM_PROTO = "c", STORE_WRAP = "w", STORE_LOOKUP = "l", STORE_FIREWALL = "f", STORE_OPTIMISTIC = "p", STORE_OPTIMISTIC_OWNERS = "t", STORE_PARENT = "u", STORE_DESC = "d";
+
+const STORE_SELF_PENDING = Symbol(0);
+
+function createStoreProxy(e, t = storeTraps, r) {
+    let n;
+    if (Array.isArray(e)) {
+        n = [];
+        n.v = e;
+    } else {
+        n = {
+            v: e
+        };
+        const t = e?.[$TARGET]?.[STORE_VALUE] ?? e;
+        const r = Object.getPrototypeOf(t);
+        if (r !== null && r !== Object.prototype) {
+            n[STORE_CUSTOM_PROTO] = true;
+        }
+    }
+    r && r(n);
+    return n[$PROXY] = new Proxy(n, t);
+}
+
+const storeLookup = new WeakMap;
+
+// Node records that hold at least one user (non-`$TRACK`) symbol-keyed node.
+// Lets reconcile enumerate symbols only for records that need it (#2851).
+const symbolKeyedRecords = new WeakSet;
+
+function wrap(e, t) {
+    if (t?.[STORE_WRAP]) {
+        const r = t[STORE_WRAP](e, t);
+        const n = r[$TARGET];
+        if (n && !n[STORE_PARENT] && n !== t) n[STORE_PARENT] = t;
+        return r;
+    }
+    let r = e[$PROXY] || storeLookup.get(e);
+    if (!r) {
+        storeLookup.set(e, r = createStoreProxy(e));
+        if (t) r[$TARGET][STORE_PARENT] = t;
+    }
+    return r;
+}
+
+function isWrappable(e) {
+    if (e == null || typeof e !== "object" || Object.isFrozen(e)) return false;
+    // Dynamic Node check (kept dynamic so test/SSR overrides of `globalThis.Node`
+    // are observed at call time).
+        return typeof Node === "undefined" || !(e instanceof Node);
+}
+
+let writeOverride = false;
+
+function setWriteOverride(e) {
+    writeOverride = e;
+}
+
+function writeOnly(e) {
+    return writeOverride || !!Writing?.has(e);
+}
+
+function unwrapStoreValue(e, t, r) {
+    const n = e?.[$TARGET] || r?.get(e)?.[$TARGET];
+    if (!n) return e;
+    const o = n[STORE_OVERRIDE];
+    if (!o) return n[STORE_VALUE];
+    if (!t) t = new Map;
+    if (t.has(e)) return t.get(e);
+    const i = n[STORE_VALUE];
+    const s = Array.isArray(i);
+    const E = s ? [] : Object.create(Object.getPrototypeOf(i));
+    t.set(e, E);
+    r = n[STORE_LOOKUP] ?? storeLookup;
+    for (const e of getStoreKeys(i, o)) {
+        if (s && e === "length") continue;
+        const n = e in o ? o[e] : i[e];
+        if (n !== $DELETED) E[e] = unwrapStoreValue(n, t, r);
+    }
+    if (s) E.length = o.length ?? i.length;
+    return E;
+}
+
+function isPrototypePollutionKey(e) {
+    return e === "__proto__" || e === "constructor" || e === "prototype";
+}
+
+// Own enumerable keys including symbols (`Object.keys` drops symbol-keyed props). #2769
+function ownEnumerableKeys(e) {
+    return Reflect.ownKeys(e).filter(t => Object.prototype.propertyIsEnumerable.call(e, t));
+}
+
+function ownEnumerableSymbols(e) {
+    const t = Object.getOwnPropertySymbols(e);
+    const r = [];
+    for (let n = 0, o = t.length; n < o; n++) {
+        const o = t[n];
+        if (Object.prototype.propertyIsEnumerable.call(e, o)) r.push(o);
+    }
+    return r;
+}
+
+// Plain-object variant that keeps Object.keys() as the fast path and only pays
+// descriptor checks for symbols. Do not use this on store proxies: splitting
+// strings/symbols would invoke their ownKeys trap twice.
+function ownEnumerableKeysPlain(e) {
+    return Object.keys(e).concat(ownEnumerableSymbols(e));
+}
+
+/**
+ * Single chokepoint for the store's layered value resolution: returns the
+ * override layer (optimistic first, then regular) that shadows `property`, or
+ * `undefined` when the base `STORE_VALUE` is authoritative. Every trap must
+ * resolve through this — hand-inlining the layer order is how the optimistic
+ * layer gets missed (#2850).
+ */ function getOverlayLayer(e, t) {
+    const r = e[STORE_OPTIMISTIC_OVERRIDE];
+    if (r && t in r) return r;
+    const n = e[STORE_OVERRIDE];
+    if (n && t in n) return n;
+    return undefined;
+}
+
+/**
+ * The value a store leaf's backing signal currently shows to readers: active
+ * override, else held pending value, else committed value.
+ */ function visibleNodeValue(e) {
+    return e.be !== undefined && e.be !== NOT_PENDING ? unwrapOverride(e.be) : e.ge !== NOT_PENDING ? e.ge : e.Ue;
+}
+
+function hasOwnStoreProperty(e, t) {
+    // Override layers are null-prototype objects, so `in` is an own check.
+    const r = getOverlayLayer(e, t);
+    if (r) return r[t] !== $DELETED;
+    return Object.prototype.hasOwnProperty.call(unwrapStoreValue(e[STORE_VALUE]), t);
+}
+
+function hasInheritedAccessor(e, t) {
+    let r = Object.getPrototypeOf(e);
+    while (r && r !== Object.prototype) {
+        const e = Reflect.getOwnPropertyDescriptor(r, t);
+        if (e) return !!e.get;
+        r = Object.getPrototypeOf(r);
+    }
+    return false;
+}
+
+function getNodes(e, t) {
+    let r = e[t];
+    if (!r) e[t] = r = Object.create(null);
+    return r;
+}
+
+function getNode(e, t, r, n, o = isEqual, i) {
+    if (t[r]) return t[r];
+    const s = signal(n, {
+        equals: o,
+        unobserved() {
+            if (t[r] === s) {
+                delete t[r];
+                // Drop the symbol-record mark once the last user symbol node is
+                // gone, so reconcile's fast path stops probing a now string-only
+                // record. Runs only on symbol-node cleanup (cold), never on reconcile.
+                                if (typeof r === "symbol" && r !== $TRACK && r !== $AFFECTS && symbolKeyedRecords.has(t)) {
+                    const e = Object.getOwnPropertySymbols(t);
+                    let r = false;
+                    for (let t = 0, n = e.length; t < n; t++) {
+                        if (e[t] !== $TRACK && e[t] !== $AFFECTS) {
+                            r = true;
+                            break;
+                        }
+                    }
+                    if (!r) symbolKeyedRecords.delete(t);
+                }
+            }
+        }
+    }, e[STORE_FIREWALL]);
+    if (e[STORE_OPTIMISTIC]) {
+        s.be = NOT_PENDING;
+    }
+    if (i && r in i) {
+        const e = i[r];
+        s.Ye = e === undefined ? NO_SNAPSHOT : e;
+        snapshotSources?.add(s);
+    }
+    if (typeof r === "symbol" && r !== $TRACK && r !== $AFFECTS) symbolKeyedRecords.add(t);
+    // A node born inside a live mark's identity scope inherits the mark
+    // (the declaration walk could only cover nodes that existed then). The
+    // record's own $AFFECTS carrier is the mark's channel, never a member.
+        if (r !== $AFFECTS && affectsScopes.size) inheritAffectsMarks(s, e[STORE_VALUE], r);
+    // Node presence bubbles up the wrap chain (sticky), so reconcile can see
+    // "subscribers live somewhere below" through node-less intermediate
+    // records — the captured-proxy diff gate (#2902). Amortized O(1): stops at
+    // the first already-flagged ancestor.
+        let E = e;
+    while (E && !E[STORE_DESC]) {
+        E[STORE_DESC] = true;
+        E = E[STORE_PARENT];
+    }
+    return t[r] = s;
+}
+
+/**
+ * Scope inheritance for late-created nodes: every live mark whose identity
+ * scope contains the owning record's raw — and, for keyed marks, whose key
+ * is this property — gets counted on the new node. Inherited marks live
+ * exactly as long as the scope's carrier — the release hook below drops
+ * them with the entry.
+ */ function inheritAffectsMarks(e, t, r) {
+    // A live scope exists, so affects.ts already installed the mark engine.
+    for (const [n, o] of affectsScopes) {
+        if (n.M && o.scope.has(t) && (o.key === undefined || o.key === r)) {
+            GlobalQueue.D(e);
+            o.inherited.push(e);
+        }
+    }
+}
+
+const affectsScopes = new Map;
+
+/**
+ * Snapshots the identities reachable from `value` into `scope`, reading
+ * through write overlays (an optimistic row pushed before the declaration is
+ * in motion too). Untracked by construction: walks raw values, never traps.
+ * Every LIVE node under each reachable record — property leaves, `$TRACK`,
+ * and has-nodes — collects into `found`: those are the graph edges existing
+ * readers subscribed through, so the mark registers on them directly and
+ * rides the status rails to everything derived. (Nodes born later inherit
+ * from the scope in `getNode`.)
+ */ function walkAffectsScope(e, t, r, n, 
+// Cycle guard, fresh per declaration: the scope itself can't serve — a
+// re-declaration on the same carrier unions into a scope that already
+// holds the root, and must still descend to pick up records added since.
+o) {
+    if (!isWrappable(e)) return;
+    const i = e[$TARGET] || (n ?? storeLookup).get(e)?.[$TARGET];
+    const s = i ? i[STORE_VALUE] : e;
+    if (o.has(s)) return;
+    o.add(s);
+    t.scope.add(s);
+    let E;
+    if (i) {
+        collectRecordNodes(i[STORE_NODE], r);
+        collectRecordNodes(i[STORE_HAS], r);
+        E = mergedOverlay(i);
+        // Carry the effective lookup into untouched descendants. Default stores
+        // use the global lookup just like snapshotImpl; without it, nested raw
+        // objects fall back to string-only enumeration and symbol branches vanish.
+                n = i[STORE_LOOKUP] ?? n ?? storeLookup;
+    }
+    if (Array.isArray(s)) {
+        const e = E?.length ?? s.length;
+        for (let i = 0; i < e; i++) {
+            const e = E && i in E ? E[i] : s[i];
+            if (e !== $DELETED) walkAffectsScope(e, t, r, n, o);
+        }
+        // Arrays can also carry symbol metadata. Enumerate symbols separately to
+        // avoid scanning large index lists twice. Outside a store tree, retain the
+        // existing index-only walk.
+                const O = i || n ? getStoreSymbols(s, E) : [];
+        for (let e = 0, i = O.length; e < i; e++) {
+            const i = O[e];
+            const c = getPropertyDescriptor(s, E, i);
+            if (!c || c.get) continue;
+            walkAffectsScope(c.value, t, r, n, o);
+        }
+    } else {
+        const e = i || n ? getStoreKeys(s, E) : getKeys(s, E);
+        for (let i = 0, O = e.length; i < O; i++) {
+            const O = getPropertyDescriptor(s, E, e[i]);
+            if (!O || O.get) continue;
+            walkAffectsScope(O.value, t, r, n, o);
+        }
+    }
+}
+
+/** All live signal nodes of one record's node map (string + symbol keyed). */ function collectRecordNodes(e, t) {
+    if (!e) return;
+    for (const r of Object.keys(e)) t.push(e[r]);
+    const r = Object.getOwnPropertySymbols(e);
+    for (let n = 0, o = r.length; n < o; n++) {
+        // Another mark's carrier is its own channel — counting it here would
+        // extend that sibling scope's lifetime to this declaration's.
+        if (r[n] !== $AFFECTS) t.push(e[r[n]]);
+    }
+}
+
+/**
+ * Witness live mark coverage of a record into the active isPending() probe.
+ * Tracked reads don't need this — they go through real signal nodes, which
+ * carry marks directly (declaration walk or birth inheritance). This covers
+ * UNTRACKED probes reading through records whose nodes never materialized
+ * (no observer ever subscribed, so no node exists to carry the mark).
+ * Callers guard on `pendingCheckActive`, so plain reads never pay for this.
+ *
+ * @internal
+ */ function witnessAffectsMark(e, t) {
+    // Callers guard on `pendingCheckActive`, which only flips inside
+    // isPending() — the verdict layer is loaded and its hook installed.
+    const r = e[STORE_NODE]?.[$AFFECTS];
+    if (r?.M) GlobalQueue.wt(r);
+    if (affectsScopes.size) {
+        const n = e[STORE_VALUE];
+        for (const [e, o] of affectsScopes) {
+            if (e !== r && e.M && o.scope.has(n) && (o.key === undefined || o.key === t)) GlobalQueue.wt(e);
+        }
+    }
+}
+
+/**
+ * Resolves the store nodes an `affects()` declaration marks: with a `key`,
+ * the named slot's leaf node (upserted so the mark has an addressable
+ * carrier); without, the record's $AFFECTS carrier plus every LIVE node in
+ * its subtree (the edges existing readers subscribed through), with the
+ * subtree's identities snapshotted into the mark's scope so nodes created
+ * during the window — and untracked probes over captured proxies — resolve
+ * against it (#2882).
+ *
+ * @internal
+ */ function getStoreAffectsNodes(e, t) {
+    const r = getNodes(e, STORE_NODE);
+    GlobalQueue.T ||= e => {
+        const t = affectsScopes.get(e);
+        if (!t) return;
+        affectsScopes.delete(e);
+        for (let e = 0; e < t.inherited.length; e++) GlobalQueue.F(t.inherited[e]);
+    };
+    if (t === undefined) {
+        const t = getNode(e, r, $AFFECTS, undefined, false);
+        let n = affectsScopes.get(t);
+        if (!n) affectsScopes.set(t, n = {
+            scope: new Set,
+            inherited: []
+        });
+        const o = [ t ];
+        walkAffectsScope(e[$PROXY], n, o, e[STORE_LOOKUP], new Set);
+        return o;
+    }
+    let n = r[t];
+    if (!n) {
+        const o = getOverlayLayer(e, t);
+        const i = o ? o[t] : e[STORE_VALUE][t];
+        n = upsertStoreNode(e, r, t, i === $DELETED ? undefined : i, e[STORE_SNAPSHOT_PROPS]);
+    }
+    // Keyed marks resolve by identity too (#2904): another store family's
+    // proxy can share this record's raw (a derived store swaps its backing to
+    // the source's raw when its projection lands), and reads through it never
+    // touch this target's node map. Scope is exactly the owning record's raw,
+    // narrowed to this key for witness and birth inheritance.
+        let o = affectsScopes.get(n);
+    if (!o) affectsScopes.set(n, o = {
+        scope: new Set,
+        inherited: [],
+        key: t
+    });
+    o.scope.add(e[STORE_VALUE]);
+    return [ n ];
+}
+
+function trackSelf(e, t = $TRACK) {
+    if (!getObserver()) return;
+    read(getNode(e, getNodes(e, STORE_NODE), t, undefined, false));
+    // Store-in-store: structural notifications (reconcile, notifySelf) land on
+    // the wrapped source's own self-node, never on this wrapper view's. Chain
+    // the read through so enumeration/$TRACK on the wrapper observes them
+    // (#2864). Property reads already chain naturally via the inner get trap.
+    // An override layer on the view is a hold (A17) — the shown structure is
+    // the overlay's, so don't subscribe through it; clearing the layer notifies
+    // this view's own self-node and the re-run re-establishes the chain.
+        if (t === $TRACK && !e[STORE_OVERRIDE] && !e[STORE_OPTIMISTIC_OVERRIDE] && e[STORE_VALUE][$TARGET]) e[STORE_VALUE][$TRACK];
+}
+
+function notifySelf(e) {
+    const t = e[STORE_NODE]?.[$TRACK];
+    t && setSignal(t, e[STORE_OPTIMISTIC] && !projectionWriteActive ? STORE_SELF_PENDING : undefined);
+}
+
+/**
+ * The write overlay a walk must read through: optimistic writes shadow
+ * regular pending writes, the same resolution order as every proxy trap and
+ * `reconcile` (#2850). Merging allocates only in the rare both-present case
+ * (a derived optimistic store with an in-flight projection commit).
+ */ function mergedOverlay(e) {
+    const t = e[STORE_OVERRIDE];
+    const r = e[STORE_OPTIMISTIC_OVERRIDE];
+    return t && r ? {
+        ...t,
+        ...r
+    } : r ?? t;
+}
+
+function getKeysImpl(e, t, r, n) {
+    // Plain objects can't trigger proxy traps — only pay for the untrack
+    // closure when the source is itself a wrapped store (store-in-store).
+    const o = e[$TARGET] ? untrack(() => r ? n ? ownEnumerableKeys(e) : Object.keys(e) : Reflect.ownKeys(e)) : r ? n ? ownEnumerableKeysPlain(e) : Object.keys(e) : Reflect.ownKeys(e);
+    return t ? mergeOverrideKeys(o, t) : o;
+}
+
+function getKeys(e, t, r = true) {
+    return getKeysImpl(e, t, r, false);
+}
+
+function getStoreKeys(e, t) {
+    return getKeysImpl(e, t, true, true);
+}
+
+function getStoreSymbols(e, t) {
+    const r = e[$TARGET] ? untrack(() => ownEnumerableSymbols(e)) : ownEnumerableSymbols(e);
+    return t ? mergeOverrideKeys(r, t, true) : r;
+}
+
+// Shared override-layer merge for key enumeration: adds live override keys,
+// drops $DELETED ones. `symbolsOnly` scopes the override scan for the
+// array-metadata passes.
+function mergeOverrideKeys(e, t, r) {
+    const n = new Set(e);
+    const o = r ? Object.getOwnPropertySymbols(t) : Reflect.ownKeys(t);
+    for (const e of o) {
+        if (t[e] !== $DELETED) n.add(e); else n.delete(e);
+    }
+    return Array.from(n);
+}
+
+function getPropertyDescriptor(e, t, r) {
+    if (t && r in t) {
+        if (t[r] === $DELETED) return void 0;
+        const n = Reflect.getOwnPropertyDescriptor(t, r);
+        if (n?.get || n?.set) return n;
+        // Plain writes live in the override while the source keeps its old value.
+        // Preserve the source descriptor flags, but report the current override
+        // value. Source accessors cannot be patched with a value, and inherited
+        // properties have no source own descriptor, so those keep their descriptor.
+                const o = Reflect.getOwnPropertyDescriptor(e, r);
+        if (!o) return n;
+        if (o.get || o.set) return o;
+        // Reflect returns a fresh descriptor, so patching in place is safe and
+        // avoids an allocation on Object.keys/spread over written stores.
+                o.value = t[r];
+        return o;
+    }
+    return Reflect.getOwnPropertyDescriptor(e, r);
+}
+
+function prepareStoreWrite(e, t, r) {
+    if (e[STORE_OPTIMISTIC]) {
+        const t = e[STORE_FIREWALL];
+        if (t?.ve) {
+            globalQueue.initTransition(t.ve);
+        }
+    }
+    const n = e[STORE_VALUE];
+    const o = n[r];
+    if (snapshotCaptureActive && typeof r !== "symbol" && !((e[STORE_FIREWALL]?.i ?? 0) & STATUS_PENDING)) {
+        if (!e[STORE_SNAPSHOT_PROPS]) {
+            e[STORE_SNAPSHOT_PROPS] = Object.create(null);
+            snapshotSources?.add(e);
+        }
+        if (!(r in e[STORE_SNAPSHOT_PROPS])) {
+            e[STORE_SNAPSHOT_PROPS][r] = o;
+        }
+    }
+    const i = e[STORE_OPTIMISTIC] && !projectionWriteActive;
+    const s = i ? STORE_OPTIMISTIC_OVERRIDE : STORE_OVERRIDE;
+    return {
+        base: o,
+        overrideKey: s,
+        state: n
+    };
+}
+
+/**
+ * Registers the store for transition reversion. Called only once a write is
+ * known to be effective — ineffective writes (same value, delete of an absent
+ * property) are no-ops and must not entangle the store. Optimistic writes are
+ * verdict-inert (question-scoped pending model): no mask is armed — the write
+ * neither pends its own slot nor silences anyone else's.
+ */ function armOptimisticStoreWrite(e, t) {
+    // STORE_OPTIMISTIC is only set by createOptimisticStore, which installs the
+    // optimistic engine before wrapping.
+    if (e[STORE_OPTIMISTIC] && !projectionWriteActive) {
+        GlobalQueue.mn(t);
+    }
+}
+
+/**
+ * Records which transition owns an optimistic layer entry (#2899), so a
+ * settling action only consumes its own keys — the layer is store-wide, but
+ * concurrent actions writing disjoint keys must revert independently, exactly
+ * like optimistic signal nodes do via the transition's _optimisticNodes.
+ * `activeTransition` is the write's transaction (action() opens it before the
+ * body runs); null marks an ambient write that clears at plain flush end.
+ * Same-key writes across actions keep last-write-wins layer semantics.
+ */ function stampOptimisticOwner(e, t, r) {
+    if (t === STORE_OPTIMISTIC_OVERRIDE) (e[STORE_OPTIMISTIC_OWNERS] ??= Object.create(null))[r] = activeTransition;
+}
+
+function upsertStoreNode(e, t, r, n, o) {
+    if (t[r]) return t[r];
+    const i = isWrappable(n) ? wrap(n, e) : n;
+    const s = getNode(e, t, r, i, isEqual, o);
+    registerTransientStoreNode(s);
+    return s;
+}
+
+function notifyStoreProperty(e, t, r, n, o, i) {
+    // Cold writes upsert a transient pending node so untracked reads batch like signals.
+    // Skip for projection writes (different commit semantics) and for optimistic stores
+    // (whose whole purpose is immediate visibility via STORE_OPTIMISTIC_OVERRIDE).
+    const s = projectionWriteActive || e[STORE_OPTIMISTIC];
+    const E = r !== "delete";
+    const O = e[STORE_HAS]?.[t];
+    if (O) {
+        setSignal(O, E);
+    } else if (!s && r !== "invalidate" && i !== E) {
+        const r = upsertStoreNode(e, getNodes(e, STORE_HAS), t, i);
+        setSignal(r, E);
+    }
+    const c = getNodes(e, STORE_NODE);
+    if (r === "set") {
+        if (c[t]) {
+            setSignal(c[t], () => isWrappable(n) ? wrap(n, e) : n);
+        } else if (!s) {
+            const r = upsertStoreNode(e, c, t, o, e[STORE_SNAPSHOT_PROPS]);
+            setSignal(r, () => isWrappable(n) ? wrap(n, e) : n);
+        }
+    } else if (r === "invalidate") {
+        if (c[t]) {
+            setSignal(c[t], {});
+            delete c[t];
+        }
+    } else {
+        if (c[t]) {
+            setSignal(c[t], undefined);
+        } else if (!s) {
+            const r = upsertStoreNode(e, c, t, o, e[STORE_SNAPSHOT_PROPS]);
+            setSignal(r, undefined);
+        }
+    }
+    notifySelf(e);
+}
+
+let Writing = null;
+
+/**
+ * A derived store's seed is a draft for the derive function, never an
+ * observable value (#2897): until the firewall first resolves there is
+ * nothing to read, so every consumer path throws NotReady — tracked reads
+ * through their node (core read()), and the untracked fall-throughs in the
+ * traps through this guard. Returning the seed leaked it; returning
+ * `undefined` would break non-nullable types. Callers exempt the firewall
+ * itself (the derive function works its own draft while uninitialized).
+ */ function throwIfUninitialized(e) {
+    const t = e[STORE_FIREWALL];
+    if (t && t.i & STATUS_UNINITIALIZED) throw t.k ?? new NotReadyError(t);
+}
+
+const storeTraps = {
+    get(e, t, r) {
+        if (t === $TARGET) return e;
+        if (t === $PROXY) return r;
+        if (t === $REFRESH) return e[STORE_FIREWALL];
+        if (pendingCheckActive) witnessAffectsMark(e, t);
+        if (t === $TRACK) {
+            trackSelf(e);
+            return r;
+        }
+        const n = getObserver() === e[STORE_FIREWALL];
+        const o = getNodes(e, STORE_NODE);
+        const i = n ? undefined : o[t];
+        const s = e[STORE_VALUE];
+        if (!i && !e[STORE_OVERRIDE] && !e[STORE_OPTIMISTIC_OVERRIDE] && !e[STORE_CUSTOM_PROTO] && !e[STORE_OPTIMISTIC] && !e[STORE_SNAPSHOT_PROPS] && !s[$TARGET] && !(t in s) && getObserver() && !n && !writeOnly(r)) {
+            return read(getNode(e, o, t, undefined));
+        }
+        const E = getOverlayLayer(e, t);
+        const O = !!E;
+        const c = !!e[STORE_VALUE][$TARGET];
+        const S = E ?? e[STORE_VALUE];
+        if (!i) {
+            const n = Object.getOwnPropertyDescriptor(S, t);
+            if (n && n.get) return n.get.call(r);
+            if (!n && !O && e[STORE_CUSTOM_PROTO]) {
+                const e = unwrapStoreValue(S);
+                if (hasInheritedAccessor(e, t)) {
+                    return Reflect.get(S, t, r);
+                }
+            }
+        }
+        if (writeOnly(r)) {
+            if (isPrototypePollutionKey(t) && !hasOwnStoreProperty(e, t)) return undefined;
+            let r = i && (O || !c) ? visibleNodeValue(i) : S[t];
+            r === $DELETED && (r = undefined);
+            if (!isWrappable(r)) return r;
+            const n = wrap(r, e);
+            Writing?.add(n);
+            return n;
+        }
+        let f = i ? O || !c ? read(o[t]) : (read(o[t]), S[t]) : S[t];
+        f === $DELETED && (f = undefined);
+        if (!i) {
+            if (!O && typeof f === "function" && !Object.prototype.hasOwnProperty.call(S, t)) {
+                let t;
+                return !Array.isArray(e[STORE_VALUE]) && (t = Object.getPrototypeOf(e[STORE_VALUE])) && t !== Object.prototype ? f.bind(S) : f;
+            } else if (getObserver() && !n) {
+                return read(getNode(e, o, t, isWrappable(f) ? wrap(f, e) : f, isEqual, e[STORE_SNAPSHOT_PROPS]));
+            }
+        }
+        // Untracked fall-through (tracked reads already threw via their node in
+        // read(); the dev strictRead error above wins first for memo parity).
+                if (!n) throwIfUninitialized(e);
+        return isWrappable(f) ? wrap(f, e) : f;
+    },
+    has(e, t) {
+        if (t === $PROXY || t === $TRACK || t === "__proto__") return true;
+        if (pendingCheckActive) witnessAffectsMark(e, t);
+        const r = getOverlayLayer(e, t);
+        const n = r ? r[t] !== $DELETED : t in e[STORE_VALUE];
+        if (writeOnly(e[$PROXY]) || getObserver() === e[STORE_FIREWALL]) return n;
+        const o = getNodes(e, STORE_HAS);
+        // If a has-node already exists, it carries the batched presence — `read()`
+        // returns `_value` (committed) for untracked reads and the pending value for
+        // downstream computes. This keeps `in` consistent with value reads.
+                if (o[t]) return read(o[t]);
+        // No node yet: `has` reflects committed presence (no pending write could change
+        // it without first upserting a has-node at the write site). Create + read only
+        // when tracking; leave untracked reads node-free.
+                if (getObserver()) {
+            return read(getNode(e, o, t, n));
+        }
+        throwIfUninitialized(e);
+        return n;
+    },
+    set(e, t, r) {
+        if (t === "__proto__") return true;
+        const n = e[$PROXY];
+        if (writeOnly(n)) {
+            untrack(() => {
+                const {base: o, overrideKey: i, state: s} = prepareStoreWrite(e, n, t);
+                const E = getOverlayLayer(e, t);
+                const O = E ? E[t] : o;
+                const c = E ? E[t] !== $DELETED : t in e[STORE_VALUE];
+                const S = unwrapStoreValue(r);
+                // Symbol-keyed writes on arrays are metadata, not index writes — never run
+                // them through the numeric index/length machinery (`parseInt` on a symbol
+                // throws). #2769
+                                const f = typeof t === "string" ? Number(t) : -1;
+                const T = Array.isArray(s) && Number.isInteger(f) && f >= 0 && f < 4294967295 && String(f) === t;
+                const R = T ? f + 1 : 0;
+                const u = T && (getOverlayLayer(e, "length") ?? s).length;
+                const l = T && R > u ? R : undefined;
+                if (O === S && l === undefined) return true;
+                armOptimisticStoreWrite(e, n);
+                if (S !== undefined && S === o && l === undefined) {
+                    delete e[i]?.[t];
+                    if (i === STORE_OPTIMISTIC_OVERRIDE) delete e[STORE_OPTIMISTIC_OWNERS]?.[t];
+                } else {
+                    const r = e[i] || (e[i] = Object.create(null));
+                    r[t] = S;
+                    stampOptimisticOwner(e, i, t);
+                    if (l !== undefined) {
+                        r.length = l;
+                        stampOptimisticOwner(e, i, "length");
+                    }
+                }
+                notifyStoreProperty(e, t, "set", S, O, c);
+                // Shrinking an array's length must remove the truncated indices, otherwise
+                // they leak through `has`, `ownKeys`, and (tracked) index reads from the
+                // underlying value. Mark each as deleted and notify so reactive reads update. #2768
+                                if (Array.isArray(s) && t === "length" && typeof S === "number" && typeof O === "number" && S < O) {
+                    const t = e[i] || (e[i] = Object.create(null));
+                    for (let r = S; r < O; r++) {
+                        if (t[r] === $DELETED) continue;
+                        const n = r in t ? t[r] : s[r];
+                        if (!(r in t) && !(r in s)) continue;
+                        t[r] = $DELETED;
+                        stampOptimisticOwner(e, i, r);
+                        notifyStoreProperty(e, r, "delete", undefined, n, true);
+                    }
+                }
+                // notify length change
+                                if (Array.isArray(s) && t !== "length" && l !== undefined) {
+                    const t = getNodes(e, STORE_NODE);
+                    if (t.length) {
+                        setSignal(t.length, l);
+                    } else if (!projectionWriteActive && !e[STORE_OPTIMISTIC]) {
+                        const r = upsertStoreNode(e, t, "length", u, e[STORE_SNAPSHOT_PROPS]);
+                        setSignal(r, l);
+                    }
+                }
+                if (false) ;
+            });
+        }
+        return true;
+    },
+    defineProperty(e, t, r) {
+        if (t === "__proto__") return true;
+        const n = e[$PROXY];
+        if (writeOnly(n)) {
+            untrack(() => {
+                const {base: o, overrideKey: i} = prepareStoreWrite(e, n, t);
+                armOptimisticStoreWrite(e, n);
+                const s = "value" in r ? {
+                    ...r,
+                    value: unwrapStoreValue(r.value)
+                } : r;
+                Object.defineProperty(e[i] || (e[i] = Object.create(null)), t, s);
+                stampOptimisticOwner(e, i, t);
+                notifyStoreProperty(e, t, "invalidate");
+                if (false) ;
+            });
+        }
+        return true;
+    },
+    deleteProperty(e, t) {
+        if (t === "__proto__") return true;
+        // Check both optimistic and regular override for existing $DELETED
+                const r = e[STORE_OPTIMISTIC_OVERRIDE]?.[t] === $DELETED;
+        const n = e[STORE_OVERRIDE]?.[t] === $DELETED;
+        if (writeOnly(e[$PROXY]) && !r && !n) {
+            untrack(() => {
+                const r = e[STORE_OPTIMISTIC] && !projectionWriteActive;
+                const n = r ? STORE_OPTIMISTIC_OVERRIDE : STORE_OVERRIDE;
+                const o = getOverlayLayer(e, t);
+                const i = o ? o[t] : e[STORE_VALUE][t];
+                if (t in e[STORE_VALUE] || e[STORE_OVERRIDE] && t in e[STORE_OVERRIDE]) {
+                    armOptimisticStoreWrite(e, e[$PROXY]);
+                    (e[n] || (e[n] = Object.create(null)))[t] = $DELETED;
+                    stampOptimisticOwner(e, n, t);
+                } else if (e[n] && t in e[n]) {
+                    armOptimisticStoreWrite(e, e[$PROXY]);
+                    delete e[n][t];
+                    if (n === STORE_OPTIMISTIC_OVERRIDE) delete e[STORE_OPTIMISTIC_OWNERS]?.[t];
+                } else return true;
+                notifyStoreProperty(e, t, "delete", undefined, i, true);
+            });
+        }
+        return true;
+    },
+    ownKeys(e) {
+        if (pendingCheckActive) witnessAffectsMark(e);
+        if (getObserver() !== e[STORE_FIREWALL]) {
+            trackSelf(e);
+            // trackSelf no-ops untracked, so enumeration of an unresolved derived
+            // store would otherwise leak the seed's structure (#2897). The write
+            // path is exempt (like the get/has traps' writeOnly early returns):
+            // the first landing's reconcile enumerates the store while
+            // STATUS_UNINITIALIZED is still set — it IS the initialization.
+                        if (!getObserver() && !writeOnly(e[$PROXY])) throwIfUninitialized(e);
+        }
+        // Merge optimistic override with regular override for key enumeration
+                let t = getKeys(e[STORE_VALUE], e[STORE_OVERRIDE], false);
+        if (e[STORE_OPTIMISTIC_OVERRIDE]) {
+            const r = new Set(t);
+            for (const t of Reflect.ownKeys(e[STORE_OPTIMISTIC_OVERRIDE])) {
+                if (e[STORE_OPTIMISTIC_OVERRIDE][t] !== $DELETED) r.add(t); else r.delete(t);
+            }
+            t = Array.from(r);
+        }
+        return t;
+    },
+    getOwnPropertyDescriptor(e, t) {
+        if (t === $PROXY) return {
+            value: e[$PROXY],
+            writable: true,
+            configurable: true
+        };
+        // Check optimistic override first, but use base descriptor structure for compatibility
+                if (e[STORE_OPTIMISTIC_OVERRIDE] && t in e[STORE_OPTIMISTIC_OVERRIDE]) {
+            if (e[STORE_OPTIMISTIC_OVERRIDE][t] === $DELETED) return undefined;
+            const r = Reflect.getOwnPropertyDescriptor(e[STORE_OPTIMISTIC_OVERRIDE], t);
+            if (r?.get || r?.set || !(t in e[STORE_VALUE])) return r;
+            // Get base descriptor structure, override just the value
+                        const n = getPropertyDescriptor(e[STORE_VALUE], e[STORE_OVERRIDE], t);
+            if (n) {
+                const r = Reflect.getOwnPropertyDescriptor(e, t);
+                const o = !r || r.configurable ? true : n.configurable;
+                return {
+                    ...n,
+                    configurable: o,
+                    value: e[STORE_OPTIMISTIC_OVERRIDE][t]
+                };
+            }
+            return {
+                value: e[STORE_OPTIMISTIC_OVERRIDE][t],
+                writable: true,
+                enumerable: true,
+                configurable: true
+            };
+        }
+        const r = getPropertyDescriptor(e[STORE_VALUE], e[STORE_OVERRIDE], t);
+        // The proxy target is an internal node object, not the original source. When the
+        // source has a non-configurable property that does not also exist as non-configurable
+        // on the proxy target, the proxy invariant is violated: the engine requires that a
+        // property reported as non-configurable must actually be non-configurable on the
+        // target object. Override configurable to true only in that case.
+                if (r && !r.configurable) {
+            const n = Reflect.getOwnPropertyDescriptor(e, t);
+            if (!n || n.configurable) return {
+                ...r,
+                configurable: true
+            };
+        }
+        return r;
+    },
+    getPrototypeOf(e) {
+        return Object.getPrototypeOf(e[STORE_VALUE]);
+    }
+};
+
+function storeSetter(e, t) {
+    const r = Writing;
+    Writing = new Set;
+    Writing.add(e);
+    try {
+        const r = t(e);
+        if (r !== e && r !== undefined) {
+            if (Array.isArray(r)) {
+                for (let t = 0, n = r.length; t < n; t++) e[t] = r[t];
+                e.length = r.length;
+            } else {
+                const t = new Set([ ...ownEnumerableKeys(e), ...ownEnumerableKeys(r) ]);
+                t.forEach(t => {
+                    if (t in r) e[t] = r[t]; else delete e[t];
+                });
+            }
+        }
+    } finally {
+        Writing.clear();
+        Writing = r;
+    }
+}
+
+function createStore(e, t, r) {
+    const n = typeof e === "function", o = n ? createProjectionInternal(e, t, r).store : wrap(e);
+    return [ o, n ? e => {
+        // Mark the projection as manually written before notifying property nodes.
+        suppressComputedRecompute(o[$REFRESH]);
+        storeSetter(o, e);
+    } : e => storeSetter(o, e) ];
+}
+
+export { $AFFECTS, $DELETED, $PROXY, $TARGET, $TRACK, STORE_CUSTOM_PROTO, STORE_DESC, STORE_FIREWALL, STORE_HAS, STORE_LOOKUP, STORE_NODE, STORE_OPTIMISTIC, STORE_OPTIMISTIC_OVERRIDE, STORE_OPTIMISTIC_OWNERS, STORE_OVERRIDE, STORE_PARENT, STORE_VALUE, STORE_WRAP, createStore, createStoreProxy, getKeys, getOverlayLayer, getPropertyDescriptor, getStoreAffectsNodes, getStoreKeys, getStoreSymbols, isWrappable, mergedOverlay, notifySelf, ownEnumerableKeys, setWriteOverride, storeLookup, storeSetter, storeTraps, symbolKeyedRecords, trackSelf, visibleNodeValue, witnessAffectsMark, wrap };