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

package/dist/prod/core/optimistic.js

@@ -1,265 +0,0 @@
-import { NOT_PENDING, unwrapOverride, STATUS_UNINITIALIZED, CONFIG_HAS_LANE, OVERRIDE_UNDEFINED, STATUS_PENDING, REACTIVE_MANUAL_WRITE, REACTIVE_OPTIMISTIC_DIRTY, EFFECT_RENDER, EFFECT_USER } from "./constants.js";
-
-import { ext, latestReadActive, currentOptimisticLane, stale } from "./core.js";
-
-import { NotReadyError } from "./error.js";
-
-import "./invariants.js";
-
-import { resolveTransition, getOrCreateLane, hasActiveOverride, activeLanes, signalLanes, findLane, resolveLane, assignOrMergeLane } from "./lanes.js";
-
-import { GlobalQueue, activeTransition, globalQueue, clock, insertSubs, schedule } from "./scheduler.js";
-
-/**
- * The optimistic write engine, moved out of core.ts/scheduler.ts. Everything
- * here serves only optimistic overrides — createOptimistic,
- * createOptimisticStore (and its store-node writes), and the verdict layer's
- * companions (which are optimistic nodes). Modules that can create optimistic
- * state call `installOptimisticEngine()` before creating it; apps that never
- * import one of those APIs never retain any of this.
- *
- * Core call sites fire the hooks behind guards on state only this module can
- * create (`_overrideValue !== undefined`, `currentOptimisticLane !== null`,
- * `_optimisticNodes.length`, `activeLanes.size`), so `!` invocations are safe
- * once the gate holds — the same late-binding contract as verdict.ts.
- */
-/** The optimistic half of setSignal, fired when `_overrideValue !== undefined`. */ function optimisticWrite(e, n) {
-    const t = e.o?.De !== NOT_PENDING;
-    const i = t ? unwrapOverride(e.o?.De) : e.be;
-    if (typeof n === "function") n = n(i);
-    const u = !!(e.S & STATUS_UNINITIALIZED) || !e.Ue || !e.Ue(i, n);
-    if (!u) {
-        // Same-value write with an active override still entangles the current
-        // action's transition — the hold must outlast all overlapping actions.
-        if (t) {
-            const n = resolveTransition(e);
-            if (n && activeTransition !== n) globalQueue.initTransition(n);
-        }
-        return n;
-    }
-    if (t) globalQueue.initTransition(resolveTransition(e));
-    // No revert target is stashed: while the override is active every reader
-    // sees it (A17), so authoritative arrivals commit silently into _value and
-    // reverting is just dropping the override — _value is already correct.
-     else globalQueue.k.Ke.push(e);
-    // Stamp ownership on the node (post-merge, so entangled writers share the
-    // joint root). resolveTransition prefers this over the lane's _transition,
-    // which a shared subscriber can merge across transactions (#2912).
-        ext(e).Et = activeTransition;
-    const l = getOrCreateLane(e);
-    ext(e).Be = l;
-    e.T |= CONFIG_HAS_LANE;
-    // Literal undefined must not land raw: the slot doubles as the optimistic
-    // brand, and erasing it makes the write invisible and routes follow-up
-    // writes off the optimistic path into permanent commits (#2898).
-        ext(e).De = n === undefined ? OVERRIDE_UNDEFINED : n;
-    // syncCompanions only pokes _pendingSignal/_latestValueComputed — with
-    // neither companion present the call is a guaranteed no-op.
-        (e.o?.Ge !== undefined || e.o?.ge !== undefined) && GlobalQueue.Oe !== null && GlobalQueue.Oe(e, n);
-    if (e.Se !== undefined) e.Te = clock;
- // §12e: computed-only slot
-        insertSubs(e, true);
-    schedule();
-    return n;
-}
-
-/**
- * transitionComplete's override blockage: a settling transition stays open
- * while one of its optimistic nodes holds an active override that is still
- * pending on real (non-affects-sentinel) async.
- */ function transitionBlocked(e) {
-    for (let n = 0; n < e.Ke.length; n++) {
-        const t = e.Ke[n];
-        if (hasActiveOverride(t) && "S" in t && t.S & STATUS_PENDING && t.o?._ instanceof NotReadyError) {
-            return true;
-        }
-    }
-    return false;
-}
-
-function resolveOptimisticNodes(e) {
-    // Settlement writes below (snapCompanionsToState → updatePendingSignal-style
-    // notifications) may push fresh optimistic nodes; only this batch settles
-    // now, so iterate a fixed window and splice it out at the end.
-    const n = e.length;
-    for (let t = 0; t < n; t++) {
-        const n = e[t];
-        if (n.o !== null) n.o.Be = undefined;
-        // Revert is a pure drop: there is no revert target to commit —
-        // override-covered authoritative values hold in _pendingValue and
-        // elevate on their OWN transition's schedule (A18 as re-ruled 2026-07-07).
-                if (!(n.S & STATUS_PENDING)) n.S &= ~STATUS_UNINITIALIZED;
-        const i = n.o?.De;
-        ext(n).De = NOT_PENDING;
-        if (i !== NOT_PENDING && n.be !== unwrapOverride(i)) insertSubs(n, true);
-        n._e = null;
-        if (n.o !== null) n.o.Et = null;
-    }
-    // Settlement checkpoint (#2838): companions caught in this batch (or owned
-    // by a node in it) re-derive from committed state, so verdicts survive the
-    // transition that produced them (A19 — pending is a property of the data).
-        for (let t = 0; t < n; t++) {
-        const n = e[t];
-        if (n.o?.Ge || n.o?.ge) GlobalQueue.un(n);
-        const i = n.o?.It;
-        if (i && (i.o?.Ge === n || i.o?.ge === n)) GlobalQueue.un(i);
-    }
-    e.splice(0, n);
-}
-
-function runQueue(e, n) {
-    for (let t = 0; t < e.length; t++) e[t](n);
-}
-
-/**
- * Run effects from all lanes that are ready (no pending async).
- */ function runLaneEffects(e) {
-    for (const n of activeLanes) {
-        if (n.tn || n.Ae.size > 0) continue;
-        const t = n.en[e - 1];
-        if (t.length) {
-            n.en[e - 1] = [];
-            runQueue(t, e);
-        }
-    }
-}
-
-function cleanupCompletedLanes(e) {
-    for (const n of activeLanes) {
-        const t = e ? n._e === e : !n._e;
-        if (!t) continue;
-        if (!n.tn) {
-            if (n.en[0].length) runQueue(n.en[0], EFFECT_RENDER);
-            if (n.en[1].length) runQueue(n.en[1], EFFECT_USER);
-        }
-        if (n.nn.o?.Be === n) if (n.nn.o !== null) n.nn.o.Be = undefined;
-        n.Ae.clear();
-        n.en[0].length = 0;
-        n.en[1].length = 0;
-        activeLanes.delete(n);
-        signalLanes.delete(n.nn);
-    }
-}
-
-/** read()'s per-lane suspension test (pending-throw path, lane context). */ function laneSuspends(e) {
-    // Per-lane suspension: only throw if in same lane as pending async
-    // AND the node doesn't have an active override (overrides are the visible value,
-    // downstream in the lane should read the override, not throw)
-    const n = e.o?.Be;
-    if (!n) return false;
-    return findLane(n) === findLane(currentOptimisticLane) && !hasActiveOverride(e);
-}
-
-/**
- * read()'s entanglement gate: a reader recomputing under an optimistic lane
- * that reads a pending mid-transition write sees the committed value; the sub
- * is recorded for replay at commit.
- */ function gatedRead(e, n, t) {
-    if (latestReadActive || e.Pe === NOT_PENDING || e.Se || n !== e && !(n.ie & REACTIVE_MANUAL_WRITE)) {
-        return false;
-    }
-    activeTransition.ln.add(t);
-    return true;
-}
-
-/**
- * read()'s value selection under a lane: return the committed `_value` for
- * optimistic/lane-assigned signals, stale-mode reads, and pending owners.
- */ function laneReadsCommitted(e, n, t) {
-    if (e.o?.De !== undefined || !!e.o?.Be || !!(n.S & STATUS_PENDING)) return true;
-    if (n === e && stale && t.o?.It !== e) {
-        // The committed view can hide a same-tick ambient write (a lane member —
-        // even just an isPending companion flip — puts the reader "under a lane"
-        // against unrelated plain writes). With no transaction the write commits
-        // at THIS flush's end with no re-delivery, so record the reader for
-        // replay at commit — the same contract gatedRead provides when a
-        // transaction is active (#2963). If a transaction forms mid-flush,
-        // initTransition carries the recording over to it.
-        if (e.Pe !== NOT_PENDING && activeTransition === null) globalQueue.k.ln.add(t);
-        return true;
-    }
-    return false;
-}
-
-/**
- * recompute()'s lane posture: resolve the node's own lane (own=true), or adopt
- * a dependency's optimistic lane (own=false — parent-deeper-than-owned-child
- * can run before its OPT-dirty child propagates).
- */ function recomputeLane(e, n) {
-    if (n) {
-        const n = resolveLane(e);
-        if (!n) return null;
-        // Wake-only lane demotion (#3009): a plain write to a latest()-tracked
-        // source rides the optimistic channel only to wake verdict companions —
-        // its lane is sourced by the companion shadow (_parentSource set) and owns
-        // no transaction. When such a node is pulled mid-tick by a latest()/
-        // isPending() probe, lane posture would direct-commit _value, leaking the
-        // queued write into committed reads before the flush. Return `false` so
-        // recompute() runs plain: the value stages and commits with the flush.
-        // (el's own override slot excludes companions themselves; a lane merged
-        // into a real optimistic lane resolves to a non-companion source.)
-                if (!globalQueue.sn && !activeTransition && !n._e && n.nn.o?.It !== undefined && e.o?.De === undefined) {
-            if (e.o !== null) e.o.Be = undefined;
-            return false;
-        }
-        return n;
-    }
-    for (let n = e.nt; n; n = n.it) {
-        const t = n.ut;
-        if (t.ie & REACTIVE_OPTIMISTIC_DIRTY) {
-            const n = resolveLane(t);
-            if (n) {
-                e.ie |= REACTIVE_OPTIMISTIC_DIRTY;
-                assignOrMergeLane(e, n);
-                return n;
-            }
-        }
-    }
-    return null;
-}
-
-/** recompute()'s catch path: track pending async in the current lane. */ function laneAsyncPending(e) {
-    const n = findLane(currentOptimisticLane);
-    if (n.nn !== e) {
-        n.Ae.add(e);
-        ext(e).Be = n;
-        e.T |= CONFIG_HAS_LANE;
-        GlobalQueue.de !== null && GlobalQueue.de(n.nn);
-    }
-}
-
-/** recompute()'s success path: the node's async settled, clear it from its lane. */ function laneAsyncSettled(e) {
-    const n = resolveLane(e);
-    if (n) {
-        n.Ae.delete(e);
-        GlobalQueue.de !== null && GlobalQueue.de(n.nn);
-    }
-}
-
-function trackOptimisticStore(e) {
-    // After initTransition, globalQueue._batch IS activeTransition (same reference)
-    globalQueue.k.cn.add(e);
-    schedule();
-}
-
-/**
- * Installs the engine's hooks. Idempotent; called by every module that can
- * create optimistic state (verdict.ts at module top level, createOptimistic
- * and createOptimisticStore at first call) BEFORE any optimistic node exists.
- */ function installOptimisticEngine() {
-    if (GlobalQueue.vt !== null) return;
-    GlobalQueue.vt = optimisticWrite;
-    GlobalQueue.fn = resolveOptimisticNodes;
-    GlobalQueue.dn = transitionBlocked;
-    GlobalQueue.En = cleanupCompletedLanes;
-    GlobalQueue.Tn = runLaneEffects;
-    GlobalQueue.Ft = gatedRead;
-    GlobalQueue.ht = laneSuspends;
-    GlobalQueue.gt = laneReadsCommitted;
-    GlobalQueue.je = recomputeLane;
-    GlobalQueue.$e = laneAsyncPending;
-    GlobalQueue.ze = laneAsyncSettled;
-    GlobalQueue.Nn = trackOptimisticStore;
-}
-
-export { installOptimisticEngine };

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

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