fix: save staged edits for rows loaded via infinite scroll (#1545)

* fix: save staged edits for rows loaded via infinite scroll

With infinite scroll enabled, the grid queries pageIndex 0 with a grown
pageSize window (25-row batches), but the row mutation hooks resolved
their TanStack DB collection from the paginated pageIndex/pageSize. The
two query scopes diverge once more than one batch is loaded, so
collection.update() targeted a collection missing rows beyond the first
batch and threw UpdateKeyNotFoundError, making "Save n rows" fail
silently (issue #1466).

The mutation hooks (update, updateMany, delete, insert) now receive the
view's exact query props and resolve their collection through the new
useActiveTableQueryCollection hook, so mutations always target the same
collection scope the grid displays — including the search term
dimension that was previously omitted as well.

Verified end-to-end in the ppg demo: editing and deleting rows beyond
the first 25-row batch with infinite scroll enabled now persists and
shows the success toast.

Co-Authored-By: Claude Fable 5 <noreply@anthropic.com>

* fix: address PR #1545 review feedback

- useActiveTableUpdate: drop the ignored AdapterUpdateOptions/table params
  from UseActiveTableUpdateParams. Persistence is delegated to the rows
  collection's onUpdate handler, so a per-call options channel could never
  reach the adapter; removing it makes that explicit instead of silently
  ignoring the values (API migration; the hook has no product callers).

- ActiveTableView: keep row mutations targeting the visible window during
  infinite-scroll growth. While a grown window is fetching, the grid keeps
  showing the previous settled window; mutation query props now stay pinned
  to that settled window and swap to the grown scope atomically together
  with the rows (new resolveVisibleTableWindow helper + tests), closing the
  save/delete race during the transition.

Co-Authored-By: Claude Fable 5 <noreply@anthropic.com>

---------

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

Author: sorenbs

.changeset/tidy-lions-tap.md

@@ -0,0 +1,5 @@
+---
+"@prisma/studio-core": patch
+---
+
+Fix saving staged cell edits silently failing for rows loaded beyond the first batch when infinite scroll is enabled. Row update, delete, and insert mutations now target the same rows-collection scope the grid displays instead of the paginated first page.

Architecture/db-state.md

@@ -185,6 +185,26 @@ There is currently no `onInsert` optimistic handler in the rows collection. Do n
 - Views MUST use `useActiveTableDelete` for row deletion.
 - Views MUST NOT call adapter query/update/delete directly.
 
+### Mutation scope alignment
+
+Row mutation hooks (`useActiveTableUpdate`, `useActiveTableUpdateMany`,
+`useActiveTableDelete`, `useActiveTableInsert`) take the view's query props
+(`UseActiveTableQueryProps`) and resolve their collection through
+`useActiveTableQueryCollection`. The view MUST pass the exact same query props
+it uses for display, so mutations target the `queryScopeKey` that actually
+contains the visible rows. With infinite scroll enabled that scope is
+`pageIndex: 0` with the grown batch-window `pageSize`, not the paginated page —
+deriving mutation scope independently (for example from `usePagination`) makes
+`collection.update`/`collection.delete` silently miss rows loaded beyond the
+first batch.
+
+While a grown infinite-scroll window is still fetching, the grid keeps showing
+the previous settled window. During that transition the view MUST keep the
+mutation query props pinned to the settled window too:
+`resolveVisibleTableWindow` pairs the visible rows with the query props of the
+scope they were loaded from, and both swap to the grown window atomically once
+its query finishes.
+
 ## Lifecycle Rules
 
 Studio context owns collection lifecycle:

FEATURES.md

@@ -182,6 +182,7 @@ When the ledger has migrations but no contract snapshots to diff (a database wri
 Table data is shown in a grid with server-backed pagination, filtered-row counts, loading feedback, and explicit empty states.
 The footer keeps page navigation, a page jump field, a fixed rows-per-page dropdown, and infinite-scroll mode in one compact control group, so users can either jump directly to a page, switch page density from a known preset, or turn on lazy-loading without leaving the grid.
 Rows-per-page and infinite-scroll preferences persist across tables through local storage, while the known filtered-row count keeps the footer stable during page transitions for the same filtered result set. Infinite scroll preloads before the hard bottom edge, always appends in fixed 25-row chunks regardless of the paginated page-size setting, keeps filling tall viewports until the grid is actually scrollable, and appends new rows in place without snapping the grid back to the top.
+Row editing, deletion, and insertion operate on the same loaded row window the grid displays, so with infinite scroll enabled staged cell edits save correctly even for rows loaded beyond the first 25-row batch.
 Rapid sort and filter changes keep the latest request authoritative, and superseded table reads are aborted so a slower older result cannot overwrite the visible grid.
 
 ## Table Row Count Display

ui/hooks/use-active-table-delete.ts

@@ -1,20 +1,13 @@
 import { useMutation } from "@tanstack/react-query";
 
-import { useActiveTableRowsCollection } from "./use-active-table-rows-collection";
-import { useFiltering } from "./use-filtering";
-import { usePagination } from "./use-pagination";
-import { useSorting } from "./use-sorting";
+import {
+  useActiveTableQueryCollection,
+  type UseActiveTableQueryProps,
+} from "./use-active-table-query";
 
-export function useActiveTableDelete() {
-  const { paginationState } = usePagination();
-  const { sortingState } = useSorting();
-  const { appliedFilter } = useFiltering();
-  const { activeTable, collection, refetch } = useActiveTableRowsCollection({
-    pageIndex: paginationState.pageIndex,
-    pageSize: paginationState.pageSize,
-    sortOrder: sortingState,
-    filter: appliedFilter,
-  });
+export function useActiveTableDelete(query: UseActiveTableQueryProps) {
+  const { activeTable, collection, refetch } =
+    useActiveTableQueryCollection(query);
   const { schema = null, name: table = null } = activeTable ?? {};
 
   return useMutation({

ui/hooks/use-active-table-insert.ts

@@ -1,23 +1,15 @@
 import { useMutation } from "@tanstack/react-query";
 
 import { useStudio } from "../studio/context";
-import { useActiveTableRowsCollection } from "./use-active-table-rows-collection";
-import { useFiltering } from "./use-filtering";
-import { usePagination } from "./use-pagination";
-import { useSorting } from "./use-sorting";
+import {
+  useActiveTableQueryCollection,
+  type UseActiveTableQueryProps,
+} from "./use-active-table-query";
 import { addRowIdToResult } from "./utils/add-row-id-to-result";
 
-export function useActiveTableInsert() {
+export function useActiveTableInsert(query: UseActiveTableQueryProps) {
   const { adapter, onEvent } = useStudio();
-  const { paginationState } = usePagination();
-  const { sortingState } = useSorting();
-  const { appliedFilter } = useFiltering();
-  const { activeTable, refetch } = useActiveTableRowsCollection({
-    pageIndex: paginationState.pageIndex,
-    pageSize: paginationState.pageSize,
-    sortOrder: sortingState,
-    filter: appliedFilter,
-  });
+  const { activeTable, refetch } = useActiveTableQueryCollection(query);
   const { schema = null, name: table = null } = activeTable ?? {};
 
   return useMutation({

ui/hooks/use-active-table-query.ts

@@ -4,7 +4,10 @@ import type {
   SortOrderItem,
   Table,
 } from "../../data/adapter";
-import { useActiveTableRowsCollection } from "./use-active-table-rows-collection";
+import {
+  type ActiveTableRowsCollectionState,
+  useActiveTableRowsCollection,
+} from "./use-active-table-rows-collection";
 import { useNavigation } from "./use-navigation";
 
 export interface UseActiveTableQueryProps {
@@ -27,9 +30,16 @@ export interface UseActiveTableQueryResult {
   refetch: () => Promise<void>;
 }
 
-export function useActiveTableQuery(
+/**
+ * Resolves the rows-collection state for the exact query scope described by
+ * `props`. Row mutation hooks must resolve their collection through this hook
+ * with the same query props the view uses for display, so mutations target the
+ * collection that actually contains the visible rows (for example the grown
+ * `pageIndex: 0` window used by infinite scroll).
+ */
+export function useActiveTableQueryCollection(
   props: UseActiveTableQueryProps,
-): UseActiveTableQueryResult {
+): ActiveTableRowsCollectionState {
   const { filter, pageIndex, pageSize, sortOrder } = props;
   const {
     metadata: { activeTable },
@@ -39,13 +49,20 @@ export function useActiveTableQuery(
     searchScope: props.searchScope ?? "table",
     searchTerm: props.searchTerm ?? "",
   });
-  const state = useActiveTableRowsCollection({
+
+  return useActiveTableRowsCollection({
     filter,
     fullTableSearchTerm,
     pageIndex,
     pageSize,
     sortOrder,
   });
+}
+
+export function useActiveTableQuery(
+  props: UseActiveTableQueryProps,
+): UseActiveTableQueryResult {
+  const state = useActiveTableQueryCollection(props);
 
   return {
     data: state.activeTable