fix(renderer-dom): journal path anchors a removed top row like the replacement path (#491) (#508)

The cooperative replacement path re-anchors a removed viewport-top row to
its nearest surviving OLD-order neighbor (+1, -1, +2, ...), and G3c gave
the synchronous reorder/refilter reset paths the same semantics through
resolveSyncAnchorRef. The incremental journal path, however, still called
restoreAnchorRequest with exact-only resolution: a journaled
applyTransaction that removed the anchored row fell straight to
globalScroll(viewport.scrollTop).

User-visible in a narrow window: one journaled transaction removing the
viewport-top row AND other rows above it makes the journal path keep the
pixel scroll (content jumps) where the replacement path holds the
neighbor - and the SAME logical transaction can reach either path
nondeterministically (journal overflow, an active replacement, or a
misaligned revision all reroute to replacement).

The searchOldNeighbors parameter is deleted rather than flipped: every
synchronous publish now resolves through the same ladder - exact ref
first (O(1), the common case), neighbor search only when the anchored row
is gone; "reorder" structurally never engages it since the row set is
unchanged. The old comment's "pinned behavior" claim was unbacked - no
test pinned the fall-to-global; the new test pins the neighbor semantics
against a forced-replacement oracle instead.

Co-authored-by: Claude Fable 5 <noreply@anthropic.com>

Author: blove

packages/renderer-dom/src/__tests__/indexed-renderer.test.ts

@@ -4399,6 +4399,89 @@ describe("indexed DOM row layout controller", () => {
         expect(controller.getState().rowHeights).toBe(result);
       });
     });
+
+    test("a journaled remove of the anchored row degrades like a full replacement (#491)", () => {
+      // The incremental JOURNAL sibling of "an anchor row filtered out
+      // degrades like a full replacement": one journaled transaction removes
+      // the anchored viewport-top row (row 4) AND a measured row above it
+      // (row 2), so the neighbor-anchored scrollTop and the retained pixel
+      // scrollTop provably differ — the fixture can DISPROVE.
+      //
+      // Anchor inside row 4 (rank 3, offsets 126..170 under the 41..50
+      // measured heights), 4px below its top. Removing rows 2 and 4 makes the
+      // old-order neighbor search (+1 first) land on row 5, whose new rank is
+      // 2 with offset 41 + 43 = 84, so the anchored viewport follows it to
+      // 84 + 4 = 88px. Exact-only resolution falls to the retained pixel
+      // scroll, 130 — the divergence #491 pins shut.
+      const neighborAnchoredScrollTop = 41 + 43 + 4;
+      const retainedPixelScrollTop = 130;
+      expect(neighborAnchoredScrollTop).not.toBe(retainedPixelScrollTop);
+
+      const model = createModel(tenRows);
+      const { controller } = createReadyController(model);
+      for (const [rowId, height] of allMeasurements) {
+        controller.measure(data(rowId), height);
+      }
+      controller.setViewport({
+        scrollTop: retainedPixelScrollTop,
+        viewportHeight: 88,
+        overscan: 0,
+      });
+      expect(controller.getState().scrollTop).toBe(retainedPixelScrollTop);
+      const before = getRowLayoutControllerDiagnosticsForTesting(controller);
+
+      model.applyTransaction({ remove: [2, 4] });
+
+      // Synchronous, and through the JOURNAL path: no replacement started,
+      // and neither synchronous reset fast path fired.
+      const after = controller.getState();
+      expect(after.status.kind).toBe("ready");
+      expect(after.snapshot?.visibleRowCount).toBe(8);
+      expect(after.observedRevision).toBe(model.getState().snapshot.revision);
+      const diagnostics =
+        getRowLayoutControllerDiagnosticsForTesting(controller);
+      expect(diagnostics.replacementStartCount).toBe(
+        before.replacementStartCount,
+      );
+      expect(diagnostics.reorderPathCount).toBe(before.reorderPathCount);
+      expect(diagnostics.refilterPathCount).toBe(before.refilterPathCount);
+      expect(after.scrollTop).toBe(neighborAnchoredScrollTop);
+
+      // The replacement reference. `createReplacementOracle` only rewrites
+      // RESETS, and a journaled transaction never produces one, so this
+      // oracle's `changesSince` reports every range as a bulk-replace reset —
+      // forcing the cooperative replacement over the same commit.
+      const oracleModel = createModel(tenRows);
+      const oracle = createReadyController(oracleModel);
+      for (const [rowId, height] of allMeasurements) {
+        oracle.controller.measure(data(rowId), height);
+      }
+      oracle.controller.setViewport({
+        scrollTop: retainedPixelScrollTop,
+        viewportHeight: 88,
+        overscan: 0,
+      });
+      vi.spyOn(oracleModel, "changesSince").mockImplementation(() => ({
+        kind: "reset" as const,
+        toRevision: oracleModel.getState().snapshot.revision,
+        reason: "bulk-replace" as const,
+      }));
+      const oracleBefore = getRowLayoutControllerDiagnosticsForTesting(
+        oracle.controller,
+      );
+
+      oracleModel.applyTransaction({ remove: [2, 4] });
+      oracle.scheduler.flushAll();
+
+      const reference = oracle.controller.getState();
+      expect(reference.status.kind).toBe("ready");
+      // Prove the oracle really took the replacement path.
+      expect(
+        getRowLayoutControllerDiagnosticsForTesting(oracle.controller)
+          .replacementStartCount,
+      ).toBe(oracleBefore.replacementStartCount + 1);
+      expect(reference.scrollTop).toBe(after.scrollTop);
+    });
   });
 });
 

packages/renderer-dom/src/row-layout-controller.ts

@@ -1992,16 +1992,17 @@ export function createRowLayoutController<
     target: PretableRowModelSnapshot<TRow, TRowId, TColumns>,
     root: RowHeightIndex<PretableVisibleRowRef<TRowId>>,
     anchor: CapturedAnchor<TRowId> | undefined,
-    // The incremental journal path keeps exact-only resolution (its remove
-    // operations already re-anchor via the surviving exact ref or fall to a
-    // global scroll — pinned behavior); the synchronous reset paths opt into
-    // the replacement-mirroring neighbor search above.
-    searchOldNeighbors = false,
   ): ScrollRequest => {
     if (anchor !== undefined) {
-      const resolved = searchOldNeighbors
-        ? resolveSyncAnchorRef(target, anchor)
-        : target.nearestVisibleRef(anchor.heightAnchor.ref);
+      // Every synchronous publish — the incremental journal path and both
+      // reset fast paths — resolves through the replacement-mirroring ladder
+      // above: exact ref first (O(1), the common case), the old-order
+      // neighbor search only when a remove took the anchored row out. A
+      // journaled remove of the viewport-top row therefore anchors its
+      // nearest surviving neighbor exactly as the cooperative replacement
+      // would for the same commit (#491), instead of degrading to a global
+      // pixel scroll.
+      const resolved = resolveSyncAnchorRef(target, anchor);
       if (resolved !== undefined) {
         const index = target.indexOf(resolved);
         if (index >= 0) {
@@ -2113,7 +2114,7 @@ export function createRowLayoutController<
                   // and the replacement path would re-anchor its nearest
                   // OLD-order neighbor. Under "reorder" the exact ref always
                   // survives and the search never engages.
-                  restoreAnchorRequest(target, root, anchor, true),
+                  restoreAnchorRequest(target, root, anchor),
                 );
                 // Mirrors `finishReplacement`'s commit: a deferred viewport is
                 // applied by the publish above (it reads the live `viewport`),