@jielga/tmdatagrid 2.0.0-beta.9 → 2.0.0

package/src/{tmdatagrid/core → core}/editEngine.ts

@@ -5,7 +5,7 @@ import {
   type AnyFormApi,
   type StandardSchemaV1,
 } from "@tanstack/react-form";
-import { batch, Store } from "@tanstack/store";
+import { Store } from "@tanstack/store";
 import type { Cell, Column, Row, RowData } from "@tanstack/react-table";
 import type { ComponentType } from "react";
 import type { TMDataGridRowData } from "../TMDataGridContext";
@@ -115,8 +115,10 @@ export type TMDataGridTableValidateArgs<
 /**
  * `editing.tableValidators` - rules that need the other rows: no duplicate
  * keys, no overlapping ranges, allocations summing to a total. Run at every
- * commit, after the row's own validators, and again per parked row during
- * `saveDrafts` - so a draft invalidated by a later edit blocks the save.
+ * commit, after the row's own validators, and again per committed row during
+ * `saveDrafts`, the only rules that run there - a committed row a later edit
+ * invalidated is reopened with the error, and the save reports it in
+ * `reopened`.
  *
  * Return nothing to pass, a message, or Form's `{ form, fields }` shape;
  * pathed issues land on the committing row's cells, pathless ones on the row.
@@ -194,20 +196,22 @@ export type TMDataGridEditState = {
    */
   active: { rowId: string; columnId: string | null } | null;
   /**
-   * Rows with a live form, committed or not - every row the grid is holding
-   * work for. A row is *open* (undecided form state) when it is in here and
-   * not in {@link committedRowIds}.
+   * Every row the grid is holding work for: open rows, whose form is still
+   * undecided, and committed rows, whose values wait in the draft store. In
+   * the order the rows first entered; a reopen keeps a row's place. A row is
+   * *open* when it is in here and not in {@link committedRowIds}, or, for an
+   * entry row, not flagged `committed` in {@link newRows}.
    */
   openRowIds: ReadonlyArray<string>;
   rows: Record<string, TMDataGridEditRowProjection>;
   /**
-   * The draft store's edit slice: existing rows whose form passed its submit
-   * and is parked, waiting for `saveDrafts`. A subset of `openRowIds` - the
-   * values stay in the row's form, this records which side of the line the
-   * row is on. `begin` on one of these takes it back out, into form state.
+   * The draft store's edit slice: existing rows that passed their commit and
+   * wait for `saveDrafts`. A committed row is data, not a form: its values
+   * are in {@link committedValues}, and `begin` on one of these builds a
+   * fresh form from them and takes the row back out.
    *
-   * Only `editing.draft` parks. Without it a commit goes straight to the
-   * consumer and the form is dropped, so this stays empty.
+   * Only `editing.draft` commits into the store. Without it a commit goes
+   * straight to the consumer, so this stays empty.
    */
   committedRowIds: ReadonlyArray<string>;
   /**
@@ -223,12 +227,21 @@ export type TMDataGridEditState = {
   /**
    * Rows being created, not yet in `data`. `committed` is the draft store's
    * add slice: the entry row passed its submit and renders as a value row
-   * until `begin` re-opens it. Without `editing.draft` a commit adds through
-   * `onRowAdd` and the entry is dropped, so it never turns `true`.
+   * from {@link committedValues} until `begin` re-opens it. Without
+   * `editing.draft` a commit adds through `onRowAdd` and the entry is
+   * dropped, so it never turns `true`.
    */
   newRows: ReadonlyArray<{ tempId: string; committed: boolean }>;
   /** The draft store's delete slice: rows marked deleted, awaiting the save. */
   deletedRowIds: ReadonlyArray<string>;
+  /**
+   * `true` while `saveDrafts` is in flight - from the call until the
+   * consumer's callbacks (`onSaveDrafts`, or the per-row `onCommit` /
+   * `onRowAdd` / `onRowDelete` loop) have settled. Concurrent `saveDrafts`
+   * calls join the same run, so it flips once per run. It stays `false` for
+   * a save that finds nothing to send.
+   */
+  isSaving: boolean;
 };
 
 const EMPTY_EDIT_STATE: TMDataGridEditState = {
@@ -239,29 +252,54 @@ const EMPTY_EDIT_STATE: TMDataGridEditState = {
   committedValues: {},
   newRows: [],
   deletedRowIds: [],
+  isSaving: false,
 };
 
 /**
  * The rows still *open*: holding a live form nobody has decided yet.
  *
  * Narrower than {@link TMDataGridEditState.openRowIds}, which is every row
- * with a form, the parked ones included. A row qualifies here when it is not
- * parked in the draft store and there is something to lose - an entered row
- * always counts, an existing one only once a value has moved.
+ * the grid holds, the committed ones included. A row qualifies here when it
+ * is not committed in the draft store and there is something to lose - an
+ * entered row always counts, an existing one only once a value has moved.
  *
  * The order is the engine's: the order the forms were opened.
  */
 export function getOpenRowIds(
   state: TMDataGridEditState,
 ): ReadonlyArray<string> {
-  return state.openRowIds.filter(
-    (rowId) =>
-      !state.committedRowIds.includes(rowId) &&
-      !state.newRows.some(
-        (newRow) => newRow.tempId === rowId && newRow.committed,
-      ) &&
-      (state.newRows.some((newRow) => newRow.tempId === rowId) ||
-        (state.rows[rowId]?.dirtyFields.length ?? 0) > 0),
+  const committed = new Set(state.committedRowIds);
+  const entered = new Map(
+    state.newRows.map((newRow) => [newRow.tempId, newRow.committed]),
+  );
+  return state.openRowIds.filter((rowId) => {
+    if (committed.has(rowId)) return false;
+    const entryCommitted = entered.get(rowId);
+    if (entryCommitted !== undefined) return !entryCommitted;
+    return (state.rows[rowId]?.dirtyFields.length ?? 0) > 0;
+  });
+}
+
+/**
+ * Whether the grid holds anything a navigation would lose: an open row with
+ * a moved value, an entry row, the draft store (edits, new rows, deletion
+ * marks), or a save still in flight.
+ *
+ * A pure selector over the edit state, so `useSelector(edit.store,
+ * hasPendingEdits)` re-renders only when the answer flips, and a navigation
+ * blocker can read `hasPendingEdits(edit.state)` at the moment it is asked.
+ * `isSaving` counts because the default per-row loop takes the deletion
+ * marks out of the store before its `onRowDelete` calls settle.
+ */
+export function hasPendingEdits(state: TMDataGridEditState): boolean {
+  return (
+    state.isSaving ||
+    state.committedRowIds.length > 0 ||
+    state.deletedRowIds.length > 0 ||
+    state.newRows.length > 0 ||
+    state.openRowIds.some(
+      (rowId) => (state.rows[rowId]?.dirtyFields.length ?? 0) > 0,
+    )
   );
 }
 
@@ -348,15 +386,16 @@ export type TMDataGridEditValueMap = (
  * `meta.type` and `meta.options` stay outside this namespace on purpose: one
  * declaration of each feeds the cell editor and the filter panel alike.
  */
-export type TMDataGridColumnEditOptions = {
+export type TMDataGridColumnEditOptions<
+  TData extends RowData = TMDataGridRowData,
+> = {
   /**
    * Whether this column's cells take edits, once `editMode` is on. `false`
    * switches the column off outright; a predicate decides per row. Defaults
    * to editable for any column that maps to a field - see {@link field}.
+   * `row` is typed by the column helper the column was declared with.
    */
-  enabled?:
-    | boolean
-    | ((row: Row<TMDataGridFeatures, TMDataGridRowData>) => boolean);
+  enabled?: boolean | ((row: Row<TMDataGridFeatures, TData>) => boolean);
   /**
    * The data path this column edits, when it is not the `accessorKey` - the
    * only way a column built on `accessorFn` becomes editable. Dot paths reach
@@ -407,10 +446,6 @@ export type TMDataGridSaveDraftsArgs<TData extends RowData> = {
   created: Array<TMDataGridRowAddArgs<TData>>;
   /** Ids marked deleted while the drafts accumulated. */
   deleted: Array<string>;
-  /** @deprecated Renamed to {@link updated}. Removed in a later beta. */
-  rows: Array<TMDataGridEditCommitArgs<TData>>;
-  /** @deprecated Renamed to {@link created}. Removed in a later beta. */
-  added: Array<TMDataGridRowAddArgs<TData>>;
 };
 
 /**
@@ -429,7 +464,7 @@ export type TMDataGridSaveOutcomes = boolean | Record<string, boolean>;
  * with nothing beyond the state itself - a failed edit keeps `data-draft`,
  * a failed deletion keeps `data-deleted` - so the display is the consumer's.
  */
-export type TMDataGridSaveDraftsResult = {
+export type TMDataGridSaveDraftsResponse = {
   /** Keyed by `rowId`. */
   updated?: TMDataGridSaveOutcomes;
   /** Keyed by `tempId`. */
@@ -448,13 +483,6 @@ function isSaved(
   return outcomes[id] !== false;
 }
 
-/**
- * @deprecated Renamed to {@link TMDataGridSaveDraftsArgs} - the payload is
- * the draft store being saved, not a commit. Removed in a later beta.
- */
-export type TMDataGridEditCommitDraftsArgs<TData extends RowData> =
-  TMDataGridSaveDraftsArgs<TData>;
-
 /** What the engine reads fresh on every call - see `createEditEngine`. */
 export type TMDataGridEditEngineContext = {
   table: TMDataGridTable<TMDataGridRowData>;
@@ -476,8 +504,8 @@ export type TMDataGridEditEngineContext = {
     args: TMDataGridSaveDraftsArgs<TMDataGridRowData>,
   ) =>
     | void
-    | TMDataGridSaveDraftsResult
-    | Promise<void | TMDataGridSaveDraftsResult>;
+    | TMDataGridSaveDraftsResponse
+    | Promise<void | TMDataGridSaveDraftsResponse>;
   /**
    * Seed values for `addRow`, under the values it is called with. A function
    * is called per added row.
@@ -537,6 +565,8 @@ export type TMDataGridAddRowsOptions = {
 
 /** What `edit.addRows` reports back. Every added row is in exactly one list. */
 export type TMDataGridAddRowsResult = {
+  /** `true` when every added row committed - `open` is empty. */
+  ok: boolean;
   /** Temp ids that committed - parked as drafts, or added outright. */
   committed: Array<string>;
   /**
@@ -546,6 +576,68 @@ export type TMDataGridAddRowsResult = {
   open: Array<string>;
 };
 
+/**
+ * What `edit.commitAll` reports back. Every row that was open at the call is
+ * in exactly one list; ids are row ids, and temp ids for entry rows.
+ */
+export type TMDataGridCommitAllResult = {
+  /** `true` when every open row committed - `open` is empty. */
+  ok: boolean;
+  /**
+   * Rows whose `commit` resolved `true` - into the draft store under
+   * `editing.draft`, out to the consumer without it, or closed with nothing
+   * to save.
+   */
+  committed: Array<string>;
+  /**
+   * Rows still open, carrying their errors: validation failed, or without
+   * `editing.draft` the consumer's `onCommit` / `onRowAdd` threw.
+   */
+  open: Array<string>;
+};
+
+/**
+ * What `edit.saveDrafts` reports back. Ids are row ids, and temp ids for new
+ * rows; edits, new rows and deletions are mixed in each list. Every id the
+ * save took from the draft store is in exactly one list. Rows open at the
+ * call are not part of the save and are in none.
+ */
+export type TMDataGridSaveDraftsResult = {
+  /** `true` when nothing was kept or reopened. */
+  ok: boolean;
+  /** Left the draft store - the consumer accepted it. */
+  saved: Array<string>;
+  /**
+   * Still in the draft store, still committed, and sent again by the next
+   * save: an id `onSaveDrafts` reported as failed, every id it was sent
+   * when it threw, or, without `onSaveDrafts`, a deletion whose
+   * `onRowDelete` threw.
+   */
+  kept: Array<string>;
+  /**
+   * Out of the draft store and open again, carrying an error: a table rule
+   * now rejects the row, or, without `onSaveDrafts`, the row's own
+   * `onCommit` / `onRowAdd` threw.
+   */
+  reopened: Array<string>;
+};
+
+/**
+ * Splits ids by the `commit` each one got - the shape `addRows` and
+ * `commitAll` share. `results[index]` answers for `ids[index]`; order is kept.
+ */
+function splitCommitted(
+  ids: ReadonlyArray<string>,
+  results: ReadonlyArray<boolean>,
+): { ok: boolean; committed: Array<string>; open: Array<string> } {
+  const committed: Array<string> = [];
+  const open: Array<string> = [];
+  ids.forEach((id, index) => {
+    (results[index] ? committed : open).push(id);
+  });
+  return { ok: open.length === 0, committed, open };
+}
+
 /** One row of {@link TMDataGridEditApi.getRows}. */
 export type TMDataGridEditRowSnapshot<
   TData extends RowData = TMDataGridRowData,
@@ -563,9 +655,11 @@ export type TMDataGridEditRowSnapshot<
 /**
  * The engine plus its store - `api.edit`.
  *
- * "One row, one form": `getForm` hands out the same `FormApi` the inline
- * editors write through, so a consumer can render it in a drawer or a detail
- * panel and share values, dirty state and errors with the cells.
+ * "One row, one form" while a row is open: `getForm` hands out the same
+ * `FormApi` the inline editors write through, so a consumer can render it in
+ * a drawer or a detail panel and share values, dirty state and errors with
+ * the cells. A committed row has no form - it is data in the draft store -
+ * so `getForm` returns `undefined` for it until `begin` reopens it.
  */
 export type TMDataGridEditApi<
   TData extends RowData = TMDataGridRowData,
@@ -574,13 +668,17 @@ export type TMDataGridEditApi<
   store: Store<TMDataGridEditState>;
   /** Current snapshot, for reads outside React. */
   readonly state: TMDataGridEditState;
-  /** rowId → live form. The source of truth for everything mid-edit. */
+  /**
+   * rowId → the open row's live form, the source of truth for everything
+   * mid-edit. `undefined` for a row that is not open, a committed row
+   * included; `begin` reopens one.
+   */
   getForm: (rowId: string) => TMDataGridRowEditForm | undefined;
   /**
-   * The row as shown: its draft values where a form holds one - open or
-   * parked in the draft store - else what `data` says. `undefined` when no
-   * such row exists. A deletion mark does not change the answer; check
-   * `state.deletedRowIds` for that.
+   * The row as shown: its draft values where the grid holds any - an open
+   * form's, or the committed values in the draft store - else what `data`
+   * says. `undefined` when no such row exists. A deletion mark does not
+   * change the answer; check `state.deletedRowIds` for that.
    */
   getRowValues: (rowId: string) => TData | undefined;
   /**
@@ -629,24 +727,33 @@ export type TMDataGridEditApi<
    * Submits every open row, as if each had been OK'd: a row that validates
    * commits (into the draft store with `editing.draft` on, straight to the
    * consumer without it), a row that fails stays open with its errors.
-   * `true` when every row committed. Under `editing.draft` it sends nothing
-   * to the consumer by itself - that is `saveDrafts`.
+   * Under `editing.draft` it sends nothing to the consumer by itself - that
+   * is `saveDrafts`.
+   *
+   * Resolves which rows went which way: `committed` and `open` hold every
+   * row that was open at the call, each in exactly one list, and `ok` is
+   * `true` when `open` is empty. See {@link TMDataGridCommitAllResult}.
    */
-  commitAll: () => Promise<boolean>;
+  commitAll: () => Promise<TMDataGridCommitAllResult>;
   /**
    * Flushes the draft store: every committed edit, added row and deletion
    * mark reaches the consumer, through `onSaveDrafts` in one call when it is
    * set, or row by row through `onCommit` / `onRowAdd` / `onRowDelete`.
    *
    * Rows still open are left alone - they keep their form state and stay
-   * open. `true` when everything landed; a rejected save keeps every draft.
-   */
-  saveDrafts: () => Promise<boolean>;
-  /**
-   * @deprecated Split into {@link commitAll} and {@link saveDrafts}, which is
-   * exactly what this now does. Removed in a later beta.
+   * open, and are in no list of the result.
+   *
+   * Resolves what happened to each id it sent: `saved` left the draft store,
+   * `kept` is still in it, committed, for the next save - an id
+   * `onSaveDrafts` reported as failed, every id when it threw, or a
+   * deletion whose per-row `onRowDelete` threw - and
+   * `reopened` is open again with an error, because a table rule now
+   * rejects it or its per-row `onCommit` / `onRowAdd` threw. `ok` is `true`
+   * when nothing was kept or reopened, and an empty store resolves `ok` with
+   * empty lists. A call while a save is in flight joins it and resolves the
+   * same result. See {@link TMDataGridSaveDraftsResult}.
    */
-  submitAll: () => Promise<boolean>;
+  saveDrafts: () => Promise<TMDataGridSaveDraftsResult>;
   /** Writes the type's empty value into a cell and commits it - Delete. */
   clearCell: (rowId: string, columnId: string) => Promise<boolean>;
   /**
@@ -691,15 +798,19 @@ export type TMDataGridEditApi<
    */
   addRow: (values?: Partial<TData>) => string;
   /**
-   * Opens entry rows for a list of records at once - one state write for the
+   * Opens entry rows for a list of records at once - one publish for the
    * batch, where a loop over `addRow` is one per row. Each row is seeded over
    * `newRowDefaults` exactly as `addRow` does.
    *
-   * `commit: true` submits each row as it lands, which is what an import
-   * wants: rows that validate commit (parked in the draft store under
-   * `editing.draft`, added through `onRowAdd` without it - once per row),
-   * and rows that fail stay open in the entry block carrying their errors,
-   * for the user to fix. The result says which went which way.
+   * `commit: true` submits the rows too, which is what an import wants: rows
+   * that validate commit, and rows that fail stay open in the entry block
+   * carrying their errors, for the user to fix. The result says which went
+   * which way - `committed` and `open` hold every added row, each in exactly
+   * one list, and `ok` is `true` when `open` is empty. Under
+   * `editing.draft` the rows validate together and land in the draft store
+   * in the same publish as the add - the grid renders once,
+   * whatever the count. Without it each valid row goes out through
+   * `onRowAdd`, one at a time and in order.
    */
   addRows: (
     rows: ReadonlyArray<Partial<TData>>,
@@ -707,11 +818,26 @@ export type TMDataGridEditApi<
   ) => Promise<TMDataGridAddRowsResult>;
   /**
    * Deletes a row: `onRowDelete` straight away, or under `editing.draft` a
-   * toggle of the id in `deletedRowIds` - the row renders struck through
-   * until `saveDrafts` reports it. On an uncommitted entry row it just
-   * discards the entry.
+   * mark in `deletedRowIds` - the row renders struck through until
+   * `saveDrafts` reports it. Idempotent: deleting a marked row again leaves
+   * it marked, and {@link restoreRow} is the undo. On an entry row,
+   * committed or not, it just discards the entry; an id the grid does not
+   * know is a no-op.
    */
   deleteRow: (rowId: string) => void;
+  /**
+   * {@link deleteRow} for several rows in one call - one notification for
+   * the batch, for a bulk action over a selection. Because `deleteRow` is
+   * idempotent and ignores unknown ids, the list may be passed exactly as
+   * the selection stands - already-marked rows stay marked, duplicates and
+   * stale ids do nothing.
+   */
+  deleteRows: (rowIds: ReadonlyArray<string>) => void;
+  /**
+   * Removes a row's deletion mark - the lane's Restore. A no-op on a row
+   * that is not marked, and outside `editing.draft`, where no marks exist.
+   */
+  restoreRow: (rowId: string) => void;
   /** Whether delete chrome makes sense - the lane's trash gate. */
   canDeleteRows: () => boolean;
 };
@@ -835,22 +961,36 @@ async function runFieldValidator(
  * form keeps its values, meta and errors; scroll back and the editor
  * re-mounts over the same form.
  */
+/**
+ * The engine as the hook holds it: the public `edit` API plus the verbs the
+ * grid calls on its own behalf and does not document.
+ */
+export type TMDataGridEditEngine = TMDataGridEditApi & {
+  /** See the implementation. `rowsById` is the core row model's. */
+  forgetMissingRows: (rowsById: Record<string, unknown>) => void;
+  /**
+   * Whether the row carries a deletion mark - the set behind
+   * `state.deletedRowIds`, for a check per row from a predicate the table
+   * calls per row.
+   */
+  isRowDeleted: (rowId: string) => boolean;
+};
+
 export function createEditEngine(
   getContext: () => TMDataGridEditEngineContext,
-): TMDataGridEditApi {
+): TMDataGridEditEngine {
   const store = new Store<TMDataGridEditState>(EMPTY_EDIT_STATE);
 
+  /**
+   * One open row's editor state. Only an open row has one: a row that
+   * commits into the draft store hands its values to `committed` and its
+   * form is dropped, so nothing in here describes a committed row.
+   */
   type FormEntry = {
     form: TMDataGridRowEditForm;
     original: TMDataGridRowData;
     /** An entry-block row - a form with no backing row yet. */
     isNew: boolean;
-    /**
-     * In the draft store: this row's form passed its submit and is parked,
-     * waiting for `saveDrafts`. Mirrored into the state's `committedRowIds`
-     * (existing rows) or `newRows[].committed` (entry rows).
-     */
-    committed: boolean;
     /** Set by the wrapped onSubmit when the consumer's commit resolved. */
     lastSubmitOk: boolean;
     /**
@@ -862,31 +1002,35 @@ export function createEditEngine(
     submitErrors: Array<{ field: string; value: unknown; message: string }>;
     /**
      * The park: this submit validates and puts the row in the draft store
-     * instead of calling the consumer. Set by `commit` per attempt - `true`
-     * only while `editing.draft` is on and outside `saveDrafts`, which is
-     * what closes the per-row escape hatches (the lane's ✓,
-     * Delete-to-clear) at the engine.
+     * instead of calling the consumer. Set by `commit` per attempt, from
+     * `editing.draft`.
      */
     parkOnly: boolean;
     /** A commit already running - Enter and blur race on the same edit. */
     pendingCommit: Promise<boolean> | null;
     unsubscribe: () => void;
-    unmount: () => void;
   };
   const forms = new Map<string, FormEntry>();
-  let newRowCounter = 0;
-  /** Lets `commit` tell a `saveDrafts` flush apart from a lone commit. */
-  let savingDrafts = false;
 
   /**
-   * While `saveDrafts` runs with an `onSaveDrafts`, each row's wrapped
-   * onSubmit contributes its args here instead of calling `onEditCommit` -
-   * validation stays per row (Form's), the consumer call becomes one.
+   * One committed row in the draft store. A committed row is plain data:
+   * it passed its validators, the user left it, and nothing can change its
+   * values until a reopen builds a form back from this. Which is what keeps
+   * an import of ten thousand rows to a few megabytes - a live `FormApi` per
+   * row is some eight kilobytes each - and what makes the store serializable.
    */
-  let draftCollector: Array<TMDataGridEditCommitArgs<TMDataGridRowData>> | null =
-    null;
-  let draftAddCollector: Array<TMDataGridRowAddArgs<TMDataGridRowData>> | null =
-    null;
+  type Committed = {
+    /** The data row, or the entry row's seed - what `changes` diffs against. */
+    original: TMDataGridRowData;
+    /** The committed values; `committedValues[rowId]` holds this same object. */
+    values: TMDataGridRowData;
+    /** `diff(original, values)` as it stood at commit time. */
+    dirtyFields: Array<string>;
+    isNew: boolean;
+  };
+  const committed = new Map<string, Committed>();
+  let newRowCounter = 0;
+  const NEW_ROW_ID_PREFIX = "__new__";
 
   /**
    * The column's half of the rule, with no row in hand: it is a consumer
@@ -946,49 +1090,62 @@ export function createEditEngine(
     return Object.keys(fields).length > 0 ? fields : undefined;
   };
 
+  /**
+   * The draft the grid is holding for a row: an open form's live values, or
+   * a committed row's snapshot. `undefined` for a row it holds nothing for.
+   */
+  const draftValues = (rowId: string): TMDataGridRowData | undefined => {
+    const entry = forms.get(rowId);
+    if (entry !== undefined) {
+      return entry.form.state.values as TMDataGridRowData;
+    }
+    return committed.get(rowId)?.values;
+  };
+
   /**
    * The collection as a table validator sees it: every data row overlaid
-   * with its draft where a form holds one, entry rows appended, and rows
-   * marked deleted removed. The committing row contributes the values being
-   * submitted, not what `data` still says. Built from the core row model, so
-   * it is unfiltered and never contains group rows.
+   * with its draft where the grid holds one, entry rows appended, and rows
+   * marked deleted removed. The committing row, when there is one,
+   * contributes the values being submitted rather than what `data` or the
+   * draft store still says. Built from the core row model, so it is
+   * unfiltered and never contains group rows.
    */
-  const mergedRows = (
-    rowId: string,
-    value: TMDataGridRowData,
-    isNew: boolean,
-  ): Array<{ rowId: string; value: TMDataGridRowData }> => {
-    const deleted = new Set(store.state.deletedRowIds);
+  const mergedRows = (committing?: {
+    rowId: string;
+    value: TMDataGridRowData;
+    isNew: boolean;
+  }): Array<{ rowId: string; value: TMDataGridRowData }> => {
+    const deleted = working.deletedRowIds;
     const rows: Array<{ rowId: string; value: TMDataGridRowData }> = [];
     const model = getContext().table.getCoreRowModel();
     for (const row of model.flatRows) {
       if (deleted.has(row.id)) continue;
-      if (row.id === rowId) {
-        rows.push({ rowId, value });
+      if (row.id === committing?.rowId) {
+        rows.push({ rowId: row.id, value: committing.value });
         continue;
       }
-      const held = forms.get(row.id);
       rows.push({
         rowId: row.id,
-        value:
-          held === undefined
-            ? (row.original as TMDataGridRowData)
-            : (held.form.state.values as TMDataGridRowData),
+        value: draftValues(row.id) ?? (row.original as TMDataGridRowData),
       });
     }
     // Entry rows the table does not hold: the open ones, and the committed
     // ones under `newRowsSticky`. A committed row in flow is in `data`
     // already, so it was listed above.
-    for (const newRow of store.state.newRows) {
-      if (newRow.tempId === rowId || newRow.tempId in model.rowsById) continue;
-      const held = forms.get(newRow.tempId);
-      if (held === undefined || deleted.has(newRow.tempId)) continue;
-      rows.push({
-        rowId: newRow.tempId,
-        value: held.form.state.values as TMDataGridRowData,
-      });
+    for (const tempId of working.newRows.keys()) {
+      if (tempId === committing?.rowId || tempId in model.rowsById) continue;
+      if (deleted.has(tempId)) continue;
+      const values = draftValues(tempId);
+      if (values === undefined) continue;
+      rows.push({ rowId: tempId, value: values });
+    }
+    if (
+      committing !== undefined &&
+      committing.isNew &&
+      !(committing.rowId in model.rowsById)
+    ) {
+      rows.push({ rowId: committing.rowId, value: committing.value });
     }
-    if (isNew && !(rowId in model.rowsById)) rows.push({ rowId, value });
     return rows;
   };
 
@@ -996,11 +1153,17 @@ export function createEditEngine(
    * Runs `editing.tableValidators` for one commit. `onSubmit` first; its
    * failure stands and `onSubmitAsync` is not consulted, mirroring how the
    * column triggers short-circuit.
+   *
+   * `rows` is the collection to judge against, for the caller that has one
+   * already: a Save pass runs the rules over rows whose values are frozen,
+   * so building the collection once there turns an O(N²) pass into an O(N)
+   * one. Left out, this builds the view for the committing row itself.
    */
   const runTableValidators = async (
     value: TMDataGridRowData,
     rowId: string,
     isNew: boolean,
+    rows?: ReadonlyArray<{ rowId: string; value: TMDataGridRowData }>,
   ): Promise<unknown> => {
     const validators = getContext().tableValidators;
     if (
@@ -1013,7 +1176,7 @@ export function createEditEngine(
       value,
       rowId,
       isNew,
-      rows: mergedRows(rowId, value, isNew),
+      rows: rows ?? mergedRows({ rowId, value, isNew }),
     };
     const sync = validators.onSubmit?.(args);
     if (isValidationError(sync)) return sync;
@@ -1094,15 +1257,16 @@ export function createEditEngine(
     };
   };
 
+  /** What moved between a row as it was and a row as drafted. */
   const diff = (
-    entry: FormEntry,
+    original: TMDataGridRowData,
     values: TMDataGridRowData,
   ): Array<TMDataGridEditChange> => {
     const changes: Array<TMDataGridEditChange> = [];
     for (const column of editableColumns()) {
       const field = getEditFieldName(column);
       if (field === null) continue;
-      const previous: unknown = getBy(entry.original, field);
+      const previous: unknown = getBy(original, field);
       const next: unknown = getBy(values, field);
       if (!sameValue(previous, next)) {
         changes.push({ columnId: column.id, field, previous, next });
@@ -1134,7 +1298,7 @@ export function createEditEngine(
       ...kept.map(({ field, message }) => ({ field, message })),
     ];
     return {
-      dirtyFields: diff(entry, values).map((change) => change.field),
+      dirtyFields: diff(entry.original, values).map((change) => change.field),
       errorFields: errorMessages.map((error) => error.field),
       errorMessages,
       hasRowError: hasAnyError(state.errors),
@@ -1143,143 +1307,314 @@ export function createEditEngine(
     };
   };
 
+  /**
+   * The same projection for a committed row, built from its snapshot. There
+   * is no form to read and nothing left to decide: the values passed every
+   * rule on the way in, so the error slots are empty and stay empty until a
+   * reopen puts the row back into form state.
+   */
+  const projectCommitted = (
+    snapshot: Committed,
+  ): TMDataGridEditRowProjection => ({
+    dirtyFields: snapshot.dirtyFields,
+    errorFields: [],
+    errorMessages: [],
+    hasRowError: false,
+    isSubmitting: false,
+    values: snapshot.values,
+  });
+
+  /**
+   * The engine's own copy of the state, in maps and sets, so a write is O(1)
+   * where the published shape would copy an array or a record. Every write
+   * lands here; `publish` materializes it into `store`, rebuilding only the
+   * slices that changed - a keystroke in an open editor leaves
+   * `committedValues` and `newRows` identity-stable, which is what keeps the
+   * table from rebuilding its row model under a caret.
+   *
+   * Holding the publish is what makes a batch verb scale. `addRows`,
+   * `commitAll`, `saveDrafts` and `cancelAll` each touch every row they
+   * hold, and an immutable write per row was quadratic: each one copied
+   * `rows` and `committedValues`, rebuilt `openRowIds` and woke every
+   * subscriber, so an import of ten thousand rows spent minutes copying and
+   * re-rendering. Held, a run's writes stay O(1) each and the grid renders
+   * once when it ends.
+   */
+  const working = {
+    active: null as TMDataGridEditState["active"],
+    /**
+     * Every row the grid holds work for, open or committed, in the order the
+     * rows first entered. Its own registry rather than `forms.keys()` plus
+     * the committed ids: rows commit in whatever order their async
+     * validators resolve, and the published order is the order the user
+     * opened them in. A re-add is a no-op on a Set, so a reopen keeps a
+     * row's place.
+     */
+    openRowIds: new Set<string>(),
+    rows: new Map<string, TMDataGridEditRowProjection>(),
+    committedRowIds: new Set<string>(),
+    committedValues: new Map<string, TMDataGridRowData>(),
+    /** `tempId` to its committed flag, in the order the rows were opened. */
+    newRows: new Map<string, boolean>(),
+    deletedRowIds: new Set<string>(),
+    isSaving: false,
+  };
+  /** The slices the next publish has to rebuild. */
+  const dirty = new Set<keyof TMDataGridEditState>();
+  /** Forms whose projection is stale - projected once each, at publish. */
+  const staleRows = new Set<string>();
+  /** Above zero, `publish` waits for the run holding it to end. */
+  let holdDepth = 0;
+
+  // Rows the engine took out of the table, and rows that only lost their
+  // selection - see flushRowState.
+  const pendingLeft = new Set<string>();
+  const pendingUnselect = new Set<string>();
+
+  /**
+   * Drops rows the engine took out of the table from the table state keyed
+   * by row id: `rowSelection`, `expanded` and `rowPinning`. A row that was
+   * only marked for deletion loses its selection alone - it is still there,
+   * pinned or open as it was.
+   *
+   * TanStack never prunes those maps itself: `toggleAllRowsSelected(false)`
+   * unticks only rows still in the model, `getIsSomeRowsSelected` counts
+   * every key, and `expanded` is persisted with whatever ids it holds. An id
+   * left behind keeps the header box indeterminate, flips "select all" back
+   * to selecting, and shows a consumer reading the keys a row that is gone.
+   * Two kinds of row leave through the engine: an entry row, discarded or
+   * saved - its temp id never comes back - and a marked row whose deletion
+   * the consumer has acted on. Run from `publish`, so a bulk delete or a
+   * save prunes in one update per slice.
+   */
+  const flushRowState = () => {
+    if (pendingLeft.size === 0 && pendingUnselect.size === 0) return;
+    const left = [...pendingLeft];
+    const unselect = [...left, ...pendingUnselect];
+    pendingLeft.clear();
+    pendingUnselect.clear();
+    const table = getContext().table;
+    const { rowSelection, expanded, rowPinning } = table.store.state;
+    const has = (map: object, rowId: string) =>
+      Object.prototype.hasOwnProperty.call(map, rowId);
+    if (unselect.some((rowId) => has(rowSelection, rowId))) {
+      table.setRowSelection((old) => {
+        const next = { ...old };
+        for (const rowId of unselect) delete next[rowId];
+        return next;
+      });
+    }
+    if (left.length === 0) return;
+    if (expanded !== true && left.some((rowId) => has(expanded, rowId))) {
+      table.setExpanded((old) => {
+        if (old === true) return old;
+        const next = { ...old };
+        for (const rowId of left) delete next[rowId];
+        return next;
+      });
+    }
+    const gone = new Set(left);
+    if (
+      rowPinning.top.some((rowId) => gone.has(rowId)) ||
+      rowPinning.bottom.some((rowId) => gone.has(rowId))
+    ) {
+      table.setRowPinning((old) => ({
+        top: old.top.filter((rowId) => !gone.has(rowId)),
+        bottom: old.bottom.filter((rowId) => !gone.has(rowId)),
+      }));
+    }
+  };
+
+  const publish = () => {
+    if (holdDepth > 0) return;
+    flushRowState();
+    if (staleRows.size > 0) {
+      for (const rowId of staleRows) {
+        const entry = forms.get(rowId);
+        if (entry !== undefined) working.rows.set(rowId, project(entry));
+        // A row whose form is gone because it committed keeps the projection
+        // `releaseForm` wrote from its snapshot; only a row that left the
+        // grid loses it.
+        else if (!committed.has(rowId)) working.rows.delete(rowId);
+      }
+      staleRows.clear();
+      dirty.add("rows");
+    }
+    if (dirty.size === 0) return;
+    const next = { ...store.state };
+    if (dirty.has("active")) next.active = working.active;
+    if (dirty.has("openRowIds")) next.openRowIds = [...working.openRowIds];
+    if (dirty.has("rows")) next.rows = Object.fromEntries(working.rows);
+    if (dirty.has("committedRowIds")) {
+      next.committedRowIds = [...working.committedRowIds];
+    }
+    if (dirty.has("committedValues")) {
+      next.committedValues = Object.fromEntries(working.committedValues);
+    }
+    if (dirty.has("newRows")) {
+      next.newRows = [...working.newRows].map(([tempId, committed]) => ({
+        tempId,
+        committed,
+      }));
+    }
+    if (dirty.has("deletedRowIds")) {
+      next.deletedRowIds = [...working.deletedRowIds];
+    }
+    if (dirty.has("isSaving")) next.isSaving = working.isSaving;
+    dirty.clear();
+    store.setState(() => next);
+  };
+
+  /** Marks slices changed and publishes - the ordinary single write. */
+  const touch = (...slices: Array<keyof TMDataGridEditState>) => {
+    for (const slice of slices) dirty.add(slice);
+    publish();
+  };
+
+  /** Runs `body` with the publish held: one render for the whole run. */
+  const held = async <T,>(body: () => Promise<T>): Promise<T> => {
+    holdDepth += 1;
+    try {
+      return await body();
+    } finally {
+      holdDepth -= 1;
+      publish();
+    }
+  };
+
+  /** {@link held} for a synchronous run. */
+  const heldSync = <T,>(body: () => T): T => {
+    holdDepth += 1;
+    try {
+      return body();
+    } finally {
+      holdDepth -= 1;
+      publish();
+    }
+  };
+
   const publishRow = (rowId: string) => {
-    const entry = forms.get(rowId);
-    store.setState((prev) => {
-      const rows = { ...prev.rows };
-      if (entry === undefined) delete rows[rowId];
-      else rows[rowId] = project(entry);
-      return { ...prev, rows, openRowIds: [...forms.keys()] };
-    });
+    staleRows.add(rowId);
+    publish();
   };
 
   const setActive = (active: TMDataGridEditState["active"]) => {
-    store.setState((prev) => ({ ...prev, active }));
+    if (working.active === active) return;
+    working.active = active;
+    touch("active");
   };
 
   /**
-   * A commit's snapshot into `committedValues`. Refreshed on every commit,
-   * not only the first - `setCellValue` on a parked row writes and commits
-   * again without the row ever leaving the draft store. A reopen leaves the
-   * snapshot alone: the table keeps showing the last decided values until
-   * the next decision.
+   * Publishes a committed row's values from its snapshot. Refreshed on every
+   * commit, not only the first - `setCellValue` on a committed row reopens
+   * it, writes and commits it again, and the table has to see the second
+   * value as well as the first. A reopen leaves the published values alone:
+   * the table keeps showing the last decided ones until the next decision.
+   * Marks the slice; the caller publishes.
    */
-  const snapshotCommitted = (
-    prev: TMDataGridEditState,
-    rowId: string,
-  ): TMDataGridEditState["committedValues"] => {
-    const values = forms.get(rowId)?.form.state.values as
-      | TMDataGridRowData
-      | undefined;
-    if (values === undefined || prev.committedValues[rowId] === values) {
-      return prev.committedValues;
+  const snapshotCommitted = (rowId: string) => {
+    const values = committed.get(rowId)?.values;
+    if (values === undefined || working.committedValues.get(rowId) === values) {
+      return;
     }
-    return { ...prev.committedValues, [rowId]: values };
+    working.committedValues.set(rowId, values);
+    dirty.add("committedValues");
   };
 
-  const setNewRowCommitted = (tempId: string, committed: boolean) => {
-    store.setState((prev) => {
-      const target = prev.newRows.find((newRow) => newRow.tempId === tempId);
-      if (target === undefined) return prev;
-      const committedValues = committed
-        ? snapshotCommitted(prev, tempId)
-        : prev.committedValues;
-      if (
-        target.committed === committed &&
-        committedValues === prev.committedValues
-      ) {
-        return prev;
-      }
-      return {
-        ...prev,
-        committedValues,
-        newRows:
-          target.committed === committed
-            ? prev.newRows
-            : prev.newRows.map((newRow) =>
-                newRow.tempId === tempId ? { ...newRow, committed } : newRow,
-              ),
-      };
-    });
+  const setNewRowCommitted = (tempId: string, isCommitted: boolean) => {
+    const current = working.newRows.get(tempId);
+    if (current === undefined) return;
+    if (isCommitted) snapshotCommitted(tempId);
+    if (current !== isCommitted) {
+      working.newRows.set(tempId, isCommitted);
+      dirty.add("newRows");
+    }
+    publish();
   };
 
   /**
    * Moves an existing row across the line between form state and the draft
-   * store. The values stay in the row's form; this records which side the
-   * row is on, snapshots them for the table on the way in, and the entry's
-   * flag keeps the two in step.
+   * store. The values are the snapshot's; this records which side the row is
+   * on and publishes them for the table on the way in. On the way out it
+   * leaves `committedValues` standing, so the row keeps the place the last
+   * decision gave it while the next one is being typed.
    */
-  const setCommitted = (rowId: string, committed: boolean) => {
-    const entry = forms.get(rowId);
-    if (entry !== undefined) entry.committed = committed;
-    store.setState((prev) => {
-      const has = prev.committedRowIds.includes(rowId);
-      const committedValues = committed
-        ? snapshotCommitted(prev, rowId)
-        : prev.committedValues;
-      if (has === committed && committedValues === prev.committedValues) {
-        return prev;
-      }
-      return {
-        ...prev,
-        committedValues,
-        committedRowIds:
-          has === committed
-            ? prev.committedRowIds
-            : committed
-              ? [...prev.committedRowIds, rowId]
-              : prev.committedRowIds.filter((id) => id !== rowId),
-      };
-    });
-  };
-
-  const withoutCommittedValues = (
-    prev: TMDataGridEditState,
-    rowId: string,
-  ): TMDataGridEditState["committedValues"] => {
-    if (!(rowId in prev.committedValues)) return prev.committedValues;
-    const { [rowId]: _dropped, ...rest } = prev.committedValues;
-    return rest;
+  const setCommitted = (rowId: string, isCommitted: boolean) => {
+    if (isCommitted) snapshotCommitted(rowId);
+    if (working.committedRowIds.has(rowId) !== isCommitted) {
+      if (isCommitted) working.committedRowIds.add(rowId);
+      else working.committedRowIds.delete(rowId);
+      dirty.add("committedRowIds");
+    }
+    publish();
   };
 
-  const drop = (rowId: string) => {
+  /**
+   * Drops the form of a row that has just committed, leaving every trace of
+   * the row itself: it is in the draft store now, and its projection is the
+   * snapshot's. The form is what goes - eight kilobytes a row that nothing
+   * can write to any more.
+   */
+  const releaseForm = (rowId: string) => {
     const entry = forms.get(rowId);
     if (entry === undefined) return;
     entry.unsubscribe();
-    entry.unmount();
     forms.delete(rowId);
-    store.setState((prev) => {
-      const rows = { ...prev.rows };
-      delete rows[rowId];
-      return {
-        ...prev,
-        rows,
-        openRowIds: [...forms.keys()],
-        committedRowIds: prev.committedRowIds.filter((id) => id !== rowId),
-        committedValues: withoutCommittedValues(prev, rowId),
-        newRows: entry.isNew
-          ? prev.newRows.filter((newRow) => newRow.tempId !== rowId)
-          : prev.newRows,
-        active: prev.active?.rowId === rowId ? null : prev.active,
-      };
+    staleRows.delete(rowId);
+    const snapshot = committed.get(rowId);
+    if (snapshot !== undefined) {
+      working.rows.set(rowId, projectCommitted(snapshot));
+      dirty.add("rows");
+    }
+    publish();
+  };
+
+  /** The row leaves the grid: its form, its snapshot and every flag go. */
+  const forget = (rowId: string) => {
+    heldSync(() => {
+      const isNew =
+        forms.get(rowId)?.isNew ?? committed.get(rowId)?.isNew ?? false;
+      releaseForm(rowId);
+      committed.delete(rowId);
+      if (working.openRowIds.delete(rowId)) dirty.add("openRowIds");
+      if (working.rows.delete(rowId)) dirty.add("rows");
+      if (working.committedRowIds.delete(rowId)) dirty.add("committedRowIds");
+      if (working.committedValues.delete(rowId)) dirty.add("committedValues");
+      if (isNew && working.newRows.delete(rowId)) dirty.add("newRows");
+      // An entry row leaves the table for good: discarded, or saved and
+      // coming back under the consumer's own id. Its selection, expansion
+      // and pin go with it - see flushRowState.
+      if (isNew) pendingLeft.add(rowId);
+      if (working.active?.rowId === rowId) {
+        working.active = null;
+        dirty.add("active");
+      }
     });
   };
 
+  /**
+   * Opens a row: a form over `original`, which is the row as it was when the
+   * editing began and what a commit's `changes` are diffed against.
+   *
+   * `values` is what the form starts out holding when that is not `original`
+   * - a reopen or a demotion, where the row already has committed values.
+   * They are written before the mount validation runs, so a rule judging the
+   * row on the way in sees what the user last decided, not the seed.
+   */
   const createForm = (
     rowId: string,
     original: TMDataGridRowData,
     isNew: boolean,
+    values?: TMDataGridRowData,
   ): FormEntry => {
     const entry: FormEntry = {
       original,
       isNew,
-      committed: false,
       lastSubmitOk: false,
       submitErrors: [],
       parkOnly: false,
       pendingCommit: null,
       unsubscribe: () => {},
-      unmount: () => {},
       form: new FormApi({
         defaultValues: original,
         // The consumer's vocabulary is Form's own; the cast erases the
@@ -1294,12 +1629,8 @@ export function createEditEngine(
               tempId: rowId,
               value: value as TMDataGridRowData,
             };
-            if (draftAddCollector !== null) {
-              draftAddCollector.push(addArgs);
-              entry.lastSubmitOk = true;
-              return;
-            }
-            // Parked: validated and held for Save all - no consumer call.
+            // Into the draft store: validated and held for Save - no
+            // consumer call, and `commit` takes it from here.
             if (entry.parkOnly) {
               entry.lastSubmitOk = true;
               return;
@@ -1315,7 +1646,7 @@ export function createEditEngine(
             }
             return;
           }
-          const changes = diff(entry, value as TMDataGridRowData);
+          const changes = diff(entry.original, value as TMDataGridRowData);
           const args: TMDataGridEditCommitArgs<TMDataGridRowData> = {
             rowId,
             value: value as TMDataGridRowData,
@@ -1323,12 +1654,8 @@ export function createEditEngine(
             changes,
             source: getContext().editMode,
           };
-          if (draftCollector !== null) {
-            draftCollector.push(args);
-            entry.lastSubmitOk = true;
-            return;
-          }
-          // Parked: validated and held for Save all - no consumer call.
+          // Into the draft store: validated and held for Save - no consumer
+          // call, and `commit` takes it from here.
           if (entry.parkOnly) {
             entry.lastSubmitOk = true;
             return;
@@ -1346,22 +1673,118 @@ export function createEditEngine(
         },
       }) as TMDataGridRowEditForm,
     };
-    entry.unmount = entry.form.mount();
+    // One write for the lot rather than a `setFieldValue` per field, which
+    // would churn the field meta and run the change rules on the way past.
+    // `keepDefaultValues` is what keeps `original` the thing the row is
+    // dirty against.
+    if (values !== undefined) {
+      entry.form.reset(values as never, { keepDefaultValues: true });
+    }
+    // Not `form.mount()`. What mount does is devtools wiring - three `window`
+    // listeners per form and a state broadcast on every change - and a grid
+    // holding ten thousand row forms cannot afford it: every form's every
+    // change would fan out to every other form's listeners. The one thing
+    // the engine wants from it is the `onMount` pass.
+    if (getContext().rowValidators?.onMount !== undefined) {
+      entry.form.validateSync("mount");
+    }
     const subscription = entry.form.store.subscribe(() => publishRow(rowId));
     entry.unsubscribe = () => subscription.unsubscribe();
     forms.set(rowId, entry);
-    publishRow(rowId);
+    staleRows.add(rowId);
+    // A Set add is idempotent, so a reopened row keeps the place it had.
+    if (!working.openRowIds.has(rowId)) {
+      working.openRowIds.add(rowId);
+      dirty.add("openRowIds");
+    }
+    publish();
     return entry;
   };
 
+  /**
+   * Takes a committed row back out of the draft store and into form state: a
+   * fresh form over the row as it was, holding the values the user last
+   * decided. `undefined` when the row is not committed.
+   *
+   * `committedValues` is left standing on purpose - the table keeps showing
+   * the last decided values, so the row holds its place in the sort while
+   * the next cell is typed into.
+   */
+  const reopen = (rowId: string): FormEntry | undefined => {
+    const snapshot = committed.get(rowId);
+    if (snapshot === undefined) return undefined;
+    committed.delete(rowId);
+    const entry = createForm(
+      rowId,
+      snapshot.original,
+      snapshot.isNew,
+      snapshot.values,
+    );
+    if (snapshot.isNew) setNewRowCommitted(rowId, false);
+    else setCommitted(rowId, false);
+    return entry;
+  };
+
+  /**
+   * A committed row that failed at Save: reopened, with the error on it.
+   * That is what the user has to act on, and "committed" means validated, so
+   * a row carrying an error cannot stay in the store.
+   *
+   * The error is read the way TanStack Form's own `normalizeError` reads a
+   * validator's return: an object naming `form` or `fields` splits into a
+   * row-level message and pathed ones, anything else is a row-level message.
+   */
+  const demote = (rowId: string, error: unknown) => {
+    const snapshot = committed.get(rowId);
+    // No snapshot: `begin` took the row back out while a per-row save was
+    // still waiting on the consumer. The row is open already, and the
+    // answer lands on the form it has rather than being lost.
+    const entry = snapshot === undefined ? forms.get(rowId) : reopen(rowId);
+    if (entry === undefined) return;
+    const values =
+      snapshot?.values ?? (entry.form.state.values as TMDataGridRowData);
+    const shape =
+      typeof error === "object" && error !== null
+        ? (error as { form?: unknown; fields?: Record<string, unknown> })
+        : undefined;
+    const split = shape !== undefined && ("fields" in shape || "form" in shape);
+    const fields = split ? shape.fields : undefined;
+    const formError = split ? shape.form : error;
+    if (fields !== undefined) {
+      // The shape `takeFieldErrors` produces, which `project` keeps on the
+      // row for as long as the value the rule tripped over stands.
+      entry.submitErrors = Object.entries(fields).flatMap(([field, issue]) =>
+        isValidationError(issue)
+          ? [
+              {
+                field,
+                value: getBy(values, field),
+                message: firstErrorText(issue) ?? "",
+              },
+            ]
+          : [],
+      );
+    }
+    if (isValidationError(formError)) {
+      entry.form.setErrorMap({ onSubmit: formError } as never);
+    }
+    publishRow(rowId);
+  };
+
   const canEditRow = (row: ErasedRow): boolean => {
     if (row.getIsGrouped()) return false;
+    // A deletion-marked row is read-only until it is restored: an edit on a
+    // row the save is about to delete has nowhere to go. The mark is checked
+    // here, in the engine, so the keyboard and the verbs agree with the
+    // pointer, which the table's CSS blocks.
+    if (working.deletedRowIds.has(row.id)) return false;
     return getContext().isRowEditable?.(row) !== false;
   };
 
   const canEditCell = (row: ErasedRow, column: ErasedColumn): boolean => {
     const context = getContext();
     if (row.getIsGrouped()) return false;
+    if (working.deletedRowIds.has(row.id)) return false;
     if (!isColumnEditable(column)) return false;
     if (!isColumnEditableForRow(column, row)) return false;
     if (context.isRowEditable !== undefined && !context.isRowEditable(row)) {
@@ -1401,6 +1824,8 @@ export function createEditEngine(
 
   const commit = async (rowId: string): Promise<boolean> => {
     const entry = forms.get(rowId);
+    // No form: the row is committed already, or the grid never held it.
+    // Either way there is nothing left to decide.
     if (entry === undefined) return true;
     // Enter and blur race on the same edit; the second caller joins the
     // first's commit instead of submitting the row twice.
@@ -1409,9 +1834,10 @@ export function createEditEngine(
     // Not for a new row: adding an untouched entry is still an add.
     if (
       !entry.isNew &&
-      diff(entry, entry.form.state.values as TMDataGridRowData).length === 0
+      diff(entry.original, entry.form.state.values as TMDataGridRowData)
+        .length === 0
     ) {
-      drop(rowId);
+      forget(rowId);
       return true;
     }
     // Field errors the *form's* validator planted are cleared before the
@@ -1421,13 +1847,18 @@ export function createEditEngine(
     clearFormSourcedFieldErrors(entry.form);
     entry.lastSubmitOk = false;
     entry.submitErrors = [];
-    entry.parkOnly = getContext().draft && !savingDrafts;
+    entry.parkOnly = getContext().draft;
     entry.pendingCommit = (async () => {
       try {
         await entry.form.handleSubmit();
       } finally {
         entry.pendingCommit = null;
       }
+      // Dropped while the submit was in flight - cancel or deleteRow won the
+      // race. The form is gone, so there is nothing to park or drop; marking
+      // the row committed now would plant an id in `committedRowIds` that no
+      // save or discard could ever clear.
+      if (forms.get(rowId) !== entry) return true;
       if (!entry.lastSubmitOk) {
         // Snapshot before the caller closes the editor: the field errors go
         // with it, and the row is about to be left carrying them.
@@ -1436,49 +1867,67 @@ export function createEditEngine(
         return false;
       }
       if (entry.parkOnly) {
-        // Into the draft store: the row's values stay in its form, and the
-        // grid records that they are decided. An entry row renders as a
-        // value row, an edited row as its draft - both until `begin` takes
-        // the row back out into form state, or `saveDrafts` flushes it.
-        entry.committed = true;
-        if (entry.isNew) setNewRowCommitted(rowId, true);
-        else setCommitted(rowId, true);
-        store.setState((prev) =>
-          prev.active?.rowId === rowId ? { ...prev, active: null } : prev,
-        );
+        // Into the draft store, as data: the values are decided, so they are
+        // snapshotted and the form goes. An entry row renders as a value
+        // row, an edited row as its draft - both until `begin` builds a form
+        // back from the snapshot, or `saveDrafts` flushes it.
+        heldSync(() => {
+          const values = entry.form.state.values as TMDataGridRowData;
+          committed.set(rowId, {
+            original: entry.original,
+            values,
+            dirtyFields: diff(entry.original, values).map(
+              (change) => change.field,
+            ),
+            isNew: entry.isNew,
+          });
+          if (entry.isNew) setNewRowCommitted(rowId, true);
+          else setCommitted(rowId, true);
+          if (working.active?.rowId === rowId) setActive(null);
+          releaseForm(rowId);
+        });
         return true;
       }
-      drop(rowId);
+      forget(rowId);
       return true;
     })();
     return entry.pendingCommit;
   };
 
   const beginOn = (rowId: string, columnId: string | null) => {
-    // An entry row has no backing row in the table; opening one re-arms its
-    // editors - with `editing.draft` on, that is how a parked row is edited
-    // again.
-    const entryForm = forms.get(rowId);
-    if (entryForm?.isNew === true) {
-      entryForm.committed = false;
-      setNewRowCommitted(rowId, false);
+    // Held: a reopen builds a form, takes the row out of the draft store and
+    // names the caret's cell, and the grid should see all of it at once.
+    heldSync(() => {
+      // An entry row has no backing row in the table. An open one is already
+      // in its editors; a committed one is re-armed from its snapshot, which
+      // with `editing.draft` on is how an entered row is edited again.
+      if (forms.get(rowId)?.isNew === true) {
+        setActive({ rowId, columnId });
+        return;
+      }
+      if (committed.get(rowId)?.isNew === true) {
+        reopen(rowId);
+        setActive({ rowId, columnId });
+        return;
+      }
+      const row = getRow(rowId);
+      if (row === undefined) return;
+      if (columnId !== null) {
+        const column = getContext().table.getColumn(columnId);
+        if (column === undefined || !canEditCell(row, column)) return;
+      } else if (!canEditRow(row)) {
+        return;
+      }
+      // Reopening a committed row takes it back out of the draft store: what
+      // the user is now editing is undecided again, and `saveDrafts` must not
+      // send it until it is committed afresh. It reopens from the snapshot,
+      // never from `row.original` - the table is showing the draft, and the
+      // row as it was is what a commit's `changes` are diffed against.
+      if (!forms.has(rowId) && reopen(rowId) === undefined) {
+        createForm(rowId, row.original, false);
+      }
       setActive({ rowId, columnId });
-      return;
-    }
-    const row = getRow(rowId);
-    if (row === undefined) return;
-    if (columnId !== null) {
-      const column = getContext().table.getColumn(columnId);
-      if (column === undefined || !canEditCell(row, column)) return;
-    } else if (getContext().isRowEditable?.(row) === false) {
-      return;
-    }
-    if (!forms.has(rowId)) createForm(rowId, row.original, false);
-    // Reopening a committed row takes it back out of the draft store: what
-    // the user is now editing is undecided again, and `saveDrafts` must not
-    // send it until it is committed afresh.
-    else if (forms.get(rowId)?.committed === true) setCommitted(rowId, false);
-    setActive({ rowId, columnId });
+    });
   };
 
   const begin: TMDataGridEditApi["begin"] = ({ rowId, columnId }) => {
@@ -1492,15 +1941,14 @@ export function createEditEngine(
     //   so a second row opening can neither discard the first nor be refused
     //   by it - nothing about one row's form bears on another's |
     //
-    // A parked row is not "open": it has had its submit and is waiting for
-    // the save, so it is skipped rather than put through a second one. An
+    // A committed row is not "open": it has had its submit and is waiting
+    // for the save, so it holds no form and the sweep never sees it. An
     // entry row is skipped too - it is row-shaped in every mode, and its ✓
     // is the decision, so the sweep must not add a half-typed row.
     if (editMode === "cell") {
-      const openElsewhere = [...forms.keys()].find((id) => {
-        const other = forms.get(id);
-        return id !== rowId && other?.committed !== true && other?.isNew !== true;
-      });
+      const openElsewhere = [...forms.keys()].find(
+        (id) => id !== rowId && forms.get(id)?.isNew !== true,
+      );
       if (openElsewhere !== undefined) {
         void commit(openElsewhere).then((ok) => {
           if (ok) beginOn(rowId, columnId);
@@ -1512,7 +1960,7 @@ export function createEditEngine(
   };
 
   const cancel = (rowId: string) => {
-    drop(rowId);
+    forget(rowId);
   };
 
   const deactivate = () => {
@@ -1520,27 +1968,34 @@ export function createEditEngine(
   };
 
   const cancelAll = () => {
-    for (const rowId of [...forms.keys()]) drop(rowId);
-    store.setState((prev) => ({
-      ...prev,
-      active: null,
-      committedRowIds: [],
-      committedValues: {},
-      deletedRowIds: [],
-    }));
+    heldSync(() => {
+      // Open rows and committed ones alike - `openRowIds` is both.
+      for (const rowId of [...working.openRowIds]) forget(rowId);
+      committed.clear();
+      working.active = null;
+      working.committedRowIds.clear();
+      working.committedValues.clear();
+      working.deletedRowIds.clear();
+      dirty.add("active");
+      dirty.add("committedRowIds");
+      dirty.add("committedValues");
+      dirty.add("deletedRowIds");
+    });
   };
 
-  const addRow = (values?: TMDataGridRowData): string => {
+  /** Opens one entry row - the form and its `newRows` entry, in one write. */
+  const openEntryRow = (values?: TMDataGridRowData): string => {
     newRowCounter += 1;
-    const tempId = `__new__${newRowCounter}`;
+    const tempId = `${NEW_ROW_ID_PREFIX}${newRowCounter}`;
     createForm(tempId, seedNewRow(values), true);
-    store.setState((prev) => ({
-      ...prev,
-      newRows: [...prev.newRows, { tempId, committed: false }],
-    }));
+    working.newRows.set(tempId, false);
+    dirty.add("newRows");
     return tempId;
   };
 
+  const addRow = (values?: TMDataGridRowData): string =>
+    heldSync(() => openEntryRow(values));
+
   /** Seeds one entry row's values - `newRowDefaults` under `values`. */
   const seedNewRow = (values?: TMDataGridRowData): TMDataGridRowData => {
     const { newRowDefaults } = getContext();
@@ -1556,56 +2011,74 @@ export function createEditEngine(
   const addRows = async (
     rows: ReadonlyArray<TMDataGridRowData>,
     options?: TMDataGridAddRowsOptions,
-  ): Promise<TMDataGridAddRowsResult> => {
-    const tempIds: Array<string> = [];
-    // One notification for the batch: `createForm` publishes its row as it
-    // mounts, so an import of hundreds would otherwise wake every subscriber
-    // once per row before the entry block has even been told they exist.
-    batch(() => {
-      for (const values of rows) {
-        newRowCounter += 1;
-        const tempId = `__new__${newRowCounter}`;
-        createForm(tempId, seedNewRow(values), true);
-        tempIds.push(tempId);
+  ): Promise<TMDataGridAddRowsResult> =>
+    // One publish for the whole import - the entry block and the table learn
+    // of the rows once, committed, rather than once per row on the way in
+    // and once more per commit.
+    held(async () => {
+      const tempIds = rows.map((values) => openEntryRow(values));
+      if (options?.commit !== true) {
+        return { ok: tempIds.length === 0, committed: [], open: tempIds };
       }
-      store.setState((prev) => ({
-        ...prev,
-        newRows: [
-          ...prev.newRows,
-          ...tempIds.map((tempId) => ({ tempId, committed: false })),
-        ],
-      }));
-    });
-
-    if (options?.commit !== true) return { committed: [], open: tempIds };
 
-    // In order, so a consumer's `onRowAdd` sees the rows as the file had
-    // them. A row that fails validation stays open carrying its errors.
-    const committed: Array<string> = [];
-    const open: Array<string> = [];
-    for (const tempId of tempIds) {
-      const ok = await commit(tempId);
-      (ok ? committed : open).push(tempId);
-    }
-    return { committed, open };
-  };
+      // A row that fails validation stays open carrying its errors.
+      //
+      // Parked, the rows are submitted together: Form runs a submit's async
+      // validators off a timer, so one row after another is a timer per row
+      // - minutes for an import, once the browser clamps nested timers.
+      // Nothing but the engine hears a parked commit, so the rows may
+      // validate side by side. Out to `onRowAdd`, one at a time and in
+      // order, so the consumer sees the rows as the file had them.
+      const results = getContext().draft
+        ? await Promise.all(tempIds.map((tempId) => commit(tempId)))
+        : [];
+      if (!getContext().draft) {
+        for (const tempId of tempIds) results.push(await commit(tempId));
+      }
+      return splitCommitted(tempIds, results);
+    });
 
   const deleteRow = (rowId: string) => {
-    const entry = forms.get(rowId);
-    // Deleting an unsaved entry row is just discarding the entry.
-    if (entry?.isNew === true) {
-      drop(rowId);
+    // Deleting an unsaved entry row is just discarding the entry, whether it
+    // is still open or already committed into the draft store.
+    if (
+      forms.get(rowId)?.isNew === true ||
+      committed.get(rowId)?.isNew === true
+    ) {
+      forget(rowId);
       return;
     }
     const context = getContext();
     if (context.draft) {
-      // A toggle: the second press unmarks - the mark is a draft too.
-      store.setState((prev) => ({
-        ...prev,
-        deletedRowIds: prev.deletedRowIds.includes(rowId)
-          ? prev.deletedRowIds.filter((id) => id !== rowId)
-          : [...prev.deletedRowIds, rowId],
-      }));
+      // Idempotent: a marked row stays marked - `restoreRow` is the undo.
+      if (working.deletedRowIds.has(rowId)) return;
+      // Only a consumer row can be marked. A deletion mark is what
+      // `saveDrafts` reports to the server, so an id it cannot act on - an
+      // engine temp id, a record gone from `data`, an id the grid never
+      // knew - must not live on as a mark inflating the draft count. Entry
+      // rows are dropped above, never marked; the prefix check also catches
+      // one already dropped that a stale selection or a double-fired
+      // handler names again, while the table's data still shows it for one
+      // render. The core model, so a filtered-out row still takes its mark.
+      if (
+        rowId.startsWith(NEW_ROW_ID_PREFIX) ||
+        !(rowId in context.table.getCoreRowModel().rowsById)
+      ) {
+        return;
+      }
+      heldSync(() => {
+        // An editor open on the row loses: what was being typed into a row
+        // the user then deleted is not worth keeping, and a marked row has
+        // no editor. A committed edit stays under the mark, so Restore
+        // brings the row back as it was edited.
+        if (forms.has(rowId)) forget(rowId);
+        working.deletedRowIds.add(rowId);
+        dirty.add("deletedRowIds");
+        // Not selectable while marked - see `enableRowSelection` in the
+        // hook - so the selection lets it go now, the way a row leaving the
+        // table would. See flushRowState.
+        pendingUnselect.add(rowId);
+      });
       return;
     }
     const row = getRow(rowId);
@@ -1614,6 +2087,19 @@ export function createEditEngine(
     void context.onRowDelete?.({ rowId, row });
   };
 
+  const deleteRows = (rowIds: ReadonlyArray<string>) => {
+    // One publish for the batch - each id still goes through `deleteRow`,
+    // so entry rows drop and everything else marks or no-ops by the same
+    // rules.
+    heldSync(() => {
+      for (const rowId of rowIds) deleteRow(rowId);
+    });
+  };
+
+  const restoreRow = (rowId: string) => {
+    if (working.deletedRowIds.delete(rowId)) touch("deletedRowIds");
+  };
+
   const canDeleteRows = (): boolean => {
     const context = getContext();
     if (context.draft) {
@@ -1625,151 +2111,275 @@ export function createEditEngine(
     return context.onRowDelete !== undefined;
   };
 
-  /** The pending deletions, reported and cleared by `saveDrafts`. */
-  const takeDeletedRowIds = (): Array<string> => {
-    const deleted = [...store.state.deletedRowIds];
-    if (deleted.length > 0) {
-      store.setState((prev) => ({ ...prev, deletedRowIds: [] }));
-    }
-    return deleted;
-  };
+  /** The draft store's rows, in the order the rows entered the grid. */
+  const committedIds = (): Array<string> =>
+    [...working.openRowIds].filter((rowId) => committed.has(rowId));
 
-  /** The draft store's rows: committed forms, in the order they landed. */
-  const committedFormIds = (): Array<string> =>
-    [...forms.keys()].filter((rowId) => forms.get(rowId)?.committed === true);
-
-  const commitAll = async (): Promise<boolean> => {
-    // Only the open ones - a row already in the draft store has had its
-    // submit and must not be put through a second one here.
-    const openIds = [...forms.keys()].filter(
-      (rowId) => forms.get(rowId)?.committed !== true,
+  const commitAll = async (): Promise<TMDataGridCommitAllResult> => {
+    // Every form there is - a row in the draft store holds none, so this is
+    // the open rows and nothing else.
+    const openIds = [...forms.keys()];
+    const results = await held(() =>
+      Promise.all(openIds.map((rowId) => commit(rowId))),
     );
-    const results = await Promise.all(openIds.map((rowId) => commit(rowId)));
-    return results.every(Boolean);
+    return splitCommitted(openIds, results);
   };
 
   /**
    * The in-flight save. A second call while `onSaveDrafts` awaits would
    * re-collect the same payload and send it again - a double-clicked Save
    * would create every pending entry row twice - so concurrent calls join
-   * this promise instead of starting a save of their own.
+   * this promise, and its result, instead of starting a save of their own.
    */
-  let saveInFlight: Promise<boolean> | null = null;
+  let saveInFlight: Promise<TMDataGridSaveDraftsResult> | null = null;
 
-  const saveDrafts = (): Promise<boolean> => {
+  const saveDrafts = (): Promise<TMDataGridSaveDraftsResult> => {
     if (saveInFlight !== null) return saveInFlight;
-    // While this runs, `commit` really commits - `editing.draft` parks
-    // otherwise. Single-threaded flag, same idiom as the collectors.
-    savingDrafts = true;
     saveInFlight = saveDraftsInner().finally(() => {
-      savingDrafts = false;
       saveInFlight = null;
+      // Guarded: a save that found nothing to send never raised the flag,
+      // so it publishes nothing either.
+      if (working.isSaving) {
+        working.isSaving = false;
+        touch("isSaving");
+      }
     });
     return saveInFlight;
   };
 
-  const saveDraftsInner = async (): Promise<boolean> => {
-    const committedIds = committedFormIds();
-    const deletedIds = [...store.state.deletedRowIds];
+  /** What one committed row hands `onEditCommit` and the payload's `updated`. */
+  const commitArgsFor = (
+    rowId: string,
+    snapshot: Committed,
+  ): TMDataGridEditCommitArgs<TMDataGridRowData> => ({
+    rowId,
+    value: snapshot.values,
+    original: snapshot.original,
+    changes: diff(snapshot.original, snapshot.values),
+    source: getContext().editMode,
+  });
+
+  const saveDraftsInner = async (): Promise<TMDataGridSaveDraftsResult> => {
+    const deletedIds = [...working.deletedRowIds];
+    // A marked row's edit is not sent - the save deletes the row. The edit
+    // stays under the mark for Restore and leaves with the row once the
+    // deletion is saved; a rejected deletion keeps both.
+    const ids = committedIds().filter(
+      (rowId) => !working.deletedRowIds.has(rowId),
+    );
+    // Every id the save takes out of the store lands in exactly one list,
+    // edits, new rows and deletions mixed, in the store's order.
+    const saved: Array<string> = [];
+    const kept: Array<string> = [];
+    const reopened: Array<string> = [];
+    const report = (): TMDataGridSaveDraftsResult => ({
+      ok: kept.length === 0 && reopened.length === 0,
+      saved,
+      kept,
+      reopened,
+    });
     // Nothing decided: open rows are not this verb's business, so a grid
     // mid-edit with an empty draft store saves cleanly and stays as it is.
-    if (committedIds.length === 0 && deletedIds.length === 0) return true;
+    if (ids.length === 0 && deletedIds.length === 0) return report();
+
+    working.isSaving = true;
+    touch("isSaving");
+
+    // Only the table rules run here, and only once per row. A committed
+    // row's values passed its column and row validators on the way in and
+    // cannot have moved since, so re-running those could only say the same
+    // thing. Table rules see the *other* rows, which later commits do move,
+    // so a draft another edit has invalidated is caught here - and nowhere
+    // else, because checking every committed row at every commit would be a
+    // pass over the store per keystroke.
+    //
+    // The collection is built once for the pass: every value in it is frozen
+    // while the pass runs, so N rows share one view instead of building one
+    // each.
+    const rows = mergedRows();
 
     if (getContext().onSaveDrafts === undefined) {
       // The default: the per-row loop - edits through `onEditCommit`, entry
-      // rows through `onRowAdd`, marked deletions through `onRowDelete`.
-      const results = await Promise.all(
-        committedIds.map((rowId) => commit(rowId)),
+      // rows through `onRowAdd`, marked deletions through `onRowDelete`. The
+      // rows go out side by side, as one `onSaveDrafts` call would.
+      const results = await held(() =>
+        Promise.all(
+          ids.map(async (rowId): Promise<"saved" | "reopened" | null> => {
+            const snapshot = committed.get(rowId);
+            if (snapshot === undefined) return null;
+            const invalid = await runTableValidators(
+              snapshot.values,
+              rowId,
+              snapshot.isNew,
+              rows,
+            );
+            if (isValidationError(invalid)) {
+              demote(rowId, invalid);
+              return "reopened";
+            }
+            try {
+              if (snapshot.isNew) {
+                await getContext().onRowAdd?.({
+                  tempId: rowId,
+                  value: snapshot.values,
+                });
+              } else {
+                await getContext().onEditCommit?.(
+                  commitArgsFor(rowId, snapshot),
+                );
+              }
+            } catch (error) {
+              // The same answer a rejected commit gets outside the draft
+              // store: the row is open again, carrying the message.
+              demote(
+                rowId,
+                error instanceof Error ? error.message : String(error),
+              );
+              return "reopened";
+            }
+            forget(rowId);
+            return "saved";
+          }),
+        ),
       );
-      for (const rowId of takeDeletedRowIds()) {
+      ids.forEach((rowId, index) => {
+        const outcome = results[index];
+        if (outcome === "saved") saved.push(rowId);
+        else if (outcome === "reopened") reopened.push(rowId);
+      });
+      // A mark leaves once its `onRowDelete` resolved, and the row's
+      // selection and the edit held under the mark go with it in one publish -
+      // see flushRowState and saveDraftsInner's `ids`. A throw keeps the mark
+      // for the next save, as a deletion `onSaveDrafts` refuses is kept.
+      const deletedOk: Array<string> = [];
+      for (const rowId of deletedIds) {
         const row = getRow(rowId);
-        if (row !== undefined) {
-          await getContext().onRowDelete?.({ rowId, row });
+        try {
+          if (row !== undefined) {
+            await getContext().onRowDelete?.({ rowId, row });
+          }
+          deletedOk.push(rowId);
+        } catch {
+          kept.push(rowId);
         }
       }
-      return results.every(Boolean);
+      heldSync(() => {
+        let deletionsChanged = false;
+        for (const rowId of deletedOk) {
+          if (working.deletedRowIds.delete(rowId)) deletionsChanged = true;
+          pendingLeft.add(rowId);
+          if (committed.has(rowId)) forget(rowId);
+        }
+        if (deletionsChanged) dirty.add("deletedRowIds");
+      });
+      saved.push(...deletedOk);
+      return report();
     }
 
-    // One consumer call for the lot. Validation stays Form's, per row: rows
-    // that fail keep their forms and markers; the valid ones travel
-    // together, and only a resolved save drops them - a rejected save keeps
-    // every draft, deletions included.
-    const collected: Array<TMDataGridEditCommitArgs<TMDataGridRowData>> = [];
-    const added: Array<TMDataGridRowAddArgs<TMDataGridRowData>> = [];
-    draftCollector = collected;
-    draftAddCollector = added;
-    let allValid = true;
-    try {
-      for (const rowId of committedIds) {
-        const entry = forms.get(rowId);
-        if (entry === undefined) continue;
-        entry.lastSubmitOk = false;
-        await entry.form.handleSubmit();
-        if (!entry.lastSubmitOk) allValid = false;
-      }
-    } finally {
-      draftCollector = null;
-      draftAddCollector = null;
-    }
+    // One consumer call for the lot. The valid rows travel together, and
+    // only a resolved save drops them - a rejected save keeps every draft,
+    // deletions included. A row the table rules now reject is reopened with
+    // the error and left behind for the user to fix.
+    type CommitArgs = TMDataGridEditCommitArgs<TMDataGridRowData>;
+    type AddArgs = TMDataGridRowAddArgs<TMDataGridRowData>;
+    const collected: Array<CommitArgs> = [];
+    const added: Array<AddArgs> = [];
+    // The rows sent, edits and new rows mixed in the store's order - the
+    // order the result reports them in.
+    const sent: Array<{ id: string; isNew: boolean }> = [];
+    await held(async () => {
+      const results = await Promise.all(
+        ids.map((rowId) => {
+          const snapshot = committed.get(rowId);
+          if (snapshot === undefined) return undefined;
+          return runTableValidators(
+            snapshot.values,
+            rowId,
+            snapshot.isNew,
+            rows,
+          );
+        }),
+      );
+      // In the store's order, which is the order the rows entered the grid.
+      ids.forEach((rowId, index) => {
+        const snapshot = committed.get(rowId);
+        if (snapshot === undefined) return;
+        if (isValidationError(results[index])) {
+          demote(rowId, results[index]);
+          reopened.push(rowId);
+          return;
+        }
+        sent.push({ id: rowId, isNew: snapshot.isNew });
+        if (snapshot.isNew) {
+          added.push({ tempId: rowId, value: snapshot.values });
+        } else {
+          collected.push(commitArgsFor(rowId, snapshot));
+        }
+      });
+    });
     const deleted = deletedIds;
     if (collected.length > 0 || added.length > 0 || deleted.length > 0) {
-      let result: void | TMDataGridSaveDraftsResult;
+      let response: void | TMDataGridSaveDraftsResponse;
       try {
-        result = await getContext().onSaveDrafts?.({
+        response = await getContext().onSaveDrafts?.({
           updated: collected,
           created: added,
           deleted,
-          // The pre-2.0 names, still filled - see TMDataGridSaveDraftsArgs.
-          rows: collected,
-          added,
         });
       } catch {
-        return false;
+        // A thrown save keeps everything it was sent, for the next save.
+        kept.push(...sent.map((row) => row.id), ...deleted);
+        return report();
       }
 
-      // Nothing returned saves the lot. A result names what failed; those
+      // Nothing returned saves the lot. A response names what failed; those
       // keep their drafts, committed, so the next save retries them.
-      const outcomes = result ?? {};
-      let savedAll = true;
-
-      for (const args of collected) {
-        if (isSaved(outcomes.updated, args.rowId)) drop(args.rowId);
-        else savedAll = false;
-      }
-      for (const args of added) {
-        if (isSaved(outcomes.created, args.tempId)) drop(args.tempId);
-        else savedAll = false;
-      }
-      const savedDeletions = deleted.filter((id) =>
-        isSaved(outcomes.deleted, id),
-      );
-      if (savedDeletions.length > 0) {
-        store.setState((prev) => ({
-          ...prev,
-          deletedRowIds: prev.deletedRowIds.filter(
-            (id) => !savedDeletions.includes(id),
-          ),
-        }));
-      }
-      if (savedDeletions.length < deleted.length) savedAll = false;
-
-      if (!savedAll) return false;
+      const outcomes = response ?? {};
+
+      // The saved rows leave the store in one publish.
+      heldSync(() => {
+        for (const { id, isNew } of sent) {
+          if (isSaved(isNew ? outcomes.created : outcomes.updated, id)) {
+            forget(id);
+            saved.push(id);
+          } else {
+            kept.push(id);
+          }
+        }
+        let deletionsChanged = false;
+        for (const id of deleted) {
+          if (!isSaved(outcomes.deleted, id)) {
+            kept.push(id);
+            continue;
+          }
+          saved.push(id);
+          if (working.deletedRowIds.delete(id)) deletionsChanged = true;
+          // The consumer has deleted the record; the row is on its way out
+          // of `data`, and its selection goes now - see flushRowState. So
+          // does the edit held under the mark.
+          pendingLeft.add(id);
+          if (committed.has(id)) forget(id);
+        }
+        if (deletionsChanged) dirty.add("deletedRowIds");
+      });
     }
-    return allValid;
-  };
-
-  /** @deprecated The old one-shot save - `commitAll` then `saveDrafts`. */
-  const submitAll = async (): Promise<boolean> => {
-    const committedOk = await commitAll();
-    const savedOk = await saveDrafts();
-    return committedOk && savedOk;
+    return report();
   };
 
   /**
    * The write path behind `clearCell`, `setCellValue` and `setRowValues`:
    * fill the row's own form and commit it, exactly as a ✓ on an open editor
    * would. Uses the form already open on the row when there is one, so a
-   * programmatic write joins an edit in progress rather than discarding it.
+   * programmatic write joins an edit in progress rather than discarding it;
+   * a committed row is reopened from its snapshot and commits afresh.
+   *
+   * Only that last case runs under a hold. Reopened, the row is out of the
+   * draft store until it commits again, and its markers must not flicker
+   * off for the length of the validators. The hold is safe there because a
+   * committed row exists only under `editing.draft`, where the commit parks
+   * and never waits on the consumer. An open row's commit without `draft`
+   * awaits `onEditCommit`, and holding the engine's publish for a server
+   * round trip would stall every other row's markers and the caret.
    *
    * No editor is involved, so `meta.edit.mapValue` does not run - the caller
    * writes the stored value itself. Validation is untouched: this is the same
@@ -1783,12 +2393,24 @@ export function createEditEngine(
   ): Promise<boolean> => {
     const row = getRow(rowId);
     if (row === undefined) return false;
+    // Read-only while marked - see canEditRow.
+    if (working.deletedRowIds.has(rowId)) return false;
     if (writes.length === 0) return true;
-    const entry = forms.get(rowId) ?? createForm(rowId, row.original, false);
-    for (const { field, value } of writes) {
-      entry.form.setFieldValue(field as never, value as never);
+    const write = (entry: FormEntry): Promise<boolean> => {
+      for (const { field, value } of writes) {
+        entry.form.setFieldValue(field as never, value as never);
+      }
+      return commit(rowId);
+    };
+    const open = forms.get(rowId);
+    if (open !== undefined) return write(open);
+    if (!committed.has(rowId)) {
+      return write(createForm(rowId, row.original, false));
     }
-    return commit(rowId);
+    return held(async () => {
+      const entry = reopen(rowId);
+      return entry === undefined ? false : write(entry);
+    });
   };
 
   /** The field a cell writes to, or `null` when that cell takes no edit. */
@@ -1840,49 +2462,73 @@ export function createEditEngine(
     return writeFields(rowId, writes);
   };
 
-  const getRowValues = (rowId: string): TMDataGridRowData | undefined => {
-    const held = forms.get(rowId);
-    // Entry rows exist only as forms, so this covers them too.
-    if (held !== undefined) return held.form.state.values as TMDataGridRowData;
-    return getRow(rowId)?.original as TMDataGridRowData | undefined;
-  };
+  const getRowValues = (rowId: string): TMDataGridRowData | undefined =>
+    // An entry row exists only as a draft, open or committed, so this covers
+    // it too.
+    draftValues(rowId) ??
+    (getRow(rowId)?.original as TMDataGridRowData | undefined);
 
   const getRows = (): ReadonlyArray<TMDataGridEditRowSnapshot> => {
-    const deleted = new Set(store.state.deletedRowIds);
+    const deleted = working.deletedRowIds;
     const rows: Array<TMDataGridEditRowSnapshot> = [];
     const model = getContext().table.getCoreRowModel();
     for (const row of model.flatRows) {
-      const held = forms.get(row.id);
       rows.push({
         rowId: row.id,
-        value:
-          held === undefined
-            ? (row.original as TMDataGridRowData)
-            : (held.form.state.values as TMDataGridRowData),
-        isNew: held?.isNew === true,
+        value: draftValues(row.id) ?? (row.original as TMDataGridRowData),
+        isNew:
+          forms.get(row.id)?.isNew ?? committed.get(row.id)?.isNew ?? false,
         deleted: deleted.has(row.id),
       });
     }
     // Entry rows the table does not hold - see mergedRows.
-    for (const newRow of store.state.newRows) {
-      if (newRow.tempId in model.rowsById) continue;
-      const held = forms.get(newRow.tempId);
-      if (held === undefined) continue;
+    for (const tempId of working.newRows.keys()) {
+      if (tempId in model.rowsById) continue;
+      const values = draftValues(tempId);
+      if (values === undefined) continue;
       rows.push({
-        rowId: newRow.tempId,
-        value: held.form.state.values as TMDataGridRowData,
+        rowId: tempId,
+        value: values,
         isNew: true,
-        deleted: deleted.has(newRow.tempId),
+        deleted: deleted.has(tempId),
       });
     }
     return rows;
   };
 
+  /**
+   * Drops what the store holds for records that left `data`: a refetch that
+   * no longer returns a row takes its open form, its committed edit and its
+   * deletion mark with it. The server has nothing for the save to update or
+   * delete, and a row nobody can see must not sit in the Save count. Entry
+   * rows are the engine's own and stay. Called by the hook whenever the rows
+   * as shown change, with the core row model's `rowsById`; not called where
+   * the grid does not own the result set, since there a row missing from
+   * `data` is on another page, not gone.
+   */
+  const forgetMissingRows = (rowsById: Record<string, unknown>) => {
+    heldSync(() => {
+      // Open rows and committed ones alike - `openRowIds` is both.
+      for (const rowId of [...working.openRowIds]) {
+        const isNew =
+          forms.get(rowId)?.isNew ?? committed.get(rowId)?.isNew ?? false;
+        if (!isNew && !(rowId in rowsById)) forget(rowId);
+      }
+      for (const rowId of [...working.deletedRowIds]) {
+        if (rowId in rowsById) continue;
+        working.deletedRowIds.delete(rowId);
+        dirty.add("deletedRowIds");
+      }
+    });
+  };
+
   return {
     store,
     get state() {
       return store.state;
     },
+    forgetMissingRows,
+    isRowDeleted: (rowId) => working.deletedRowIds.has(rowId),
     getForm: (rowId) => forms.get(rowId)?.form,
     getRowValues,
     getRows,
@@ -1896,13 +2542,14 @@ export function createEditEngine(
     cancelAll,
     commitAll,
     saveDrafts,
-    submitAll,
     clearCell,
     setCellValue,
     setRowValues,
     addRow,
     addRows,
     deleteRow,
+    deleteRows,
+    restoreRow,
     canDeleteRows,
   };
 }