fix(signals): unchanged store key read under an adoption hold does not hold the reader (#3706)

A derived store adopting a new backing while a transaction is still open
puts the whole container under an adoption hold, and readSource's
adoption-hold arm entered every deriving read of that container into the
transaction, whichever key was read. In the report, confirming one
optimistic move while another was pending landed the authoritative array
under the still-open shared transaction, and a memo reading
`drag() === cards[0].id` beside an independent `drag` signal was held until
the second move settled, so isPending(drag) went true. The other two
reproductions (a nested <Show> preview over `cards.find(...)`, and a single
action writing rows before its yield with the preview mounting afterwards)
reach the same arm through an inherited array method and through a row
first read after the adoption.

The arm now compares the read key across the held and adopted backings
(own on both, never an accessor, the store's slot equality so a
re-ingested row is the same logical slot; or own on neither with the same
prototype). A child slot nobody read before the adoption has no target to
compare, so it is materialized under the parent's hold with the old raw as
its held view and its own leaves decide: sameLogicalSlot recognizes such a
child through that held view, and the parent's slot node is seeded with
the adopted raw so the reader is served that child. A key that reads the
same from either backing derives nothing from the hold and takes the
ordinary pending-backing selection with no transaction entry and no stale
replay. This is the adoption twin of the fold gate's written-key scoping
(#3688). Keyless reads, chained backings, a chained held view, optimistic
families, shallow stores, raw-marked values, relocated rows and descriptor
reads whose flags changed keep the whole-container hold.

Size: +765 B minified on the store read path; brotli +149..+224 B, four caps
ratcheted (+ createStore 16.71 -> 16.94 KB, hydrating + every store
30.63 -> 30.80 KB, base page 44.93 -> 45.02 KB, live page 49.10 -> 49.28 KB).

Author: brenelz

.changeset/fix-store-adoption-unchanged-key-read-hold.md

@@ -0,0 +1,5 @@
+---
+"@solidjs/signals": patch
+---
+
+Reading a store key a derived store's adoption left unchanged no longer holds the reader with the transaction that adopted it (#3706). Confirming one optimistic move while another was pending landed the authoritative array on the derived base store under the still-open transaction, and the adoption-hold arm of `readSource` entered every deriving read of that container into the transaction: a memo reading `drag() === cards[0].id` beside an independent `drag` signal was held until the second move settled, and `isPending(drag)` went true. The arm now compares the key across the held and adopted backings with the store's slot equality (a re-ingested row is the same logical slot): a key that reads the same from either is served with no entry and no stale replay, the adoption twin of the fold gate's written-key scoping (#3688). Keyless reads (`ownKeys`, `$TRACK`, `deep()`), chained backings and optimistic families keep the whole-container hold.

packages/signals/docs/RULES-INDEX.md

@@ -73,7 +73,7 @@ Status legend: **live** stated and standing · **ruled** carries an explicit rul
 | A26 | ruled | `docs/SPEC-ASYNC-SEMANTICS.md:67` | core.ts×1 scheduler.ts×1 store.ts×1 | action-await-contract.test.ts×2 posture-store-parity.test.ts×2 visibility-oracle-store.states.ts×2 visibility-oracle.states.ts×1 visibility-oracle.test.ts×1 | [ruled 2026-07-17] An ambient transaction window is one flush; parking is flush-driven — (**ruled 2026-07-17**, #2913; **enforcement hardened 2026-08-31**, #3141 — parking is flush-driven, and a trans… |
 | A27 | ruled | `docs/SPEC-ASYNC-SEMANTICS.md:245` | — | loading-value.test.ts×2 visibility-oracle.states.ts×18 visibility-oracle.test.ts×1 | [ruled 2026-08-10] The commit-#0 loading window is loading-class and verdict-quiet — (**ruled 2026-08-10**) **The commit-#0 loading window is loading-class and verdict-quiet.** A node born committed v… |
 | A28 | ruled, mechanism landed | `docs/SPEC-ASYNC-SEMANTICS.md:51` | constants.ts×2 core.ts×20 optimistic.ts×2 scheduler.ts×3 types.ts×1 verdict.ts×6 optimistic.ts×3 store.ts×1 | createOptimistic.test.ts×5 held-derivation-not-a-proposal-3612.test.ts×1 latest-held-till-flush.test.ts×1 optimistic-store-layer-scope.test.ts×1 posture-store-parity.test.ts×5 question-scoped-pending.test.ts×3 snapshot-derived-store-rows.test.ts×1 createOptimisticStore.test.ts×10 optimistic-draft-visibility-3665.test.ts×5 optimistic-list-mutation-matrix.harness.ts×1 optimistic-list-mutation-matrix.test.ts×2 shallow.test.ts×1 woken-transaction-adopts-staged-bump.test.ts×1 treeshake.test.ts×2 visibility-oracle-store.states.ts×8 visibility-oracle.states.ts×8 | [ruled, mechanism landed 2026-09-15] A write becomes visible at flush — to every channel — (**ruled 2026-09-08**; supersedes the #2922 mid-tick pull) **A write becomes visible at flush — to every chan… |
-| A29 | amended | `docs/SPEC-ASYNC-SEMANTICS.md:75` | boundaries.ts×1 action.ts×1 async.ts×1 constants.ts×1 core.ts×8 effect.ts×1 optimistic.ts×1 scheduler.ts×2 signals.ts×1 store.ts×5 | body-end-supersession-visibility.test.ts×1 born-held.test.ts×3 boundary-not-born-held-3540.test.ts×4 direct-commit-readers-posture.test.ts×1 held-conditional-memo.test.ts×1 held-frame-dependencies.test.ts×2 held-truth-lane-only.test.ts×3 latest-held-till-flush.test.ts×2 optimistic-read-lane-not-transaction-3698.test.ts×3 posture-store-parity.test.ts×6 optimistic-untracked-reads-f3-f5.test.ts×1 store-unchanged-read-independent-write-3688.test.ts×1 treeshake.test.ts×3 visibility-oracle-store.states.ts×5 visibility-oracle-store.test.ts×1 visibility-oracle.states.ts×7 visibility-oracle.test.ts×1 write-proposals-3494.test.ts×1 | [ruled, amended in place 2026-09-13 (#3408)] A tracked read served a live transaction's staged value enters that transaction — A tracked computation served a node's staged `_pendingValue` — a value a … |
+| A29 | amended | `docs/SPEC-ASYNC-SEMANTICS.md:75` | boundaries.ts×1 action.ts×1 async.ts×1 constants.ts×1 core.ts×8 effect.ts×1 optimistic.ts×1 scheduler.ts×2 signals.ts×1 store.ts×5 | adoption-unchanged-key-read-3706.test.ts×7 body-end-supersession-visibility.test.ts×1 born-held.test.ts×3 boundary-not-born-held-3540.test.ts×4 direct-commit-readers-posture.test.ts×1 held-conditional-memo.test.ts×1 held-frame-dependencies.test.ts×2 held-truth-lane-only.test.ts×3 latest-held-till-flush.test.ts×2 optimistic-read-lane-not-transaction-3698.test.ts×3 posture-store-parity.test.ts×6 optimistic-untracked-reads-f3-f5.test.ts×1 store-unchanged-read-independent-write-3688.test.ts×1 treeshake.test.ts×3 visibility-oracle-store.states.ts×5 visibility-oracle-store.test.ts×1 visibility-oracle.states.ts×7 visibility-oracle.test.ts×1 write-proposals-3494.test.ts×1 | [ruled, amended in place 2026-09-13 (#3408)] A tracked read served a live transaction's staged value enters that transaction — A tracked computation served a node's staged `_pendingValue` — a value a … |
 | A30 | ruled | `docs/SPEC-ASYNC-SEMANTICS.md:207` | async.ts×3 attribution.ts×1 constants.ts×1 core.ts×3 effect.ts×1 scheduler.ts×5 | async-landing-deps-3461.test.ts×3 held-conditional-effect.test.ts×1 held-conditional-memo.test.ts×1 held-frame-dependencies.test.ts×2 ispending-in-boundary-on-3528.test.ts×1 lane-frame-deferred-run-3662.test.ts×1 lane-frame-held-lane-3662.test.ts×1 posture-born-held-and-observation.test.ts×1 treeshake.test.ts×2 write-proposals-3494.test.ts×2 zombie-rerun-after-commit-3546.test.ts×2 | [ruled 2026-09-13 (#3410)] A memo's dependencies are the committed frame's until the frame is replaced — A pass that _staged_ its value has not replaced the committed frame, so the committed value sti… |
 | A31 | live | `docs/SPEC-ASYNC-SEMANTICS.md:83` | core.ts×2 | ispending-combined-atomic-3442.test.ts×1 | [live 2026-09-14 (#3442)] A memo computes under its own lane posture, never its puller's — A memo's value is one shared slot every reader sees, so its pass runs under the lane posture the memo itself … |
 | A32 | ruled | `docs/SPEC-ASYNC-SEMANTICS.md:91` | core.ts×1 store.ts×1 | visibility-oracle-store.states.ts×8 visibility-oracle-store.test.ts×1 visibility-oracle.states.ts×9 visibility-oracle.test.ts×1 | [ruled 2026-09-14] Children-forbidden readers see the frame, not the graph — `createTrackedEffect` and `onSettled` callbacks are effect-phase code that runs after the frame is decided. They read the f… |

packages/signals/src/store/next/store.ts

@@ -310,8 +310,13 @@ export function getNode(
     //    committed is the held view `hv[key]`, staged is `v[key]`.
     const fold = heldFoldTransition(target);
     let held = heldAdoptionTransition(target);
-    if (held !== null) current = (target.hv as any)[key];
-    else if ((held = fold) !== null) current = (target.v as any)[key];
+    if (held !== null) {
+      current = (target.hv as any)[key];
+      // A slot-equal adopted raw is the one to wrap: a child materialized
+      // under the hold is registered for it alone (#3706).
+      const nv = (target.v as any)[key];
+      if (sameLogicalSlot(target, current, nv)) current = nv;
+    } else if ((held = fold) !== null) current = (target.v as any)[key];
     // Create-floor diet: slotSignal bakes the whole node into one literal —
     // no options object, no equals/unobserved closures, no NodeExtension,
     // no post-construction expandos (acc + the wrap cache px/pxv are
@@ -437,6 +442,47 @@ function holdVisible(txn: Transition | null, c: Computed<any>): boolean {
   return true;
 }
 
+// #3706: the adoption twin of the fold gate's written-key scoping (#3688).
+function adoptionKeyUnchanged(target: StoreNextTarget, key: PropertyKey, desc?: boolean): boolean {
+  const hv = target.hv!;
+  const v = target.v;
+  if (target.ch || target.fam?.opt === true || (hv as any)[$TARGET] !== undefined) return false;
+  const own = hasOwn.call(hv, key);
+  if (own !== hasOwn.call(v, key)) return false;
+  // Absent on both (a prototype method, an out-of-range index) reads alike.
+  if (!own) return Object.getPrototypeOf(hv) === Object.getPrototypeOf(v);
+  // Accessors are never invoked here; a descriptor read compares the flags too.
+  if (isOwnAccessor(hv, key) || isOwnAccessor(v, key)) return false;
+  if (desc) {
+    const od = Object.getOwnPropertyDescriptor(hv, key)!;
+    const nd = Object.getOwnPropertyDescriptor(v, key)!;
+    if (od.enumerable !== nd.enumerable || od.writable !== nd.writable) return false;
+  }
+  const a = hv[key as any];
+  const b = v[key as any];
+  if (isEqual(a, b) || sameLogicalSlot(target, a, b)) return true;
+  // A child slot nobody read before the adoption has no target to compare:
+  // materialize it under the parent's hold so its own leaves decide (#3706).
+  // Never for a shallow store or a raw-marked value (the reference IS the
+  // value there), and never across kinds; a relocated row keeps its hold.
+  if (
+    target.s ||
+    !isWrappable(a) ||
+    !isWrappable(b) ||
+    Array.isArray(a) !== Array.isArray(b) ||
+    (a as any)[$TARGET] !== undefined ||
+    (b as any)[$TARGET] !== undefined ||
+    (rawValuesUsed && (isRawValue(a) || isRawValue(b))) ||
+    lookupTarget(a, target.fam) !== undefined ||
+    lookupTarget(b, target.fam) !== undefined
+  )
+    return false;
+  const child = createTarget(b, target, key, target.fam);
+  child.hv = a;
+  child.ht = target.ht;
+  return true;
+}
+
 function stageHeldKey(node: Signal<any>, nv: any, txn: Transition): void {
   if (slotNodeEquals.call(node, node._value, nv)) return;
   node._pendingValue = nv;
@@ -448,7 +494,10 @@ function stageHeldKey(node: Signal<any>, nv: any, txn: Transition): void {
 function sameLogicalSlot(target: StoreNextTarget, a: any, b: any): boolean {
   if (a === null || typeof a !== "object" || b === null || typeof b !== "object") return false;
   const at = lookupTarget(a, target.fam);
-  return at !== undefined && at === lookupTarget(b, target.fam);
+  const bt = lookupTarget(b, target.fam);
+  // A child materialized under its parent's hold keeps the old raw as its
+  // held view (#3706): the slot it was read at, not a relocation.
+  return at === undefined ? bt !== undefined && bt.hv === a : at === bt;
 }
 
 /**
@@ -1785,8 +1834,13 @@ function foldHeld(target: StoreNextTarget): boolean {
 }
 
 /** The backing a reader is served. `key` (the get/has/descriptor traps)
- * scopes a fold hold to the keys the fold touched — see pendingBackingVisible. */
-function readSource(target: StoreNextTarget, key?: PropertyKey): Record<PropertyKey, any> {
+ * scopes a fold hold to the keys the fold touched — see pendingBackingVisible —
+ * and an adoption hold to the keys the adoption changed (adoptionKeyUnchanged). */
+function readSource(
+  target: StoreNextTarget,
+  key?: PropertyKey,
+  desc?: boolean
+): Record<PropertyKey, any> {
   // Adoption hold first (#3074): an adoption staged under a live transaction
   // (or a latest()-pull, PLAIN_HOLD) serves the pre-hold committed view to
   // committed-visibility readers — context-free and children-forbidden ones,
@@ -1797,11 +1851,11 @@ function readSource(target: StoreNextTarget, key?: PropertyKey): Record<Property
     const hv = heldMaskView(target);
     if (hv !== null) {
       const c = readerContext();
-      if (
-        c === null ||
-        c._config & CONFIG_CHILDREN_FORBIDDEN ||
-        !holdVisible(ht === PLAIN_HOLD ? null : currentTransition(ht as Transition), c)
-      )
+      if (c === null || c._config & CONFIG_CHILDREN_FORBIDDEN) return hv;
+      // A key the adoption left unchanged derives nothing from the hold (#3706).
+      if (key !== undefined && adoptionKeyUnchanged(target, key, desc))
+        return pendingBackingVisible(target, false, key) ? target.pb! : target.v;
+      if (!holdVisible(ht === PLAIN_HOLD ? null : currentTransition(ht as Transition), c))
         return hv;
     }
   }
@@ -2444,7 +2498,7 @@ const traps: ProxyHandler<StoreNextTarget> = {
     if (pendingCheckActive) witnessAffectsMark(target as any, key);
     const obs = getObserver();
     if (target.fam !== null && obs === null && !inDraft(target)) firewallGate(target);
-    const src = readSource(target, key);
+    const src = readSource(target, key, true);
     const desc = visibleDescriptor(target, src, key);
     if (!inDraft(target) && obs !== null && !observerHoldsKeySet(target, obs)) {
       // The node is born from the source's presence (as `has` births it),