@solidjs/signals 2.0.0-rc.3 → 2.0.0-rc.5

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

@@ -1,8 +1,8 @@
-import { computed, ext, setSignal, isEqual } from "../../core/core.js";
+import { CONFIG_AUTO_DISPOSE, STATUS_PENDING, NOT_PENDING, CONFIG_OPTIMISTIC, CONFIG_HELD_TRUTH, unwrapOverride } from "../../core/constants.js";
 
-import { CONFIG_AUTO_DISPOSE, STATUS_PENDING, NOT_PENDING, unwrapOverride, CONFIG_OPTIMISTIC } from "../../core/constants.js";
+import { computed, setSignal, isEqual } from "../../core/core.js";
 
-import { GlobalQueue, insertSubs, schedule, globalQueue } from "../../core/scheduler.js";
+import { activeTransition, GlobalQueue, runAsTransitionBatch, globalQueue, currentTransition } from "../../core/scheduler.js";
 
 import "../../core/invariants.js";
 
@@ -16,7 +16,11 @@ import { $TARGET, markRawIngest, setNextOptimisticViewResolver, isWrappable, raw
 
 import { runProjectionComputedNext } from "./projection.js";
 
-import { wrapNext, runAuthoritative, storeSetterNext, hasActiveOverride, unwrapValue, getNode, getHasNode, targetsEqual, getKeySetNode, bumpDeep } from "./store.js";
+import { wrapNext, runAuthoritative, storeSetterNext, hasActiveOverride, unwrapValue, targetsEqual, getNode, getHasNode, getKeySetNode, bumpDeep, stagedTruthPB, authoritativeRead } from "./store.js";
+
+import { patchHooks, rowHooks } from "./patch-hooks.js";
+
+import { sameKey, buildIdentityRowOps } from "./reconcile.js";
 
 import { setOptHooks } from "./target.js";
 
@@ -29,12 +33,32 @@ import { setOptHooks } from "./target.js";
  * 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
+ * Derived form = an optimistic projection. Landings follow the fold rule
+ * (#3164, RUL-2 as re-ruled): while a transaction retains optimistic edits
+ * on the family, truth that lands STAGES into that transaction — a keyed
+ * identity-preserving walk written through the ordinary staged setter
+ * channel — and reveals atomically at settle, exactly like a signal landing
+ * under an active override (asyncWrite's held branch). Optimistic edits are
+ * never consumed by landings; they live exactly as long as their transaction
+ * and die by engine-native revert. With no retainer, landings commit
+ * immediately under projectionWriteActive (authoritative, silently beneath
+ * any bare-write overrides — those ride the flight's own transition, #2951).
+ * Authoritative readers (until()'s predicate) tunnel into staged truth via
+ * the node read path's pending-value arm. The transitionBlocked store-half
+ * (#2951) is installed here for next-shaped targets, chaining the
  * legacy/engine checks.
- */ let blockedInstalled = false;
+ */
+/** #3164 fold: a stamped truth is HELD (masked from ordinary readers until
+ * the reveal) only while its transition is live AND retaining optimism —
+ * overrides are what make partial-coverage composition a tear. A plain
+ * async transition carries no overrides, so downstream computes must see
+ * staged values to converge (normal speculation). Resolves merges first:
+ * merge unions optimistic nodes/stores into the target. */ function transitionHoldsOptimism(e) {
+    const t = currentTransition(e);
+    return t.sn !== true && (t.ze.length !== 0 || t.En.size !== 0);
+}
+
+let blockedInstalled = false;
 
 function installNextBlockedHalf() {
     if (blockedInstalled) return;
@@ -45,20 +69,45 @@ function installNextBlockedHalf() {
         setOptHooks({
         notifyOptimisticWrites: notifyOptimisticWrites,
         optimisticView: optimisticView,
-        applyTentative: applyTentative
+        applyTentative: applyTentative,
+        retainsOptimism: transitionHoldsOptimism
     });
     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 => {
+        if (!GlobalQueue.qt) {
+        GlobalQueue.qt = e => {
+            // Patch channel (revert site): engine-native reverts flip node values
+            // back to committed; patched records need a forced DOM re-apply from
+            // the post-revert view. Emission only — next keeps no layer to clear.
+            for (const t of e) {
+                const e = t?.[$TARGET];
+                const n = e?.fam?.overlaid;
+                if (n !== undefined) {
+                    for (const e of n) {
+                        if (e.pc !== null && e.pc.p !== null) patchHooks.emitPatchOptimistic(e, null, null);
+                        // Row-ops resync (family increment 2): reverts flip node values
+                        // back engine-natively; a driven list must rebuild retention by
+                        // row identity against the post-revert view (resolved from the
+                        // target at drain — overrides are gone by then).
+                                                if (e.pc !== null && e.pc.ro !== null) rowHooks.emitRowOpsOptimistic(e, null, null);
+                        // Keyset resync (classic channel twin): the keyset node's own
+                        // revert can compare EQUAL (a landing's bump matched the
+                        // tentative bump) while the arrangement underneath changed —
+                        // mapArray/ownKeys subscribers must re-read the post-revert
+                        // view. Authoritative bump: never re-arm the node we are
+                        // clearing.
+                                                if (e.k !== null) runAuthoritative(() => setSignal(e.k, e => e + 1));
+                    }
+                }
+            }
             e.clear();
         };
     }
-    const e = GlobalQueue.En;
-    GlobalQueue.En = t => {
-        for (const e of t.cn) {
+    const e = GlobalQueue.dn;
+    GlobalQueue.dn = t => {
+        for (const e of t.En) {
             const t = e?.[$TARGET];
             const n = t?.fam?.node;
             // The hold exists to keep optimistic state alive until the store's own
@@ -80,10 +129,10 @@ function familyHasLiveOverrides(e) {
             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 (n.o?.Oe !== undefined && n.o?.Oe !== NOT_PENDING) return true;
             }
         }
-        if (e.k !== null && e.k.o?.De !== undefined && e.k.o?.De !== NOT_PENDING) return true;
+        if (e.k !== null && e.k.o?.Oe !== undefined && e.k.o?.Oe !== NOT_PENDING) return true;
     }
     t.clear();
  // nothing live — drop the bookkeeping
@@ -106,32 +155,216 @@ function createOptimisticStoreNext(e, t, n) {
     };
     const s = wrapNext(o, null, null, r);
     r.px = s;
+    // Same key resolution the projection channels use ("id" default) — replay's
+    // satisfaction rule reads it off the family.
+        const l = n?.key === undefined ? "id" : n.key;
+    r.key = typeof l === "function" ? l : l === null ? null : e => isWrappable(e) ? e[l] : undefined;
     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();
+        // Landing router (#3164 fold ruling): while a transaction retains
+        // optimistic edits on this family, truth landings stage INTO it and
+        // reveal atomically at settle; with no retainer they commit immediately
+        // under the authoritative posture (async commits land outside the
+        // computed's sync body, so the posture is re-applied here).
+                const wrapCommit = (e, t) => {
+            const n = retainingTransition(r);
+            if (n === null) runAuthoritative(e); else stageLanding(r, n, t);
+        };
+        // Draft writes (the derive mutating its draft, sync body and post-await
+        // continuations alike) are the same truth channel per-operation: bind
+        // each op to the retaining transaction so its node writes stage and its
+        // backing fold defers (ensurePB stamps foldBatches with the swapped-in
+        // batch; the write-override eager-commit branch in notifyWrites yields
+        // to any active transaction).
+                const aroundDraftWrite = e => {
+            const t = retainingTransition(r);
+            if (t === null) e(); else runFolded(t, e);
         };
         let i;
         if (n?.seedLoadingValue) i = {
             loadingValue: undefined
         };
         const o = computed(() => {
-            runAuthoritative(() => runProjectionComputedNext(s, t, n?.key === undefined ? "id" : n.key, wrapCommit, consume));
+            runAuthoritative(() => runProjectionComputedNext(s, t, n?.key === undefined ? "id" : n.key, wrapCommit, aroundDraftWrite));
         }, i);
         o.T &= ~CONFIG_AUTO_DISPOSE;
         r.node = o;
     }
-    return [ s, e => storeSetterNext(s, e) ];
+    return [ s, e => {
+        // Retention ledger (#3164): record the owning transaction so landings
+        // know to fold. Captured at entry — the action machinery has the
+        // transaction ambient while user code runs; a bare write with no
+        // transaction retains nothing (it rides the flight's own transition
+        // per #2951 and dies with it).
+        const t = activeTransition;
+        storeSetterNext(s, e);
+        if (t !== null) (r.rt ??= new Set).add(t);
+    } ];
+}
+
+/** Resolve a retained transition through its merge chain (`_done` holds the
+ * merge target while merged, `true` once settled). Null = dead. */ function liveTransition(e) {
+    while (typeof e.sn === "object") e = e.sn;
+    return e.sn === true ? null : e;
+}
+
+/** The transaction truth landings fold into: the first live member of the
+ * family's retention ledger (dead members prune here). Multiple live
+ * retainers entangle through their shared family writes and settle
+ * together, so folding into the first reaches all of them. */ function retainingTransition(e) {
+    const t = e.rt;
+    if (t === undefined || t.size === 0) return null;
+    let n = null;
+    for (const e of t) {
+        const i = liveTransition(e);
+        if (i === null) t.delete(e); else n ??= i;
+    }
+    return n;
+}
+
+/** Fold a landing into the retaining transaction (#3164): the landed value
+ * is written through the ORDINARY staged setter channel — node writes park
+ * as `_pendingValue` registered with the transaction's batch (speculation
+ * and until()'s authoritative tunnel see them; live view stays coherent),
+ * and the backing fold defers via the foldBatches stamp — under the
+ * authoritative posture, so armed nodes take the engine bypass and no
+ * override is created. The engine's own commit machinery reveals everything
+ * atomically when the transaction settles (transitions never abort: failed
+ * actions still commit — only optimistic overrides revert). */ function stageLanding(e, t, n) {
+    runFolded(t, () => runAuthoritative(() => storeSetterNext(e.px, t => {
+        stagedApply(t, unwrapValue(n), e.key ?? null);
+    }, false)));
+}
+
+/** Run a fold write inside the retaining transaction's batch, then
+ * transition-stamp its staged nodes NOW (parity with the parked-transition
+ * flush path's reassignPendingTransition): the stamp is what routes stale
+ * (render) readers to the committed value — core read's cross-transaction
+ * guard — and what makes foldHeld defer the backing for context-free
+ * readers. A microtask staging never crosses that flush path, so without
+ * the stamp a render effect's speculative recompute would compose staged
+ * truth with live overrides — the #3164 tear, one window later. Armed
+ * nodes additionally raise CONFIG_HELD_TRUTH: their staged value is
+ * confirming truth masked from ordinary readers until the reveal (plain
+ * staged nodes stay visible — normal speculation; override-covered nodes
+ * stay unarmed — the override is their display and its revert their
+ * notification, A17). */ function runFolded(e, t) {
+    runAsTransitionBatch(e, t);
+    const n = e.Lt;
+    for (let t = 0; t < n.length; t++) {
+        const i = n[t];
+        i.Ae = e;
+        if (i.T & CONFIG_OPTIMISTIC && !hasActiveOverride(i)) i.T |= CONFIG_HELD_TRUTH;
+    }
+}
+
+/** Keyed identity-preserving deep merge through live draft proxies — the
+ * staged twin of the adoption walk. Reads see the pending backing (staged
+ * view), so consecutive landings during one hold compose; key-matched rows
+ * keep their raw (and so their proxy) in the slot with only changed leaves
+ * written; unmatched rows land wholesale. Runs inside stageLanding's
+ * authoritative bracket: drafts seed from committed truth, never overlays. */ function stagedApply(e, t, n) {
+    const i = Array.isArray(e);
+    if (i && Array.isArray(t)) {
+        const i = t.length;
+        if (n !== null) {
+            // Occurrence-aware key queues (parity with the adoption window):
+            // duplicate keys match per occurrence, each current row consumed once.
+            let o = null;
+            const r = e.length;
+            for (let t = 0; t < r; t++) {
+                const i = unwrapValue(e[t]);
+                if (!isWrappable(i)) continue;
+                const r = n(i);
+                if (r === undefined) continue;
+                const s = (o ??= new Map).get(r);
+                if (s === undefined) o.set(r, [ i ]); else s.push(i);
+            }
+            // Echo adoption: an optimistic structural add whose key the landing
+            // confirms must keep its raw (and so its proxy — list drivers keep the
+            // DOM row). Tentative rows never reach committed truth (they live in
+            // node overrides), so key-match the draft target's active override
+            // rows as a secondary pool. Committed rows queued first own their
+            // keys; overlay rows only extend coverage. Adopted raws enter staged
+            // truth; at settle the override reverts and the reveal re-seats the
+            // same raw.
+                        const s = e[$TARGET]?.n;
+            if (s != null) {
+                for (const e of Reflect.ownKeys(s)) {
+                    const t = s[e];
+                    if (!hasActiveOverride(t)) continue;
+                    const i = unwrapValue(unwrapOverride(t.o.Oe));
+                    if (!isWrappable(i)) continue;
+                    const r = n(i);
+                    if (r === undefined) continue;
+                    const l = (o ??= new Map).get(r);
+                    if (l === undefined) o.set(r, [ i ]); else l.push(i);
+                }
+            }
+            for (let r = 0; r < i; r++) {
+                const i = t[r];
+                let s;
+                if (isWrappable(i) && o !== null) {
+                    const e = n(i);
+                    if (e !== undefined) {
+                        for (const [t, n] of o) {
+                            if (!sameKey(t, e)) continue;
+                            s = n.shift();
+                            if (n.length === 0) o.delete(t);
+                            break;
+                        }
+                    }
+                }
+                if (s !== undefined) {
+                    if (unwrapValue(e[r]) !== s) e[r] = s;
+                    stagedApply(e[r], i, n);
+                } else {
+                    const t = unwrapValue(e[r]);
+                    if (!isEqual(t, i) && !targetsEqual(t, i)) e[r] = i;
+                }
+            }
+        } else {
+            for (let o = 0; o < i; o++) {
+                const i = t[o];
+                const r = unwrapValue(e[o]);
+                if (r === i) continue;
+                if (isWrappable(i) && isWrappable(r) && Array.isArray(i) === Array.isArray(r)) stagedApply(e[o], i, n); else if (!isEqual(r, i) && !targetsEqual(r, i)) e[o] = i;
+            }
+        }
+        if (e.length !== i) e.length = i;
+        return;
+    }
+    // Object merge; also the degenerate root-kind-change shape (arrays accept
+    // keyed writes/deletes, so a wholesale restatement still lands staged).
+        for (const o of Reflect.ownKeys(t)) {
+        if (i && o === "length") continue;
+        const r = t[o];
+        const s = unwrapValue(e[o]);
+        if (s === r) continue;
+        if (isWrappable(r) && isWrappable(s) && Array.isArray(r) === Array.isArray(s)) {
+            // Different-keyed entities never merge (tentative-channel parity):
+            // the incoming object replaces the slot wholesale.
+            if (n !== null) {
+                const t = n(s);
+                const i = n(r);
+                if (t !== undefined && i !== undefined && !sameKey(t, i)) {
+                    e[o] = r;
+                    continue;
+                }
+            }
+            stagedApply(e[o], r, n);
+        } else if (!isEqual(s, r) && !targetsEqual(s, r)) {
+            e[o] = r;
+        }
+    }
+    for (const n of Reflect.ownKeys(e)) {
+        if (i && n === "length" || n in t) continue;
+        delete e[n];
+    }
 }
 
 // ---- optimistic-only store machinery (moved from next/store.ts /
@@ -146,15 +379,30 @@ function createOptimisticStoreNext(e, t, n) {
     // 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);
+    if (n?.Ae) globalQueue.initTransition(n.Ae);
     const i = e.v;
+    // Patch channel (override-application site): the draft IS the intended
+    // visible state; prev is the view before these overrides apply. Bypasses
+    // the transition stash — optimism is visible in flight.
+        if (e.pc !== null && e.pc.p !== null) patchHooks.emitPatchOptimistic(e, t, optimisticView(e, i));
+    // Row-ops channel (family increment 2): optimistic STRUCTURE on an array
+    // rides node overrides — it never enters the reconcile walk — so a driven
+    // list must get its structural ops here, lane-timed. Identity diff of the
+    // pre-write optimistic view against the draft; aligned writes emit nothing.
+        if (e.pc !== null && e.pc.ro !== null && Array.isArray(t)) {
+        const n = optimisticView(e, i);
+        if (Array.isArray(n)) {
+            const i = buildIdentityRowOps(n, t);
+            if (i !== null) rowHooks.emitRowOpsOptimistic(e, t, i);
+        }
+    }
     const visible = (t, n) => {
         const i = e.n?.[t];
-        return i !== undefined && hasActiveOverride(i) ? unwrapOverride(i.o?.De) : n;
+        return i !== undefined && hasActiveOverride(i) ? unwrapOverride(i.o?.Oe) : n;
     };
     const visiblePresent = t => {
         const n = e.h?.[t];
-        return n !== undefined && hasActiveOverride(n) ? !!unwrapOverride(n.o?.De) : t in i;
+        return n !== undefined && hasActiveOverride(n) ? !!unwrapOverride(n.o?.Oe) : t in i;
     };
     let o = false;
     const r = Array.isArray(t);
@@ -194,91 +442,22 @@ function createOptimisticStoreNext(e, t, n) {
     // (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;
+    // construction) — restoring any truth-staged backing this draft displaced
+    // (#3164 fold: ensurePB parked it so tentative writes could not pollute
+    // staged truth). Register the root store for the scheduler's settle hooks.
+        e.pb = stagedTruthPB.get(e) ?? null;
+    if (e.pb !== null) stagedTruthPB.delete(e);
     (e.fam.overlaid ??= new Set).add(e);
-    GlobalQueue.In?.(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();
-    });
+    GlobalQueue._n?.(e.fam.px ?? e.px);
 }
 
 /** 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;
+ * RUL-12). Returns `src` untouched when no override is active on `t`.
+ * Authoritative-view reads (until()'s predicate) skip composition entirely:
+ * the predicate observes authoritative truth, never the caller's tentative
+ * overlay. (Write-side emission callers never run under such a compute.) */ function optimisticView(e, t) {
+    if (e.fam?.opt !== true || authoritativeRead()) return t;
     let n = null;
     const ensure = () => n ??= Array.isArray(t) ? [ ...t ] : {
         ...t
@@ -288,7 +467,7 @@ function createOptimisticStoreNext(e, t, n) {
         for (const e of Reflect.ownKeys(i)) {
             const n = i[e];
             if (!hasActiveOverride(n)) continue;
-            const o = unwrapOverride(n.o?.De);
+            const o = unwrapOverride(n.o?.Oe);
             if (e === "length" && Array.isArray(t)) {
                 if (t.length !== o) ensure().length = o;
             } else if (!isEqual(t[e], o)) ensure()[e] = o;
@@ -299,7 +478,7 @@ function createOptimisticStoreNext(e, t, n) {
         for (const e of Reflect.ownKeys(o)) {
             const i = o[e];
             if (!hasActiveOverride(i)) continue;
-            const r = !!unwrapOverride(i.o?.De);
+            const r = !!unwrapOverride(i.o?.Oe);
             if (!r && e in (n ?? t)) delete ensure()[e];
         }
     }
@@ -322,7 +501,9 @@ function applyTentative(e, t, n) {
         if (n) {
             const i = n(e);
             const o = n(t);
-            if (i !== undefined && o !== undefined && i !== o) return null;
+            // SameValueZero (re-audit 3, P1-3): parity with the plain reconcile
+            // channel — NaN keys are self-equal.
+                        if (i !== undefined && o !== undefined && !sameKey(i, o)) return null;
         }
         return r.get(unwrapValue(e)) ?? null;
     };
@@ -337,23 +518,35 @@ function applyTentative(e, t, n) {
                 const t = n(r);
                 if (t !== undefined) {
                     if (i === null) {
+                        // Occurrence-aware index queues (re-audit 3, P1-3): parity with
+                        // the plain adoption window — duplicate keys match per
+                        // occurrence, each view row consumed once.
                         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);
+                                if (e === undefined) continue;
+                                const r = i.get(e);
+                                if (r === undefined) i.set(e, t); else if (Array.isArray(r)) r.push(t); else i.set(e, [ r, t ]);
                             }
                         }
                     }
-                    s = i.get(t);
+                    const o = i.get(t);
+                    if (o === undefined) s = undefined; else if (Array.isArray(o)) {
+                        s = unwrapValue(e[o.shift()]);
+                        if (o.length === 1) i.set(t, o[0]);
+                    } else {
+                        s = unwrapValue(e[o]);
+                        i.delete(t);
+                    }
                 } else s = unwrapValue(e[o]);
             } else s = unwrapValue(e[o]);
-            const c = match(s, r);
-            if (c !== null) {
+            const a = match(s, r);
+            if (a !== null) {
                 // Keep the existing row in the slot (identity preserved); recurse.
                 u[o] = unwrapValue(s);
-                l.push([ c, r ]);
+                l.push([ a, r ]);
             }
         }
     } else {
@@ -369,10 +562,10 @@ function applyTentative(e, t, n) {
     }
     // 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;
+        const a = e.pb;
     e.pb = null;
     notifyOptimisticWrites(e, u);
-    e.pb = c;
+    e.pb = a;
     for (let e = 0; e < l.length; e++) applyTentative(l[e][0], unwrapValue(l[e][1]), n);
 }
 
@@ -382,4 +575,4 @@ function shallowWithSymbols(e) {
     return t;
 }
 
-export { consumeOverridesNext, createOptimisticStoreNext, notifyOptimisticWrites, optimisticView };
+export { createOptimisticStoreNext, notifyOptimisticWrites, optimisticView, transitionHoldsOptimism };

package/dist/prod/store/next/patch-hooks.js

@@ -0,0 +1,13 @@
+let patchHooks = null;
+
+let rowHooks = null;
+
+function installPatchHooks(o) {
+    patchHooks = o;
+}
+
+function installRowHooks(o) {
+    rowHooks = o;
+}
+
+export { installPatchHooks, installRowHooks, patchHooks, rowHooks };