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

package/dist/observe/store/index.js

@@ -1,44 +1,47 @@
-import "../core/core.js";
+import { createStore as createStore$1, deep as deep$1, snapshot as snapshot$1 } from "./store.js";
 
-import "../core/dev.js";
+export { storeHasFamily, storeHasOptimisticFamily, storeIsShallow } from "./store.js";
 
-import "../core/scheduler.js";
+export { createOptimisticStore } from "./optimistic.js";
 
-import "../core/invariants.js";
+import { createStoreDerived } from "./projection.js";
 
-import "../core/verdict.js";
+export { createProjection } from "./projection.js";
 
-import "../core/effect.js";
+import { reconcileState } from "./reconcile.js";
 
-import { createStoreNext, nameStore, deepNext, snapshotNext } from "./next/store.js";
+import "../core/verdict.js";
 
-export { storeHasFamily, storeHasOptimisticFamily, storeIsShallow } from "./next/store.js";
+import "../core/core.js";
 
-import { reconcileNextState } from "./next/reconcile.js";
+import "../core/dev.js";
 
-import { createStoreDerivedNext } from "./next/projection.js";
+import "../core/scheduler.js";
+
+import "../core/effect.js";
 
-export { createProjectionNext as createProjection } from "./next/projection.js";
+import "../core/lanes.js";
 
-function createStore(e, t, r) {
-    if (typeof e === "function") return createStoreDerivedNext(e, t, r);
-    {
-        const r = createStoreNext(e, !!t?.shallow);
-        if (t?.name) nameStore(r[0], t.name);
-        return r;
-    }
+function createStore(e, r, t) {
+    if (typeof e === "function") return createStoreDerived(e, r, t);
+    return createStore$1(e, r);
 }
 
-function reconcile(e, t = "id") {
-    return r => reconcileNextState(e, r, t);
+/**
+ * A setter transform that reconciles `value` into the store by key
+ * (`"id"` by default; `null` positional), preserving store identity for
+ * surviving rows.
+ */ function reconcile(e, r = "id") {
+    return t => reconcileState(e, t, r);
 }
 
-function snapshot(e) {
-    return snapshotNext(e);
+/** Non-tracking snapshot of a store's current value (source identity for
+ * unmodified subtrees). */ function snapshot(e) {
+    return snapshot$1(e);
 }
 
-function deep(e) {
-    return deepNext(e);
+/** Tracking snapshot: subscribes to every reachable record. */ function deep(e) {
+    return deep$1(e);
 }
 
 export { createStore, deep, reconcile, snapshot };

package/dist/observe/store/optimistic.js

@@ -0,0 +1,571 @@
+import { CONFIG_OVERRIDE, CONFIG_AUTO_DISPOSE, NOT_PENDING } from "../core/constants.js";
+
+import { computed, ext, untrack, read, isEqual } from "../core/core.js";
+
+import { pendingGuessOf, laneValueOf, optimisticWrite } from "../core/lanes.js";
+
+import { getOwner } from "../core/owner.js";
+
+import { GlobalQueue, txOf, list, insertSubs, laneDirty, notifyEpoch, schedule } from "../core/scheduler.js";
+
+import { runProjectionComputed } from "./projection.js";
+
+import { wrap, nameStore, storeSetter, LaneView, committed, getNode, unwrapValue, sameKey, resolveChainedRaw, getHasNode, targetsEqual, getContainerNode, cloneRaw } from "./store.js";
+
+import { installOptHooks } from "./hooks.js";
+
+import { $OWNER } from "./target.js";
+
+import { $TARGET, markRawIngest, $TRACK, isWrappable } from "./types.js";
+
+/**
+ * Store — optimistic stores on lanes (plan sec. 31, S4; INTERNALS §3/§7, RUL-3).
+ *
+ * No store-side layer, no backup snapshots, no retaining ledger: a user
+ * write to an optimistic store is a GUESS on the written key's node
+ * (`optimisticWrite` — the same write `createOptimistic`'s setter makes),
+ * a presence guess on its presence node, and, when membership or
+ * arrangement changed, an arrangement guess on the container node. Lanes
+ * do the rest: the guess shows under the action's hold, a landing beneath
+ * it stages as truth and confirms it when equal (A18/A24), the action's
+ * settle dissolves it (a revert to the value it covered, or the landed
+ * truth). The committed backing is never touched by a guess.
+ *
+ * Reads compose: a reader of an overlaid target sees the truth it is served
+ * with the lanes' values over it (`optimisticView` — per node, by the same
+ * rule a leaf read follows: what the lane shows).
+ *
+ * Landings (Q-D, plan sec. 31.7): the derive's output is reconciled against the
+ * optimistic VIEW — a row the guess added and the server returns with the
+ * same key in the same position keeps its proxy (the row target adopts the
+ * server object), its leaves write truth beneath their guesses, and the
+ * container's arrangement guess is confirmed silently (`LaneView`'s
+ * comparator) — `For` does not run. Retained-setter replay (the
+ * 2026-08-31b continuation half) is not built here; the matrix decides.
+ */ const hasOwn = Object.prototype.hasOwnProperty;
+
+/** A user setter's writes on an optimistic family, as guesses: one per
+ * changed key's leaf, one per presence change, the container's arrangement
+ * when membership or order changed. `pb` is the draft (a clone of the view
+ * the user saw); `old` the view it composed on. */
+/** An optimistic setter's targets whose staging was set aside (`draft`),
+ * restored when the setter's writes become guesses (`writes`). */ const optStaged = new Map;
+
+// A chained backing is a proxy: reading it as a handler can expose a
+// derived store's staging. Compose the writer's view on the committed
+// backing of each link, retaining any optimistic guesses on that link.
+function writerBacking(e) {
+    const n = committed(e);
+    const t = n[$TARGET];
+    return t === undefined ? n : optimisticView(t, writerBacking(t), laneValueOf, true);
+}
+
+/** The user's draft on an optimistic family: a clone of the view the user
+ * saw — the committed frame with the lanes' values and the tick's own
+ * unflushed guesses over it (#3665). A staging already on the target (a
+ * landing adopted this flush) is set aside for the setter's duration: the
+ * guesses go over it, it stays the truth beneath. */ function optimisticDraft(e) {
+    if (e.pb !== null) optStaged.set(e, e.pb);
+    return cloneRaw(optimisticView(e, writerBacking(e), laneValueOf, true), e);
+}
+
+function notifyOptimisticWrites(e, n) {
+    // The view the user saw: the committed frame (a staging adopted eagerly
+    // is not it) with the lanes' values and the tick's own guesses over it.
+    const t = writerBacking(e);
+    const i = optimisticView(e, t, laneValueOf, true);
+    const r = Array.isArray(n);
+    // A chained target's nodes are links (§7b): their committed value is
+    // never served and never learns the inner store's commits — yet a guess
+    // is judged against it, and reverts to it (#3672). Hand the node the
+    // inner store's truth for its key before guessing over it.
+        const o = e.ch ? e.v : null;
+    const guess = (e, n, i, r) => {
+        if (o !== null) e.Ae = i ? n in t : unwrapValue(t[n]);
+        // By value: a function leaf is a value, not an updater (#3017).
+                optimisticWrite(e, () => r);
+    };
+    let s = false;
+    for (const t of Reflect.ownKeys(n)) {
+        if (r && t === "length" || t === $OWNER) continue;
+        // A chained draft holds the inner store's raws; a raw is the inner slot it
+        // resolves to (as a read of it serves) — the row a held write staged is
+        // the same row, not a guess over the slot (#3796).
+                const a = n[t];
+        const f = unwrapValue(o && a ? resolveChainedRaw(e, t, a) : a);
+        if (!(t in i)) {
+            guess(getNode(e, t), t, false, f);
+            guess(getHasNode(e, t), t, true, true);
+            s = true;
+        } else {
+            const n = i[t];
+            const a = unwrapValue(o && n ? resolveChainedRaw(e, t, n) : n);
+            if (!isEqual(a, f) && !targetsEqual(a, f)) {
+                guess(getNode(e, t), t, false, f);
+                if (r) s = true;
+            }
+        }
+    }
+    for (const t of Reflect.ownKeys(i)) {
+        if (r && t === "length" || t === $OWNER) continue;
+        if (t in n) continue;
+        guess(getNode(e, t), t, false, undefined);
+        guess(getHasNode(e, t), t, true, false);
+        s = true;
+    }
+    if (r && i.length !== n.length) {
+        guess(getNode(e, "length"), "length", false, n.length);
+        s = true;
+    }
+    if (s) {
+        const o = r ? n.map(unwrapValue) : shallowKeys(n);
+        // The rows the setter removed from the view it saw, by key: a later
+        // re-base over another action's truth must not bring them back.
+                let s = null;
+        const a = e.fam.key;
+        if (r && a !== null && a !== undefined) {
+            const e = new Set;
+            for (let n = 0; n < o.length; n++) {
+                const t = isWrappable(o[n]) ? a(o[n]) : undefined;
+                if (t !== undefined) e.add(t);
+            }
+            for (let n = 0; n < i.length; n++) {
+                const t = unwrapValue(i[n]);
+                const r = isWrappable(t) ? a(t) : undefined;
+                if (r !== undefined && !e.has(r)) (s ??= new Set).add(r);
+            }
+        }
+        optimisticWrite(getContainerNode(e), new LaneView(o, t, s));
+    }
+    if (e.dk !== null) optimisticWrite(e.dk, {});
+    markOverlaid(e);
+    const a = optStaged.get(e);
+    if (a === undefined) return null;
+    optStaged.delete(e);
+    return a;
+}
+
+/** The container comparator's lane arm (store.ts `containerEquals`): an
+ * arrangement guess (`LaneView`) against a landing or another arrangement,
+ * by row identity — by key when the family has one. */ function arrangement(e, n, t) {
+    const i = n instanceof LaneView;
+    const r = t instanceof LaneView;
+    if (!i && !r) return false;
+    return arrangementEqual(i ? n.rows : n, r ? t.rows : t, e.fam?.key ?? null);
+}
+
+function rowSame(e, n, t) {
+    if (isEqual(e, n) || targetsEqual(e, n)) return true;
+    if (t === null || !isWrappable(e) || !isWrappable(n)) return false;
+    const i = t(unwrapValue(e));
+    const r = t(unwrapValue(n));
+    // Keyless rows are identified by position — reconcile's fallback when the
+    // key is missing. The caller already paired these by index, so two keyless
+    // rows are the same row and the landing confirms the arrangement instead of
+    // dissolving it. Dissolving held an external echo under the action, and a
+    // mainline `until` then timed out on a source that already contained it
+    // (#3898). Keyed rows still match only on the key.
+        if (i === undefined && r === undefined) return true;
+    return i !== undefined && sameKey(i, r);
+}
+
+/** Whether reconcile would write anything into `a` from `b`: wrappable
+ * pairs descend, leaves compare as its writes do. A key mismatch is a
+ * replacement, which a content difference already says. Plain data — the
+ * server's echo of a guessed row is a new object with the same contents. */ function echoes(e, n) {
+    if (e === n) return true;
+    if (!isWrappable(e) || !isWrappable(n)) return false;
+    e = unwrapValue(e);
+    n = unwrapValue(n);
+    const t = Object.keys(e);
+    if (Array.isArray(e) !== Array.isArray(n) || t.length !== Object.keys(n).length) return false;
+    for (const i of t) if (!hasOwn.call(n, i) || !echoes(e[i], n[i])) return false;
+    return true;
+}
+
+// A cycle (a row that references itself) is not plain data: no match, so
+// the landing stays a correction.
+GlobalQueue.sn = (e, n) => {
+    try {
+        return echoes(e, n);
+    } catch {
+        return false;
+    }
+};
+
+function arrangementEqual(e, n, t) {
+    if (Array.isArray(e) !== Array.isArray(n)) return false;
+    if (Array.isArray(e)) {
+        if (e.length !== n.length) return false;
+        for (let i = 0; i < e.length; i++) if (!rowSame(e[i], n[i], t)) return false;
+        return true;
+    }
+    const i = Reflect.ownKeys(e).filter(e => e !== $OWNER);
+    const r = Reflect.ownKeys(n).filter(e => e !== $OWNER);
+    if (i.length !== r.length) return false;
+    for (const e of i) if (!(e in n)) return false;
+    return true;
+}
+
+/** Write `incoming` into the draft `draft` (a store proxy inside a user's
+ * setter): arrays match rows by key (position when unkeyed) and recurse into
+ * the matched row's draft; objects recurse into a wrappable pair, assign
+ * otherwise; keys `incoming` lacks are deleted. */ function reconcileDraft(e, n, t) {
+    if (Array.isArray(n)) {
+        const i = e.length;
+        const r = new Array(i);
+        for (let n = 0; n < i; n++) r[n] = e[n];
+        let o = null;
+        if (t !== null) {
+            o = new Map;
+            for (let e = 0; e < i; e++) {
+                const n = unwrapValue(r[e]);
+                if (!isWrappable(n)) continue;
+                const i = t(n);
+                if (i !== undefined && !o.has(i)) o.set(i, r[e]);
+            }
+        }
+        for (let s = 0; s < n.length; s++) {
+            const a = n[s];
+            let f;
+            if (isWrappable(a)) {
+                if (o !== null) {
+                    const e = t(a);
+                    if (e !== undefined) f = o.get(e);
+                } else if (s < i && isWrappable(unwrapValue(r[s]))) f = r[s];
+            }
+            if (f !== undefined) {
+                if (unwrapValue(f) !== a) reconcileDraft(f, a, t);
+                if (e[s] !== f) e[s] = f;
+            } else if (unwrapValue(e[s]) !== a) e[s] = a;
+        }
+        if (e.length !== n.length) e.length = n.length;
+        return;
+    }
+    for (const i of Object.keys(n)) {
+        const r = n[i];
+        const o = e[i];
+        const s = unwrapValue(o);
+        if (isWrappable(r) && isWrappable(s) && Array.isArray(r) === Array.isArray(s) && (t === null || Array.isArray(r) || sameKey(t(r), t(s)))) {
+            if (s !== r) reconcileDraft(o, r, t);
+        } else if (s !== r) e[i] = r;
+    }
+    for (const t of Object.keys(e)) if (!(t in n)) delete e[t];
+}
+
+/** Q-D (plan sec. 39): an OLDER question's truth landed beneath an arrangement
+ * guess (`laneWrite` held it — another action's landing is not this guess's
+ * answer). The guess is re-based over it: order from the guess, rows from
+ * the truth by key (a guessed row the truth has is the truth's object — the
+ * row target adopted it, its proxy survives), guessed rows the truth lacks
+ * kept (the guess's own landing judges them), truth rows the guess lacks
+ * appended. The composed arrangement becomes the lane's value on every
+ * index whose row the committed backing does not already show — compared
+ * BY KEY, never by raw identity: the same key's new object is the same row
+ * (its target adopted it) and the slot stays the committed backing's — (a
+ * node is born for it as the lane's derivation), on `length` only when the
+ * committed length differs, and as the `LaneView`'s base for structural
+ * reads. Unkeyed families compose
+ * positionally — the guess stands as written (the documented residue). */ GlobalQueue._n = (e, n) => {
+    const t = e.yt;
+    if (t === undefined || e.bt !== $TRACK) return;
+    const i = e.m.B;
+    if (!(i instanceof LaneView)) return;
+    if (!Array.isArray(n) || !Array.isArray(i.rows)) {
+        i.base = n;
+        return;
+    }
+    const r = t.fam?.key ?? null;
+    if (r === null) return;
+    const o = new Map;
+    for (let e = 0; e < n.length; e++) {
+        const t = n[e];
+        const i = isWrappable(t) ? r(t) : undefined;
+        if (i !== undefined && !o.has(i)) o.set(i, t);
+    }
+    const s = new Set;
+    const a = [];
+    const f = i.rows;
+    for (let e = 0; e < f.length; e++) {
+        const n = f[e];
+        const t = isWrappable(n) ? r(n) : undefined;
+        const i = t !== undefined ? o.get(t) : undefined;
+        if (i !== undefined) {
+            a.push(i);
+            s.add(t);
+        } else a.push(n);
+    }
+    const u = i.removed;
+    for (let e = 0; e < n.length; e++) {
+        const t = n[e];
+        const i = isWrappable(t) ? r(t) : undefined;
+        if (i !== undefined && !s.has(i) && (u === null || !u.has(i))) a.push(t);
+    }
+    i.rows = a;
+    i.base = a;
+    const l = txOf(e);
+    const c = committed(t);
+    const d = t.n;
+    for (let e = 0; e < a.length; e++) {
+        const n = d?.[e];
+        // A slot the lane does not own shows the committed row: it becomes the
+        // lane's only where the composed row is another row (by key — the same
+        // key's new object is the same row, its target adopted it).
+                if (n === undefined) {
+            if (!sameRow(c[e], a[e], r)) laneSet(getNode(t, e), a[e], l);
+        } else if (!sameRow(n.i & CONFIG_OVERRIDE ? n.m.B : c[e], a[e], r)) laneSet(n, a[e], l);
+    }
+    if (d !== null) {
+        for (let e = a.length; ;e++) {
+            const n = d[e];
+            if (n === undefined) break;
+            laneSet(n, undefined, l);
+        }
+        const e = d.length;
+        if (e !== undefined && (e.i & CONFIG_OVERRIDE || c.length !== a.length)) laneSet(e, a.length, l);
+    }
+};
+
+function sameRow(e, n, t) {
+    if (e === n) return true;
+    if (!isWrappable(e) || !isWrappable(n)) return false;
+    const i = t(unwrapValue(e));
+    return i !== undefined && sameKey(i, t(unwrapValue(n)));
+}
+
+/** A composed value becomes the lane's on `node`: a guess re-based, or a
+ * node that was not the lane's becomes its derivation (its committed value
+ * untouched beneath; the lane's end commits the latest). */ function laneSet(e, n, t) {
+    const i = ext(e);
+    if (!(e.i & CONFIG_OVERRIDE)) {
+        e.i |= CONFIG_OVERRIDE;
+        list(e, t);
+    } else if (i.B === n) return;
+    i.B = n;
+    if (e.t !== null) {
+        insertSubs(e);
+        laneDirty(e, t);
+    }
+}
+
+installOptHooks({
+    draft: optimisticDraft,
+    writes: notifyOptimisticWrites,
+    arrangement: arrangement,
+    reconcile: reconcileDraft,
+    view: (e, n, t = false) => t ? optimisticView(e, n, laneValueOf, true) : optimisticView(e, n),
+    has: optimisticHas,
+    descriptor: optimisticOwnDescriptor,
+    sweep: sweepOverlaid
+});
+
+function shallowKeys(e) {
+    const n = {};
+    for (const t of Reflect.ownKeys(e)) if (t !== $OWNER) n[t] = unwrapValue(e[t]);
+    return n;
+}
+
+/** Families with a target carrying a lane value — swept at the flush's
+ * commit (`sweepOverlaid`): a target none of whose nodes is a lane's any
+ * more leaves its family's `overlaid`. (Not on the read path: a guess is
+ * pending between the setter and the seam, and a read in between must not
+ * take the target for clean.) */ const overlaidFamilies = new Set;
+
+function markOverlaid(e) {
+    const n = e.fam;
+    (n.overlaid ??= new Set).add(e);
+    overlaidFamilies.add(n);
+}
+
+function sweepOverlaid() {
+    if (overlaidFamilies.size === 0) return;
+    for (const e of overlaidFamilies) {
+        const n = e.overlaid;
+        for (const e of n) if (!carriesLane(e)) {
+            n.delete(e);
+            if (e.ch) rebaseChained(e);
+            // The container shows its backing again (a shown arrangement guess
+            // that ended without a landing left its `LaneView` as the value).
+                        const t = e.k;
+            if (t !== null && t.Ae instanceof LaneView) t.Ae = t.Ae.base;
+        }
+        if (n.size === 0) overlaidFamilies.delete(e);
+    }
+}
+
+/** A chained view's lanes ended: its nodes are links (§7b) whose committed
+ * value is the inner store's at the guess, not now — the inner may have
+ * moved underneath the guess (the base committed while the view showed
+ * its arrangement, #3672/F1). Re-base each node on the inner's truth and
+ * re-derive the readers whose shown value it is not. */ function rebaseChained(e) {
+    const n = e.v;
+    let t = false;
+    const i = e.n;
+    if (i !== null) for (const e of Reflect.ownKeys(i)) {
+        const r = i[e];
+        const o = untrack(() => unwrapValue(n[e]));
+        if (r.en && r.en(r.Ae, o)) continue;
+        r.Ae = o;
+        // (The lane's end notified it this epoch when the shown value and the
+        // covered one differed — its readers re-derive already.)
+                if (r.t !== null && r.Pt !== notifyEpoch) {
+            insertSubs(r);
+            t = true;
+        }
+    }
+    const r = e.h;
+    if (r !== null) for (const e of Reflect.ownKeys(r)) {
+        const i = r[e];
+        const o = untrack(() => e in n);
+        if (i.Ae === o) continue;
+        i.Ae = o;
+        if (i.t !== null && i.Pt !== notifyEpoch) {
+            insertSubs(i);
+            t = true;
+        }
+    }
+    // The arrangement the readers saw (the shown guess) against the inner's
+    // now: a structural reader re-derives when they differ.
+        const o = e.k;
+    if (o !== null && o.t !== null && o.Ae instanceof LaneView && o.Pt !== notifyEpoch) {
+        const i = Array.isArray(n) ? untrack(() => n.map(unwrapValue)) : n;
+        if (!arrangementEqual(o.Ae.rows, i, e.fam?.key ?? null)) {
+            insertSubs(o);
+            t = true;
+        }
+    }
+    if (t) schedule();
+}
+
+function carriesLane(e) {
+    if (e.k !== null && e.k.i & CONFIG_OVERRIDE) return true;
+    if (e.dk !== null && e.dk.i & CONFIG_OVERRIDE) return true;
+    const n = e.n;
+    if (n !== null) for (const e of Reflect.ownKeys(n)) if (n[e].i & CONFIG_OVERRIDE) return true;
+    const t = e.h;
+    if (t !== null) for (const e of Reflect.ownKeys(t)) if (t[e].i & CONFIG_OVERRIDE) return true;
+    return false;
+}
+
+function overlaid(e) {
+    const n = e.fam;
+    return n !== null && n.opt === true && n.overlaid !== undefined && n.overlaid.has(e);
+}
+
+/** What a lane node shows an untracked reader here: core's rule (`read`
+ * without a link — the lane's world inside its own pass, the screen
+ * outside, a verdict window's answer under one). */ const shown = e => untrack(() => read(e));
+
+/** An untracked `key in store` on an optimistic family: the presence guess
+ * (what its lane shows) when the key carries one; `undefined` when not —
+ * the backing answers. */ function optimisticHas(e, n) {
+    if (!overlaid(e)) return undefined;
+    const t = e.h?.[n];
+    if (t !== undefined && t.i & CONFIG_OVERRIDE) return !!shown(t);
+    const i = e.n?.[n];
+    if (i !== undefined && i.i & CONFIG_OVERRIDE) return shown(i) !== undefined;
+    return undefined;
+}
+
+/** A descriptor read of a guessed key: synthesized from the lane's value
+ * (`null`: the guess removed the key; `undefined`: no guess — the backing
+ * describes it). */ function optimisticOwnDescriptor(e, n) {
+    const t = optimisticHas(e, n);
+    if (t === undefined) return undefined;
+    if (!t) return null;
+    const i = e.n?.[n];
+    const r = i !== undefined && i.i & CONFIG_OVERRIDE ? shown(i) : e.v[n];
+    // An array's `length` is reported as the array has it (non-configurable).
+        if (n === "length" && Array.isArray(e.v)) return {
+        value: r,
+        writable: true,
+        enumerable: false,
+        configurable: false
+    };
+    return {
+        value: r,
+        writable: true,
+        enumerable: true,
+        configurable: true
+    };
+}
+
+/** The truth `src` with the target's lane values over it: each overlaid
+ * leaf's value (`pick`: what the lane shows, or — for `latest` — the lane's
+ * latest), each presence guess as a key added or removed, the array
+ * length. Returns `src` itself when nothing is overlaid. */ function optimisticView(e, n, t = shown, 
+// The writer's view: the unflushed guesses too (on nodes that are no
+// lane's yet) — what the next write composes on (#3665).
+i = false) {
+    if (!i && !overlaid(e)) return n;
+    let r = null;
+    const ensure = () => r ??= Array.isArray(n) ? [ ...n ] : {
+        ...n
+    };
+    const o = e.n;
+    if (o !== null) {
+        for (const e of Reflect.ownKeys(o)) {
+            const r = o[e];
+            let s;
+            if (r.i & CONFIG_OVERRIDE) s = t(r); else if (!i || (s = pendingGuessOf(r)) === NOT_PENDING) continue;
+            if (e === "length" && Array.isArray(n)) {
+                if (n.length !== s) ensure().length = s;
+            } else if (!isEqual(n[e], s) || !hasOwn.call(n, e)) {
+                ensure()[e] = s;
+            }
+        }
+    }
+    const s = e.h;
+    if (s !== null) {
+        for (const e of Reflect.ownKeys(s)) {
+            const o = s[e];
+            let a;
+            if (o.i & CONFIG_OVERRIDE) a = t(o); else if (!i || (a = pendingGuessOf(o)) === NOT_PENDING) continue;
+            const f = !!a;
+            const u = r ?? n;
+            if (!f && e in u) delete ensure()[e];
+        }
+    }
+    return r ?? n;
+}
+
+function createOptimisticStore(e, n, t) {
+    const i = typeof e === "function";
+    const r = i ? t : n;
+    const o = i ? n : e;
+    const s = r?.key === undefined ? "id" : r.key;
+    const a = {
+        map: new WeakMap,
+        node: null,
+        live: new Set,
+        shallow: !!r?.shallow,
+        opt: true,
+        key: typeof s === "function" ? s : s === null ? null : e => isWrappable(e) ? e[s] : undefined
+    };
+    const f = wrap(o, null, null, a);
+    nameStore(f, r?.name);
+    if (a.shallow) {
+        f[$TARGET].s = true;
+        markRawIngest(o);
+    }
+    if (i) {
+        const n = e;
+        let t;
+        if (r?.seedLoadingValue) t = {
+            loadingValue: undefined
+        };
+        if (r?.name) t = {
+            ...t,
+            name: r.name
+        };
+        const i = computed(() => {
+            if (!a.node) a.node = getOwner();
+            runProjectionComputed(f, n, s);
+        }, t);
+        i.i &= ~CONFIG_AUTO_DISPOSE;
+        a.node = i;
+    }
+    return [ f, e => storeSetter(f, e) ];
+}
+
+export { createOptimisticStore, notifyOptimisticWrites, optimisticHas, optimisticOwnDescriptor, optimisticView, sweepOverlaid };