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

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

@@ -1,257 +0,0 @@
-import { computed } from "../../core/core.js";
-
-import { isDisposed, getOwner } from "../../core/owner.js";
-
-import { setProjectionWriteActive, projectionWriteActive, scheduleWithheld } from "../../core/scheduler.js";
-
-import { handleAsync } from "../../core/async.js";
-
-import "../../core/verdict.js";
-
-import "../../core/effect.js";
-
-import { CONFIG_AUTO_DISPOSE, STATUS_PENDING } from "../../core/constants.js";
-
-import { $TARGET, STORE_VALUE, markRawIngest, setWriteOverride } from "../store.js";
-
-import { reconcileNextState } from "./reconcile.js";
-
-import { storeSetterNext, wrapNext, derivedStoreWrite } 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.
- */
-/**
- * Wrap a store proxy as a projection DRAFT: every operation carries the write
- * override (the derive is the author — its ops must not hit the §6c firewall
- * gate, even in a continuation after an `await`/`yield` where the sync write
- * scope has closed).
- *
- * FAKE TARGET, not the store proxy itself (#3060): after a proxy trap
- * returns, the engine runs spec invariant validation against the proxy's
- * TARGET — [[OwnPropertyKeys]] after ownKeys, [[GetOwnProperty]] after
- * set/getOwnPropertyDescriptor/defineProperty. With the store proxy as
- * target those checks re-enter the store's traps OUTSIDE the override
- * bracket (the trap's finally has already run), so `Object.keys(state)` in
- * a derive continuation fired the firewall gate and re-threw the
- * projection's own pending NotReadyError into the derive. A dummy of
- * matching kind (array/object, same trick as the store's own TargetShape)
- * keeps invariant validation away from the store entirely; the traps
- * forward to the closed-over inner proxy inside the bracket.
- *
- * Save/restore projectionWriteActive, 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.
- */ function wrapDraft(e, t, r, o, i) {
-    // One bracket for the three mutating traps. A write to a superseded or
-    // disposed draft is dropped silently (proj R37 — the same fate as a
-    // superseded async run's pending draft writes, R26). `afterWrite` runs
-    // once the bracket has closed — outside it, so the scheduler's
-    // projectionWriteActive guard no longer applies — and only for the
-    // outermost bracket (a draft driven from inside an enclosing authoritative
-    // scope, the optimistic derive, leaves scheduling to that scope's caller).
-    const mutate = e => {
-        if (!t()) return true;
-        const o = projectionWriteActive;
-        setWriteOverride(true);
-        setProjectionWriteActive(true);
-        try {
-            r ? r(e) : e();
-        } finally {
-            setWriteOverride(false);
-            setProjectionWriteActive(o);
-        }
-        if (!o && i) i();
-        return true;
-    };
-    const n = {
-        get(n, c) {
-            let s;
-            const l = projectionWriteActive;
-            setWriteOverride(true);
-            setProjectionWriteActive(true);
-            try {
-                s = e[c];
-            } finally {
-                setWriteOverride(false);
-                setProjectionWriteActive(l);
-            }
-            // A shallow store's leaves are raw by contract (#3498): no draft proxy
-            // over them, so identity holds and a frozen leaf is never trapped.
-                        return !o && typeof s === "object" && s !== null && c !== $TARGET ? wrapDraft(s, t, r, false, i) : s;
-        },
-        has(t, r) {
-            let o;
-            const i = projectionWriteActive;
-            setWriteOverride(true);
-            setProjectionWriteActive(true);
-            try {
-                o = r in e;
-            } finally {
-                setWriteOverride(false);
-                setProjectionWriteActive(i);
-            }
-            return o;
-        },
-        set: (t, r, o) => mutate(() => {
-            e[r] = o;
-        }),
-        deleteProperty: (t, r) => mutate(() => {
-            delete e[r];
-        }),
-        ownKeys() {
-            const t = projectionWriteActive;
-            setWriteOverride(true);
-            setProjectionWriteActive(true);
-            try {
-                return Reflect.ownKeys(e);
-            } finally {
-                setWriteOverride(false);
-                setProjectionWriteActive(t);
-            }
-        },
-        getOwnPropertyDescriptor(t, r) {
-            let o;
-            const i = projectionWriteActive;
-            setWriteOverride(true);
-            setProjectionWriteActive(true);
-            try {
-                o = Reflect.getOwnPropertyDescriptor(e, r);
-            } finally {
-                setWriteOverride(false);
-                setProjectionWriteActive(i);
-            }
-            // The dummy target doesn't hold the key, so a non-configurable report
-            // would violate the proxy invariant. Store descriptors are already
-            // normalized configurable; enforce it for raw leaves too.
-                        if (o) o.configurable = true;
-            return o;
-        },
-        defineProperty: (t, r, o) => mutate(() => {
-            Reflect.defineProperty(e, r, o);
-        })
-    };
-    // Matching-kind dummy so Array.isArray(draft) answers like the store.
-        return new Proxy(Array.isArray(e) ? [] : {}, n);
-}
-
-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.C &= ~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). Across a hold the write is not a proposal:
- * a leaf another transaction holds as the fold's result re-runs the fold
- * under it, the write being the draft's prior state (A34 amendment, #3612;
- * core derivedWrite). */ function createStoreDerivedNext(e, t, r) {
-    const {store: o, node: i} = createProjectionNextInternal(e, t, r);
-    return [ o, e => derivedStoreWrite(i, o, e) ];
-}
-
-// A detached copy of projection state: the root container alone for a shallow
-// store — its leaves are raw references by contract and stay so (#3498) — the
-// whole tree otherwise.
-function cloneState(e, t) {
-    return t ? Array.isArray(e) ? e.slice() : {
-        ...e
-    } : JSON.parse(JSON.stringify(e));
-}
-
-function runProjectionComputedNext(e, t, r, o, i) {
-    const n = getOwner();
-    const c = e[$TARGET];
-    const s = c.fam;
-    // Draft validity is per run (R37): live from here until the NEXT run starts
-    // — this counter moves, whatever that run does (lands, throws NotReady,
-    // awaits) — or the owner is disposed. Not "until no longer in flight": a
-    // sync derive that subscribes to an external source and pushes into the
-    // draft from the callback (#3585) is the model use, and the old gate
-    // (`owner._x?._inFlight === result`) only admitted it by accident — while
-    // nothing had read the projection yet (no `_x`), `undefined === undefined`.
-        const l = s.run = (s.run || 0) + 1;
-    let u;
-    // 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. (A callback
-    // that closes over the shadow writes into a dead clone once the window has
-    // closed — the one carve-out from R37's one-draft-per-run model.)
-        const a = n.ve ? cloneState(c[STORE_VALUE], c.s) : null;
-    const f = wrapDraft(e, () => s.run === l && !isDisposed(n), i, c.s, 
-    // A write after the run returned takes the override channel (pending
-    // backing + per-op notify + fold) and arms the drain itself when no
-    // landing will: a flight still up — pending, or the loading window's
-    // first flight — drains at its landing, and must not be drained early.
-    // Not gated on the run having returned: the body's own writes withhold
-    // the microtask too, and a derive body only ever runs outside a flush at
-    // creation (reruns are flush-driven) — a top-level sync projection in a
-    // createRoot stranded the scheduler until an explicit flush(). Arming
-    // mid-body is safe: the microtask fires after this synchronous slice,
-    // when the body has returned or parked, and an initial async run's
-    // pre-await half drains before its landing exactly as it does when the
-    // creation ran inside a flush — nothing reads it before the landing
-    // (the node is uninitialized, proj R23).
-    () => {
-        if (!(n.h & STATUS_PENDING) && !n.ve) scheduleWithheld();
-    });
-    storeSetterNext(f, i => {
-        u = t(a ?? i);
-        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 (a && (t === undefined || t === a)) t = cloneState(a, c.s);
-            if (t === i || t === undefined) return;
-            const write = () => storeSetterNext(e, e => reconcileNextState(t, e, r, true), false);
-            o ? o(write, t) : write();
-        };
-        const s = handleAsync(n, u, commit);
-        if (!n.ve) commit(s);
-    }, false);
-    return n;
-}
-
-export { createProjectionNext, createStoreDerivedNext, runProjectionComputedNext };

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

@@ -1,373 +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 { isOwned, $OWNER, storeNextLookup, optHooks, lookupTarget } 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 f = t?.[$TARGET];
-    if (f === undefined || f.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 (f.ovl) materializePB(f);
-    let i = 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 = f.pb ?? f.v;
-        if (t === e) return;
- // already chained to this store
-                adoptPB(f, e);
-        return;
-    }
-    const l = unwrapValue(e);
-    if (i) {
-        // 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 = f.pb ?? f.v;
-        const t = i(e);
-        if (t !== undefined && !sameKey(i(l), 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.
-                        const e = f.pb ?? f.v;
-            if (isOwned(e)) delete e[$OWNER]; // disown: wraps fresh if re-handed
-             else (f.fam?.map ?? storeNextLookup).delete(e);
-            adoptPB(f, l);
-            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 (f.fam?.opt === true && !projectionWriteActive && !getWriteOverride()) {
-        optHooks.applyTentative(f, l, i);
-        return;
-    }
-    applyAdopt(f, l, i, o);
-}
-
-function applyAdopt(e, t, n, o = false) {
-    const f = e.pb ?? e.v;
-    // The sound identity skip (O7): same reference AND we never diverged it.
-        if (t === f && !isOwned(f)) return;
-    const i = 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 l = i?.opt === true ? optHooks.optimisticView(e, f) : f;
-    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 s = i === null;
-    const u = e.s === true;
-    // Node-notify base is the view the nodes were last told (#3296): a draft
-    // preceding this reconcile already moved them to its pending backing at
-    // setter exit (prev, materialized above), so diffing incoming against the
-    // committed backing would skip a key the draft changed and the reconcile
-    // restores — the node would commit the superseded draft value.
-        const a = f;
-    adoptPB(e, t, s);
-    // Shallow adoption: records are slot values — sticky raw-mark the incoming
-    // set (R41) and never descend; slot notification is the positional diff.
-        if (u) markRawIngest(t);
-    if (Array.isArray(l) !== r) {
-        if (s) notifyFold(e, a, t);
-        return;
-    }
-    if (r) {
-        const f = l;
-        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 = s ? e.n : null;
-        let d = 0;
-        if (n && !u) {
-            // 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 l = f.length;
-            const s = r.length;
-            let u = false;
-            let p = 0;
-            for (const y = Math.min(l, s); p < y; p++) {
-                const l = r[p];
-                const s = f[p];
-                // 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 (s !== l && !(s !== null && typeof s === "object" && l !== null && typeof l === "object" && sameKey(n(s), n(l)))) break;
- // misaligned: fall to the keyed remainder below
-                // Identity skip inline (FINDING-1 guard), then descend the pair.
-                                if ((s !== l || l !== null && typeof l === "object" && isOwned(l)) && l !== null && typeof l === "object") descend(unwrapValue(s), l, n, i, o);
-                if (e.dk !== null && !u && !(l !== null && typeof l === "object" ? targetsEqual(s, l) : isEqual(s, l))) {
-                    bumpDeep(e);
-                    u = true;
-                }
-                if (c !== null) {
-                    const e = c[p];
-                    if (e !== undefined) {
-                        d++;
-                        notifyKeyValue(e, p, a[p], l, a, t);
-                    }
-                }
-            }
-            if (e.dk !== null && !u && p < r.length) bumpDeep(e);
-            const y = p;
- // misalignment point (== nlen on aligned ticks)
-                        let w = null;
-            for (;p < r.length; p++) {
-                const e = r[p];
-                // typeof gates route; descend validates (same contract as the prefix).
-                                if (e !== null && typeof e === "object") {
-                    const t = n(e);
-                    let l;
-                    if (t !== undefined) {
-                        if (w === null) {
-                            // Occurrence-aware (re-audit 2, P1-5): duplicate keys queue
-                            // their prev INDICES (rows can themselves be arrays, so index
-                            // queues are the unambiguous encoding — same as buildRowOps)
-                            // and each is consumed ONCE. First-wins would adopt two next
-                            // rows into the SAME prev target while row ops retain two
-                            // separate DOM rows (the second one stale).
-                            w = new Map;
-                            // From structStart, not 0 (re-audit 3, P1-2): prefix-aligned
-                            // rows already adopted their incoming counterparts — re-offering
-                            // them here let a duplicate key adopt a prefix row AGAIN while
-                            // row ops (which correctly window from structStart) retained
-                            // the later occurrence's DOM row against a never-adopted target.
-                                                        for (let e = y; e < f.length; e++) {
-                                const t = unwrapValue(f[e]);
-                                if (t !== null && typeof t === "object") {
-                                    const o = n(t);
-                                    if (o === undefined) continue;
-                                    const f = w.get(o);
-                                    if (f === undefined) w.set(o, e); else if (Array.isArray(f)) f.push(e); else w.set(o, [ f, e ]);
-                                }
-                            }
-                        }
-                        const e = w.get(t);
-                        if (e === undefined) l = undefined; else if (Array.isArray(e)) {
-                            l = unwrapValue(f[e.shift()]);
-                            if (e.length === 1) w.set(t, e[0]);
-                        } else {
-                            l = unwrapValue(f[e]);
-                            w.delete(t);
-                        }
-                    } else {
-                        l = unwrapValue(f[p]);
- // keyless item: positional fallback
-                                        }
-                    descend(l, e, n, i, o);
-                }
-                if (c !== null) {
-                    const e = c[p];
-                    if (e !== undefined) {
-                        d++;
-                        notifyKeyDiff(e, p, a, t, false);
-                    }
-                }
-            }
-        } else {
-            const l = Math.min(f.length, r.length);
-            const s = r.length;
-            let p = false;
-            for (let y = 0; y < s; y++) {
-                const s = r[y];
-                if (!u && y < l && s !== null && typeof s === "object") descend(unwrapValue(f[y]), s, n, i, o);
-                if (e.dk !== null && !p && !(s !== null && typeof s === "object" ? targetsEqual(f[y], s) : isEqual(f[y], s))) {
-                    bumpDeep(e);
-                    p = true;
-                }
-                if (c !== null) {
-                    const e = c[y];
-                    if (e !== undefined) {
-                        d++;
-                        notifyKeyDiff(e, y, a, t, false);
-                    }
-                }
-            }
-        }
-        if (s) {
-            if (c !== null && d < 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 f = s ? 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 s in t) {
-            const d = t[s];
-            const p = a[s];
-            const y = d !== null && typeof d === "object";
-            if (p === d && (!y || !isOwned(d)) && (f === null || f[s] === undefined || !hasAccessorFlag(f[s]))) {
-                if (f !== null && f[s] !== undefined) r++;
-                continue;
-            }
-            if (y && !u) descend(unwrapValue(l[s]), d, n, i, 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(p, d) : isEqual(p, d))) {
-                bumpDeep(e);
-                c = true;
-            }
-            if (f !== null) {
-                const e = f[s];
-                if (e !== undefined) {
-                    r++;
-                    notifyKeyValue(e, s, p, d, a, t);
-                }
-            }
-        }
-        const d = Object.getOwnPropertySymbols(t);
-        for (let e = 0; e < d.length; e++) {
-            const s = d[e];
-            if (s === $OWNER) continue;
-            const c = t[s];
-            if (!u && c !== null && typeof c === "object") descend(unwrapValue(l[s]), c, n, i, o);
-            if (f !== null) {
-                const e = f[s];
-                if (e !== undefined) {
-                    r++;
-                    notifyKeyValue(e, s, a[s], c, a, t);
-                }
-            }
-        }
-        if (s) {
-            // Deleted-key nodes (in the map but absent from incoming) — counted
-            // fast-out: when every node was visited, skip the sweep entirely.
-            if (f !== null && r < e.nc) {
-                for (const e of Reflect.ownKeys(f)) {
-                    if (!hasOwnP.call(t, e)) notifyKeyDiff(f[e], e, a, t, false);
-                }
-            }
-            notifyFoldTail(e, a, t);
-        }
-        return;
-    }
-}
-
-const hasOwnP = Object.prototype.hasOwnProperty;
-
-/** Setter-channel row ops (the fold site calls this for array targets with
- * ops consumers): structural mutation through the setter — push/splice/index
-/** Key equality for EVERY key comparison in this module (re-audit 2, P1-5):
- * SameValueZero, matching the adoption window's Map-based matcher — NaN keys
- * are equal to themselves, so aligned NaN rows stay aligned in the prefix
- * walk instead of forever misaligning. */ function sameKey(e, t) {
-    return e === t || e !== e && t !== t;
-}
-
-function descend(e, t, n, o, f = 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 i = lookupTarget(e, o);
-    if (i === 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 f = 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.
-        // SameValueZero (re-audit 2, P1-5): NaN keys are self-equal — strict
-        // inequality detached every NaN-keyed slot on every tick while the
-        // Map-based row-ops matcher retained its DOM row (stale forever).
-                if (o !== undefined && f !== undefined && !sameKey(o, f)) 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 (!f && n !== null && !i.d) return;
-    applyAdopt(i, t, n, f);
-}
-
-export { reconcileNextState, sameKey };