@jielga/tmdatagrid 2.0.0-beta.1 → 2.0.0-beta.2

package/skills/editing/references/common-mistakes.md

@@ -0,0 +1,177 @@
+# Editing - common mistakes
+
+The failure modes that compile, raise no warning, and lose a user's typing.
+Severity is how much data or trust the mistake costs.
+
+## CRITICAL Expecting the grid to write into `data`
+
+The grid holds no copy of the rows. Without `editing.onCommit` an edit commits,
+the draft clears, and the cell reverts to the value in `data`.
+
+Wrong:
+
+```tsx
+useTMDataGrid({
+  data: employees,
+  columns,
+  getRowId,
+  editing: { mode: "cell" },
+});
+```
+
+Correct: wire `editing.onCommit` to apply the change where the data lives, as
+in the skill's Setup section.
+
+Source: `src/docs/editing.md`, `src/tmdatagrid/core/editEngine.ts`.
+
+## CRITICAL `getRowId` built from the row index
+
+`getRowId` accepts any string, so an index-based id compiles. Drafts are keyed
+by it, so after a sort or a filter the draft is applied to whichever record now
+sits at that index.
+
+Wrong:
+
+```tsx
+getRowId: (row, index) => String(index),
+```
+
+Correct:
+
+```tsx
+getRowId: (row) => String(row.id),
+```
+
+Source: `src/tmdatagrid/useTMDataGrid.tsx` (`TMDataGridEditingCallbacks`).
+
+## HIGH A cell editor defined inside the component
+
+`meta.edit.editor` is rendered as JSX, so its identity is its component type. An
+inline arrow function is a new type on every render, which unmounts the open
+editor and discards what was being typed.
+
+Wrong:
+
+```tsx
+meta: { edit: { editor: ({ field }) => <Slider value={field.state.value} /> } },
+```
+
+Correct:
+
+```tsx
+// Module scope, referenced by name.
+const SalaryEditor: TMDataGridEditorComponent = ({ field, commit }) => (
+  <Slider
+    value={Number(field.state.value ?? 0)}
+    onChange={(next) => field.handleChange(next)}
+    onChangeEnd={() => void commit()}
+  />
+);
+
+meta: { edit: { editor: SalaryEditor } },
+```
+
+Source: `src/docs/editors.md`, `src/tmdatagrid/core/editEngine.ts`.
+
+## HIGH A cross-field rule under `editing.mode: "cell"`
+
+Under `"cell"` each cell commits on its own, so a rule spanning two columns
+cannot be satisfied by either one: the first cell edited is rejected against the
+other column's old value, and the row cannot be saved.
+
+Correct: `editing.rowValidators` needs `mode: "row"` or `"draft"`, which
+validate the whole row in one commit.
+
+Source: `src/docs/editors.md` (Validation).
+
+## HIGH An `accessorFn` column that never opens an editor
+
+Editability follows the data path, not the column. A column built on an accessor
+function has no `accessorKey`, so it maps to nothing and stays read-only while
+every other column edits. No warning is raised.
+
+Wrong:
+
+```tsx
+columnHelper.accessor((row) => `${row.firstName} ${row.lastName}`, {
+  id: "fullName",
+  header: "Full name",
+});
+```
+
+Correct:
+
+```tsx
+columnHelper.accessor((row) => `${row.firstName} ${row.lastName}`, {
+  id: "fullName",
+  header: "Full name",
+  meta: { label: "Full name", edit: { field: "lastName" } },
+});
+```
+
+Source: `src/docs/editing.md` (Which cells edit).
+
+## HIGH Swallowing the error in `editing.onCommit`
+
+The draft is dropped when `editing.onCommit` resolves. A `try/catch` that logs
+the failure resolves it, so a save that failed on the server clears the editor
+and the grid shows the old value as though nothing happened.
+
+Wrong:
+
+```tsx
+onCommit: async ({ rowId, changes }) => {
+  try {
+    await api.patch(rowId, changes);
+  } catch (error) {
+    console.error(error);
+  }
+},
+```
+
+Correct: no `catch` - let the rejection propagate, and the form stays open
+with the error on the row.
+
+Source: `src/tmdatagrid/useTMDataGrid.tsx` (`TMDataGridEditingCallbacks`).
+
+## HIGH Submitting an outer form while the grid holds a draft
+
+The outer form's array contains only committed rows. Under any mode a mid-edit
+row is invisible to it, and under `"draft"` every edit is until `submitAll()`,
+so a form submit saves stale rows and collection rules skip pending values.
+
+Correct:
+
+```tsx
+const hasOpenDraft = useSelector(grid.edit.store, (s) => s.openRowIds.length > 0);
+
+<Button type="submit" disabled={!canSubmit || hasOpenDraft}>Save</Button>
+// or flush instead of blocking:
+const flushed = await grid.edit.submitAll();
+if (flushed) await form.handleSubmit();
+```
+
+Source: `src/docs/query-builder.md` (Which mode, Submitting).
+
+## MEDIUM Reading a commit's result as the saved value
+
+`edit.commit(rowId)` and `edit.submitAll()` resolve to a `boolean` saying
+whether the form closed, and resolve `false` when validation or a rejected save
+kept it open. Ignoring the result reports a save that did not happen.
+
+```tsx
+const saved = await grid.edit.submitAll();
+notifications.show({ message: saved ? "Saved" : "Some rows need attention" });
+```
+
+Source: `src/tmdatagrid/core/editEngine.ts` (`TMDataGridEditApi`).
+
+## MEDIUM Expecting `editing.onRowDelete` to fire under draft
+
+Under the immediate modes `edit.deleteRow` calls `editing.onRowDelete` at once.
+Under `"draft"` it only toggles a deletion mark, so nothing is removed until
+`submitAll`: the ids arrive as `deleted` in `editing.onCommitDrafts`, or, with
+no such callback, in the per-row `editing.onRowDelete` loop. A confirmation
+placed inside `editing.onRowDelete` therefore guards the save, not the trash.
+
+Source: `src/docs/editing.md` (Adding and deleting rows).

package/skills/editing/references/editing-api.md

@@ -8,22 +8,24 @@ kind.
 | Name | Type | Default | What it does |
 | --- | --- | --- | --- |
 | `editing` | `TMDataGridEditingOptions` | off | The editing namespace. Setting it turns editing on. |
-| `editing.mode` | `"cell" \| "cellConfirm" \| "row" \| "batch"` | – | Picks the commit policy. |
+| `editing.mode` | `"cell" \| "cellConfirm" \| "row" \| "draft"` | – | Picks the commit policy. |
 | `getRowId` | `(row) => string` | – | A TanStack table option, required once `editing` is set. Drafts are keyed by it. |
 | `editing.isRowEditable` | `(row) => boolean` | – | Closes a whole row to editing, in every mode. |
 | `editing.rowValidators` | `TMDataGridRowValidators` | – | Form-level validation. Cross-field rules live here. |
 | `editing.newRowDefaults` | `TData \| (() => TData)` | – | Seeds the entry row's form. A function is called per added row. |
+| `editing.newRowsSticky` | `boolean` | `false` | Draft mode only. Keeps entered new rows pinned in the entry block until Save all, instead of letting them scroll with the body. |
 | `cellSelection` | `"none" \| "single" \| "range"` | `"single"` while `editing` is set | Editing turns the cell cursor on; set it explicitly to override. |
 
 Passing any other member of `editing` without `mode` is a compile error, and
-`onCommitBatch` exists only in the `"batch"` branch of the type.
+`onCommitDrafts` and `newRowsSticky` exist only in the `"draft"` branch of the
+type.
 
 ## Callbacks
 
 | Name | Argument | What it does |
 | --- | --- | --- |
 | `editing.onCommit` | `{ rowId, value, original, changes, source }` | Applies one row's change. Reject to keep the draft and show the error. |
-| `editing.onCommitBatch` | `{ rows, added, deleted }` | Batch only. One call for the entire save. Without it, `submitAll` loops `editing.onCommit`. |
+| `editing.onCommitDrafts` | `{ rows, added, deleted }` | Draft mode only. One call for the entire save. Without it, `submitAll` loops `editing.onCommit`, `editing.onRowAdd` and `editing.onRowDelete`. |
 | `editing.onRowAdd` | `{ tempId, value }` | Commits an entry row. Mint the real id here. |
 | `editing.onRowDelete` | `{ rowId, row }` | Deletes a row under the immediate modes, and puts the trash can in the edit lane. |
 
@@ -47,15 +49,15 @@ path, which may be dotted.
 
 | Member | Signature | Notes |
 | --- | --- | --- |
-| `begin` | `({ rowId, columnId }) => void` | Row mode opens the entire row either way. `columnId` selects which cell takes the caret; `null` (the pencil) uses its first editable one. |
-| `commit` | `(rowId) => Promise<boolean>` | `false` keeps the form open with its errors. |
+| `begin` | `({ rowId, columnId }) => void` | Row mode opens the entire row either way. `columnId` selects which cell takes the caret; `null` (the pencil) uses its first editable one. On an entered new row it reopens the row, flipping `confirmed` back to `false`. |
+| `commit` | `(rowId) => Promise<boolean>` | `false` keeps the form open with its errors. Under `"draft"` it validates and holds the draft: no consumer callback runs until `submitAll`. |
 | `cancel` | `(rowId) => void` | Drops one draft. |
 | `cancelAll` | `() => void` | Drops every draft. |
 | `deactivate` | `() => void` | Closes the editor without touching the draft, as blur does under `"cellConfirm"`. |
-| `submitAll` | `() => Promise<boolean>` | Batch's save. `true` when every row landed. |
+| `submitAll` | `() => Promise<boolean>` | Draft mode's Save all. `true` when every row landed. |
 | `clearCell` | `(rowId, columnId) => Promise<boolean>` | What Delete does: writes the type's empty value and commits. |
 | `addRow` | `() => string` | Opens an entry row, returns its `tempId`. |
-| `deleteRow` | `(rowId) => void` | `editing.onRowDelete` under the immediate modes, a deletion mark under batch. |
+| `deleteRow` | `(rowId) => void` | `editing.onRowDelete` under the immediate modes, a deletion mark under draft mode. Toggles: a second call restores the row. |
 | `canEditCell` | `(row, column) => boolean` | The check the built-in controls use. |
 | `canEditRow` | `(row) => boolean` | The pencil's gate. |
 | `canDeleteRows` | `() => boolean` | Whether the delete control should be shown. |
@@ -70,17 +72,23 @@ type TMDataGridEditState = {
   // The cell the last open gesture named - where the caret goes.
   active: { rowId: string; columnId: string | null } | null;
   // Rows with a live form. One under `"cell"`; as many as the user opened
-  // under `"row"`, `"cellConfirm"` and `"batch"` - which rows are editing.
+  // under `"row"`, `"cellConfirm"` and `"draft"` - which rows are editing.
   openRowIds: ReadonlyArray<string>;
+  // One `TMDataGridEditRowProjection` per open row.
   rows: Record<
     string,
     {
       dirtyFields: ReadonlyArray<string>;
       errorFields: ReadonlyArray<string>;
+      hasRowError: boolean;
       isSubmitting: boolean;
+      // The row as drafted, reference-stable while no value changes.
+      values: TMDataGridRowData;
     }
   >;
-  newRows: ReadonlyArray<{ tempId: string }>;
+  // `confirmed` is draft mode's "entered, awaiting Save all". Under the
+  // immediate modes a confirm commits through `onRowAdd`, so it stays `false`.
+  newRows: ReadonlyArray<{ tempId: string; confirmed: boolean }>;
   deletedRowIds: ReadonlyArray<string>;
 };
 ```
@@ -98,7 +106,7 @@ type TMDataGridEditState = {
 | `TMDataGridStringEditor` … `TMDataGridMultiSelectEditor` | Exports | The six built-in editors, for wrapping. |
 
 Types: `TMDataGridEditMode`, `TMDataGridEditApi`, `TMDataGridEditState`,
-`TMDataGridEditCommitArgs`, `TMDataGridEditCommitBatchArgs`,
+`TMDataGridEditCommitArgs`, `TMDataGridEditCommitDraftsArgs`,
 `TMDataGridEditChange`, `TMDataGridEditorArgs`, `TMDataGridEditorComponent`,
 `TMDataGridEditField`, `TMDataGridEditRowProjection`, `TMDataGridFieldValidate`,
 `TMDataGridRowValidators`, `TMDataGridRowEditForm`, `TMDataGridRowAddArgs`,
@@ -110,20 +118,38 @@ Generated, pinned right, id `EDIT_COLUMN_ID`. It appears when any of these
 holds:
 
 - `editing.mode: "row"` - the lane is Save and Cancel's home
+- `editing.mode: "draft"` - the lane is the change indicator and the per-row
+  revert, and `editing.onCommitDrafts` is not required for it
 - `editing.onRowDelete` is set - the trash can has somewhere to report to
-- `editing.mode: "batch"` **and** `editing.onCommitBatch` is set
 
 `"cell"` and `"cellConfirm"` have no lane unless `editing.onRowDelete` asks for
 one.
 
+What the lane holds depends on the mode. Under `"row"` an open row shows
+`save-row` and `cancel-row`; those two never render under `"draft"`. Under
+`"draft"` every changed row shows `row-state`, whose `data-state` is `new`,
+`edited` or `deleted`, together with `revert-row` on an edited row,
+`restore-row` on one marked for deletion, and `edit-row` plus `discard-new-row`
+on an entered new row. A row holding a dirty draft hides `delete-row`. Every
+control carries a tooltip from the labels, `revertRow`, `rowStateNew`,
+`rowStateEdited` and `rowStateDeleted` among them.
+
 ## Styling and test hooks
 
 | Name | Kind | What it is |
 | --- | --- | --- |
 | `--dg-entry-height` | CSS variable | Height of the sticky entry block. From `size`. |
-| `data-deleted` | Row attribute | On a row marked for deletion under batch. |
+| `--dg-row-new-bg` | CSS variable | Background of an entered new row. A green tint. |
+| `data-deleted` | Row attribute | On a row marked for deletion under draft mode. |
+| `data-dirty` | Row attribute | On a body row holding a dirty draft. Also on the cell whose field is dirty. |
+| `data-new` / `data-confirmed` | Entry row attributes | On an entry row; `data-confirmed` once it is entered, awaiting Save all. |
+| `data-dg-entry-flow-block` | Attribute | The in-flow block above the body rows holding entered new rows, unless `editing.newRowsSticky` keeps them in the sticky entry block. |
 | `data-dg-part="editor-input"` | Part | The control inside an editing cell. |
-| `data-dg-part="save-row"` / `"cancel-row"` | Parts | The edit lane's buttons, with `data-row-id`. |
+| `data-dg-part="save-row"` / `"cancel-row"` | Parts | The edit lane's buttons on an open row, with `data-row-id`. Row mode only. |
+| `data-dg-part="row-state"` | Part | Draft mode's change marker, with `data-row-id` and `data-state` of `new`, `edited` or `deleted`. |
+| `data-dg-part="revert-row"` / `"restore-row"` | Parts | Drops a row's draft, and undoes a deletion mark, with `data-row-id`. |
+| `data-dg-part="edit-row"` / `"delete-row"` | Parts | The idle lane's pencil and trash, with `data-row-id`. `edit-row` also reopens an entered new row. |
+| `data-dg-part="confirm-new-row"` / `"discard-new-row"` | Parts | An entry row's ✓ and ✕, with `data-row-id`. |
 | `data-dg-part="save-all"` / `"discard-all"` | Parts | `EditActions`. |
 
 See the `testing` skill for how to compose these into selectors.

package/skills/editing/references/editors-and-validation.md

@@ -214,7 +214,7 @@ issue lands on the column whose `editField` is `"address.city"`.
 
 Cross-field rules need a mode that commits the whole row at once. Under `"cell"`
 each cell commits alone, so the rule is evaluated against the other column's
-unedited value and cannot pass. Use `"row"` or `"batch"`.
+unedited value and cannot pass. Use `"row"` or `"draft"`.
 
 ## Server-side errors
 
@@ -242,9 +242,12 @@ row.
 
 | Marker | Means |
 | --- | --- |
+| The cell's own value | A held draft is displayed: the cell renders the draft value through the column's `cell` renderer, in every mode |
 | Blue cell corner | The field is dirty against its original value |
 | Red cell corner | The field carries a validation error |
 | Row error text | A pathless rule failed, or a commit was rejected |
+| `data-dirty` on the row | The row holds a dirty draft |
 
 The same information is readable from `edit.store`: `rows[rowId].dirtyFields`,
-`rows[rowId].errorFields`, `rows[rowId].isSubmitting`.
+`rows[rowId].errorFields`, `rows[rowId].hasRowError`,
+`rows[rowId].isSubmitting`, and `rows[rowId].values` for the draft itself.

package/skills/filtering/SKILL.md

@@ -15,7 +15,7 @@ description: >
 metadata:
   type: core
   library: '@jielga/tmdatagrid'
-  library_version: '2.0.0-beta.1'
+  library_version: '2.0.0-beta.2'
 sources:
   - 'Jielga/TMDataGrid:src/docs/filtering.md'
   - 'Jielga/TMDataGrid:src/docs/quick-search.md'

package/skills/getting-started/SKILL.md

@@ -11,7 +11,7 @@ description: >
 metadata:
   type: core
   library: '@jielga/tmdatagrid'
-  library_version: '2.0.0-beta.1'
+  library_version: '2.0.0-beta.2'
 sources:
   - 'Jielga/TMDataGrid:src/docs/getting-started.md'
   - 'Jielga/TMDataGrid:src/docs/anatomy.md'

package/skills/grouping/SKILL.md

@@ -14,7 +14,7 @@ description: >
 metadata:
   type: core
   library: '@jielga/tmdatagrid'
-  library_version: '2.0.0-beta.1'
+  library_version: '2.0.0-beta.2'
 sources:
   - 'Jielga/TMDataGrid:src/docs/grouping.md'
   - 'Jielga/TMDataGrid:src/docs/summary-row.md'

package/skills/options/SKILL.md

@@ -14,7 +14,7 @@ description: >
 metadata:
   type: core
   library: '@jielga/tmdatagrid'
-  library_version: '2.0.0-beta.1'
+  library_version: '2.0.0-beta.2'
 sources:
   - 'Jielga/TMDataGrid:src/docs/use-tm-data-grid.md'
   - 'Jielga/TMDataGrid:src/tmdatagrid/useTMDataGrid.tsx'
@@ -65,7 +65,7 @@ rather than forwarded to TanStack.
 | `initialState` | `Partial<TableState>` | See below | Merged over the grid defaults. |
 | `meta` | `TMDataGridTableMeta` | `{}` | Grid configuration, see below. |
 | `persist` | `TMDataGridPersistence` | – | State persistence, see below. |
-| `editing` | `TMDataGridEditingOptions` | off | Turns editing on. `mode` (`"cell" \| "cellConfirm" \| "row" \| "batch"`) picks the commit policy; the object also holds `onCommit`, `onCommitBatch`, `rowValidators`, `isRowEditable`, `newRowDefaults`, `onRowAdd` and `onRowDelete` - see the `editing` skill. |
+| `editing` | `TMDataGridEditingOptions` | off | Turns editing on. `mode` (`"cell" \| "cellConfirm" \| "row" \| "draft"`) picks the commit policy; the object also holds `onCommit`, `onCommitDrafts`, `rowValidators`, `isRowEditable`, `newRowDefaults`, `newRowsSticky`, `onRowAdd` and `onRowDelete` - see the `editing` skill. |
 | `labels` | `TMDataGridLabelsOverride` | English | Overrides for the grid's strings and `aria-label`s. |
 
 ### Default initial state

package/skills/rows/SKILL.md

@@ -17,7 +17,7 @@ description: >
 metadata:
   type: core
   library: '@jielga/tmdatagrid'
-  library_version: '2.0.0-beta.1'
+  library_version: '2.0.0-beta.2'
 sources:
   - 'Jielga/TMDataGrid:src/docs/row-selection.md'
   - 'Jielga/TMDataGrid:src/docs/row-interaction.md'

package/skills/rows/references/rows-api.md

@@ -69,7 +69,7 @@ Row data attributes:
 | `data-grouped` | Group rows |
 | `data-depth` | Every row - the nesting level |
 | `data-context-menu` | The row whose context menu is open |
-| `data-deleted` | Rows marked for deletion under batch editing |
+| `data-deleted` | Rows marked for deletion under draft editing |
 | `data-row-id` | Every row - its id |
 
 ## Details

package/skills/server-side/SKILL.md

@@ -10,7 +10,7 @@ description: >
 metadata:
   type: core
   library: '@jielga/tmdatagrid'
-  library_version: '2.0.0-beta.1'
+  library_version: '2.0.0-beta.2'
 sources:
   - 'Jielga/TMDataGrid:src/docs/server-side.md'
   - 'Jielga/TMDataGrid:src/tmdatagrid/useTMDataGrid.tsx'

package/skills/testing/SKILL.md

@@ -11,7 +11,7 @@ description: >
 metadata:
   type: core
   library: '@jielga/tmdatagrid'
-  library_version: '2.0.0-beta.1'
+  library_version: '2.0.0-beta.2'
 sources:
   - 'Jielga/TMDataGrid:src/docs/testing.md'
   - 'Jielga/TMDataGrid:src/tmdatagrid/components/TMDataGrid.tsx'
@@ -71,7 +71,8 @@ Body cells carry no `data-dg-part` - the coordinate pair already names them.
 
 **Keyed by `data-row-id`**: `row`, `entry-row`, `details`, `select-row`,
 `details-toggle`, `group-toggle`, `edit-row`, `delete-row`, `save-row`,
-`cancel-row`, `restore-row`, `confirm-new-row`, `discard-new-row`.
+`cancel-row`, `row-state`, `revert-row`, `restore-row`, `confirm-new-row`,
+`discard-new-row`.
 
 **Keyed by `data-column-id`**: `header`, `header-sort`, `header-menu`,
 `header-filter`, `filter-row`, `filter-pill`, `columns-toggle`.

package/src/tmdatagrid/components/TMDataGrid.module.css

@@ -71,6 +71,13 @@
     var(--mantine-color-text) 3.5%,
     var(--mantine-color-body)
   );
+  /* A confirmed entry row under draft mode - entered, awaiting Save all. A
+     whisper of green over the body, one declaration for both themes. */
+  --dg-row-new-bg: color-mix(
+    in srgb,
+    var(--mantine-color-green-6) 8%,
+    var(--mantine-color-body)
+  );
 
   /* The stacking ladder, stated once. Body cells sit at auto (0); everything
      sticky stacks over them in this order, and a sticky row crossing a sticky

package/src/tmdatagrid/components/TMDataGridCellEditor.tsx

@@ -43,7 +43,7 @@ const BUILT_IN_EDITORS: Record<
 export type TMDataGridCellEditorClose =
   | { committed: true; via: "enter" | "tab" | "shift-tab" | "pick" }
   | { committed: false; via: "escape" }
-  /** Batch: the editor closed, the draft stays - Enter parks, Tab moves on. */
+  /** Draft: the editor closed, the draft stays - Enter parks, Tab moves on. */
   | { committed: false; via: "defer" | "defer-tab" | "defer-shift-tab" };
 
 /**
@@ -59,6 +59,7 @@ export function TMDataGridCellEditor({
   row,
   takeSeedText,
   onClose,
+  inEntryBlock = false,
 }: {
   cell: Cell<TMDataGridFeatures, TMDataGridRowData, unknown>;
   row: Row<TMDataGridFeatures, TMDataGridRowData>;
@@ -66,6 +67,13 @@ export function TMDataGridCellEditor({
   takeSeedText: () => string | undefined;
   /** After the editor closed itself - the table moves the focus. */
   onClose: (args: TMDataGridCellEditorClose) => void;
+  /**
+   * Hosted by the entry block rather than a body cell. Under draft the keys
+   * change meaning there: Enter confirms the whole entry (the engine parks
+   * it), and Tab stays the browser's, walking the entry row's own inputs the
+   * way row mode's do.
+   */
+  inEntryBlock?: boolean;
 }) {
   const { table, edit, features, labels, controlSize } = useTMDataGridContext();
   // Row mode mounts one host per editable cell of the row; every key that
@@ -164,7 +172,7 @@ export function TMDataGridCellEditor({
     onClose({ committed: false, via: "escape" });
   };
 
-  /** Batch: the key closes the editor and leaves the draft for submitAll. */
+  /** Draft: the key closes the editor and leaves the draft for submitAll. */
   const deferAndClose = (via: "defer" | "defer-tab" | "defer-shift-tab") => {
     if (closingRef.current) return;
     closingRef.current = true;
@@ -173,23 +181,27 @@ export function TMDataGridCellEditor({
   };
 
   const handleKeyDown = (event: KeyboardEvent<HTMLDivElement>) => {
-    const isBatch = features.editMode === "batch";
+    const isDraft = features.editMode === "draft";
     if (event.key === "Enter") {
       event.preventDefault();
       event.stopPropagation();
       // In row mode Enter (and Ctrl+Enter, the documented pair) saves the
-      // row; in batch nothing commits until submitAll, so Enter just parks
-      // the draft.
-      if (isBatch) deferAndClose("defer");
+      // row; in draft nothing reaches a callback until submitAll, so Enter
+      // parks the draft - and in the entry block it confirms the entry, which
+      // the engine parks the same way.
+      if (isDraft && !inEntryBlock) deferAndClose("defer");
       else void commitAndClose("enter");
     } else if (event.key === "Escape") {
       event.preventDefault();
       event.stopPropagation();
       cancelAndClose();
-    } else if (event.key === "Tab" && !isRowMode) {
+    } else if (event.key === "Tab" && !isRowMode && !(isDraft && inEntryBlock)) {
+      // In the draft entry block Tab stays the browser's: every editable
+      // cell's editor is mounted, so it walks the row's inputs as row mode's
+      // does.
       event.preventDefault();
       event.stopPropagation();
-      if (isBatch) {
+      if (isDraft) {
         deferAndClose(event.shiftKey ? "defer-shift-tab" : "defer-tab");
       } else {
         void commitAndClose(event.shiftKey ? "shift-tab" : "tab");

package/src/tmdatagrid/components/TMDataGridEditActions.tsx

@@ -120,7 +120,7 @@ export type TMDataGridEditActionsProps = {
 };
 
 /**
- * Batch mode's toolbar chrome: Save with the dirty-row count, and Discard.
+ * Draft mode's toolbar chrome: Save with the dirty-row count, and Discard.
  * Both read the edit store, so they grey out while nothing is dirty and the
  * Save spins while a submit is in flight. Works under any `editing.mode` - a
  * cellConfirm grid accumulating drafts can offer the same pair - and renders