@opencorestack/opengridx 3.3.0 → 3.4.0

package/docs/API_REFERENCE.md

@@ -82,6 +82,35 @@ interface GridSelectedCell { id: GridRowId; field: string; value: unknown }
 
 Public CSS: `ogx__cell--range`, `ogx__cell--range-top` / `-bottom` / `-left` / `-right`, `ogx--range-dragging` (root, during a drag), `--ogx-range-background`, `--ogx-range-border`. Range cells carry `aria-selected="true"`.
 
+#### Paste and Range Clear (v3.4)
+
+| Prop | Type | Default | Description |
+| :--- | :--- | :--- | :--- |
+| `disableClipboardPaste` | `boolean` | `false` | With `cellSelection` on, Ctrl/Cmd+V pastes tab-separated text into the editable cells (through `valueSetter` and `processRowUpdate`, once per row). `true` turns the shortcut off; `apiRef.current.pasteText()` still works. See [Clipboard](features/clipboard.md#-paste-from-excel-and-google-sheets-v34). |
+| `onClipboardPaste` | `(result: GridClipboardPasteResult) => void` | — | Fired after every paste, once every row has settled: `{ updated, failed, skipped, text }`. |
+| `onBeforeClipboardPaste` | `(params: GridBeforeClipboardPasteParams) => boolean \| string` | — | Runs before a paste with `{ text, anchor }`. Return `false` to cancel, a string to paste instead. A throw cancels the paste. |
+| `disableRangeClear` | `boolean` | `false` | With `cellSelection`, Delete / Backspace on a range of more than one cell empties its editable cells (`''` for strings, `null` otherwise) as one edit. `true` turns that off. |
+
+#### Undo / Redo (v3.4)
+
+| Prop | Type | Default | Description |
+| :--- | :--- | :--- | :--- |
+| `undoRedo` | `boolean \| GridUndoRedoOptions` | `false` | History of committed edits, pastes and range clears: Ctrl/Cmd+Z, Ctrl/Cmd+Shift+Z, Ctrl+Y (focus on a cell, no editor open) and `apiRef.undo()` / `redo()`. Undo and redo write through `valueSetter` and `processRowUpdate`; cells changed since are skipped (`'changed'`). `{ limit }`: actions kept, default 100. See [Undo & Redo](features/undo-redo.md). |
+| `onHistoryChange` | `(params: GridHistoryChangeParams) => void` | — | Fired when `canUndo`, `canRedo` or `size` (actions that can be undone) changes. |
+
+```ts
+type GridEditSkipReason = 'notEditable' | 'invalidValue' | 'changed' | 'missing';
+interface GridBatchEditResult {
+  updated: GridRowId[];                                   // rows stored (processRowUpdate succeeded)
+  failed: { id: GridRowId; error: unknown }[];            // also sent to onProcessRowUpdateError
+  skipped: { id: GridRowId; field: string; reason: GridEditSkipReason }[];
+}
+interface GridClipboardPasteResult extends GridBatchEditResult { text: string }
+interface GridBeforeClipboardPasteParams { text: string; anchor: GridCellCoordinates | null }
+interface GridHistoryChangeParams { canUndo: boolean; canRedo: boolean; size: number }
+interface GridUndoRedoOptions { limit?: number }
+```
+
 #### Column Visibility
 
 | Prop | Type | Default | Description |
@@ -329,6 +358,11 @@ Access these methods via the `apiRef` prop.
 | `clearCellSelection()` | `void` | Empty the cell selection (`reason: 'clear'`) (v3.3). |
 | `getSelectedCells()` | `GridSelectedCell[]` | Cells of the range in display order with values read through `valueGetter`. Synthetic rows and span-covered positions are left out (v3.3). |
 | `copySelectedCells()` | `Promise<void>` | Copy the range (the focused cell when nothing else is selected) as TSV without a header line. Resolves without writing when there is nothing to copy; rejects when the clipboard write fails (v3.3). |
+| `pasteText(text, anchor?)` | `Promise<GridBatchEditResult>` | Paste tab-separated text as Ctrl/Cmd+V does, from `anchor` (default: the range's top-left cell, else the focused cell), with `onBeforeClipboardPaste` / `onClipboardPaste`. Works with `disableClipboardPaste` and without `cellSelection` (then pass `anchor` or focus a cell) (v3.4). |
+| `undo()` | `Promise<GridBatchEditResult>` | Undo the last action (`undoRedo`); resolves once every row has settled (v3.4). |
+| `redo()` | `Promise<GridBatchEditResult>` | Redo the last undone action (v3.4). |
+| `canUndo()` / `canRedo()` | `boolean` | Whether there is an action to undo / redo (v3.4). |
+| `clearHistory()` | `void` | Forget every undo and redo action (v3.4). |
 | `copySelectedRows()` | `Promise<void>` | Copy every selected row that passes the filter (other pages, collapsed groups and pinned rows included) as TSV, with the visible columns in screen order. Resolves without writing when no selected row is found; rejects when the clipboard write fails. |
 
 ---
@@ -385,6 +419,7 @@ Defines the behavior and appearance of a single column.
 | `valueOptions` | `Array<string \| number \| { value: unknown; label: string }>` | — | Allowed values for `type: 'singleSelect'` — the filter panel offers them as a (multi-)select, and the edit cell uses them; cells and exports show the option's label. |
 | `valueGetter` | `(params: GridValueGetterParams) => unknown` | — | Derive a computed value from the row object. Runs before `valueFormatter` and `renderCell`. Client-side sorting, column filters and the quick filter use this value, and editors start from it (double-click and Enter alike). Keep it pure: the quick filter caches each row's search text per row object and column set. A getter that throws for a row shows an error in that cell and reads as `undefined` for sorting, filtering, aggregation, grouping, pivot and list view (v3.0+, with a one-time development warning per column); before, it crashed the grid once the column was sorted, filtered or aggregated. |
 | `valueSetter` | `(params: GridValueSetterParams) => R` | — | v3.0+. Maps an edited value back onto the row (`{ value, row, field }` → updated row) when an edit is committed. Needed for editable `valueGetter` columns; without it the commit writes `row[field]` and a development warning is logged. |
+| `valueParser` | `(text: string, params: GridValueParserParams) => unknown` | — | v3.4+. Turns pasted text into this column's value instead of the default parser for its `type` (`{ row, field, colDef }`). Throw or return `undefined` to skip the cell (`'invalidValue'`). See [Clipboard](features/clipboard.md#valueparser). |
 | `valueFormatter` | `(params: GridValueFormatterParams) => string` | — | Format the value into a display string (e.g. currency, dates). Does not affect editing, sorting or column filters; the quick filter also searches the formatted text. A formatter that throws leaves the value unformatted (the quick filter searches the raw value; v3.0+). |
 
 #### Rendering
@@ -433,6 +468,7 @@ Span values are floored; `Infinity` means "to the end"; `NaN`, `0` and negative
 | `groupingValueFormatter` | `(params: { field: string; value: unknown }) => string` | — | Custom formatter for group-header labels when this column is the active grouping field. Falls back to `"field: value"` when omitted or when it throws (v3.0+). |
 | `aggregable` | `boolean` | — | Whether this column can be aggregated. Unset, the toolbar's Summaries panel and the pivot panel's value fields offer it only for `type: 'number'` columns; `true` offers it for any type. `false` keeps it out of both panels, and an `aggregationModel` or `pivotModel` entry naming it is ignored (no footer total, group aggregate, pivot value or export total). |
 | `availableAggregationFunctions` | `string[]` | all built-ins | Restrict which aggregation functions are computed and available for this column (e.g. `['sum', 'avg']`). Functions outside this list are skipped even if set in `aggregationModel` or a pivot value field, the toolbar's Summaries panel and the pivot panel offer only these. |
+| `aiExamples` | `unknown[]` | — | Example values put into the schema from `getGridAiSchema` (`@opencorestack/opengridx/ai`) to help a model write filters. **These values are sent to the model**: the schema never reads row data, so only what you list here leaves the app. Strings, numbers and booleans, at most 10. Not used by the grid itself (v3.4.0+). |
 
 ---
 
@@ -453,6 +489,32 @@ Every exporter takes `columns` typed for your rows (`GridColDef<R>[]`) or untype
 
 ---
 
+## 🤖 AI Toolkit (`@opencorestack/opengridx/ai`)
+
+A separate entry point (v3.4.0+) with no React import and no dependencies; the core package never loads it. It does not call any AI service: the app sends the schema to its own model and validates the reply. Guide: [AI Toolkit](features/ai-toolkit.md).
+
+```ts
+import { getGridAiSchema, validateGridAiState } from '@opencorestack/opengridx/ai';
+import type { GridAiState, GridAiValidationError } from '@opencorestack/opengridx/ai';
+```
+
+| Function | Return | Description |
+| :--- | :--- | :--- |
+| `getGridAiSchema(columns, options?)` | `GridAiSchema` | JSON Schema (draft 2020-12, `schemaVersion: 1`) of the `filterModel` (nested AND/OR groups up to 3 levels, `quickFilterValues`), `sortModel`, `rowGroupingModel`, `aggregationModel`, `pivotModel` and `columnVisibilityModel` the columns allow, honouring `filterable`, `sortable`, `groupable`, `hideable`, `aggregable`, `availableAggregationFunctions` and `valueOptions`. Operators per column come from the column type. Reads column definitions only, never rows; deterministic for the same input. |
+| `validateGridAiState(json, columns, options?)` | `GridAiValidationResult` | `{ state, errors }`. `json` is an object or a JSON string. Drops unknown parts, fields, operators and enum values (each with an `{ path, message }` error), coerces values to the column type (`"1,200"` → `1200`, dates → `"YYYY-MM-DD"`), removes empty filter groups. Never throws. |
+
+`GridAiSchemaOptions`: `include` / `exclude` (`GridAiPart[]`: `'filter' \| 'sort' \| 'grouping' \| 'aggregation' \| 'pivot' \| 'columnVisibility'`; `exclude` wins), `descriptions` (default `true`: each column's `headerName` and `description` go into the schema), `examples` (default `true`: the columns' `aiExamples` go into the schema). `GridAiValidateOptions` takes `include` / `exclude`; parts outside them are dropped with an error.
+
+| Type | Description |
+| :--- | :--- |
+| `GridAiColumn` | The column properties the toolkit reads. A `GridColDef` (typed or untyped) is accepted as is. Fields starting with `__` (system columns) are skipped. |
+| `GridAiSchema` | The returned JSON Schema object: `$schema`, `schemaVersion: 1`, `title`, `type: 'object'`, `properties` (one per offered part) and `$defs`. |
+| `GridAiState` | The validated state: `filterModel?`, `sortModel?`, `rowGroupingModel?`, `aggregationModel?`, `pivotModel?`, `columnVisibilityModel?`, the same types the grid's props take. Only parts present in the reply are set. |
+| `GridAiValidationError` | `{ path: string; message: string }`, e.g. `{ path: 'filterModel.items[2].field', message: 'Unknown field "revenue"' }`. At most 100 are listed. |
+| `GridAiValidationResult` | `{ state: GridAiState; errors: GridAiValidationError[] }` |
+
+---
+
 ## 🧩 Standalone Components
 
 The grid's building blocks are exported with their props types (the props types since v3.0). `DataGrid` renders all of them itself; import them to build your own layout or slot.
@@ -469,7 +531,33 @@ The grid's building blocks are exported with their props types (the props types
 | `Cell` | `CellProps` | One body cell. See [Cell](components/cell.md). |
 | `CellSelectionStats` | `CellSelectionStatsProps` | The default status bar of `showCellSelectionStats` (v3.3), e.g. to wrap in a `cellSelectionStats` slot. |
 | `Skeleton` | `SkeletonProps` | Loading placeholder (`rows`, `columns`, both default 5). |
-| `Button`, `Input`, `Checkbox` | `ButtonProps`, `InputProps`, `CheckboxProps` | The grid's form controls. `Button` defaults to `type="button"`. |
+| `Button`, `Input`, `Checkbox` | `ButtonProps`, `InputProps`, `CheckboxProps` | The grid's form controls. `Button` defaults to `type="button"`. See [`Input`](#input) and [`Checkbox`](#checkbox) below. |
+
+### `Input`
+A text field: an `<input class="ogx-input">` inside a `<div class="ogx-input-wrapper">` that also holds the adornments. The grid's search boxes, filter value box and text / number / date cell editors render through it. Every other `<input>` attribute (`value`, `onChange`, `type`, `id`, `name`, `aria-*`, …) goes to the `<input>`.
+
+| Prop | Type | Default | Description |
+| :--- | :--- | :--- | :--- |
+| `ref` | `Ref<HTMLInputElement>` | — | Reaches the `<input>` (`forwardRef`, React 18 and 19). Since v3.3.1. |
+| `variant` | `'field' \| 'cell'` | `'field'` | `'field'`: bordered form field. `'cell'`: fills its container (a grid cell), no border, radius, background or focus shadow, cell font and the editor padding; adds `ogx-input-wrapper--cell`. Since v3.3.1. |
+| `inputClassName` | `string` | — | Classes added to the `<input>` next to `ogx-input`. Since v3.3.1. |
+| `className` | `string` | — | Classes added to the wrapper `<div>`. |
+| `fullWidth` | `boolean` | `false` | Wrapper takes 100% width (`ogx-input-wrapper--full-width`). |
+| `error` | `boolean` | `false` | `ogx-input-wrapper--error` (error border; inset error edge in the cell variant) and `aria-invalid="true"` on the `<input>`. |
+| `startAdornment` / `endAdornment` | `ReactNode` | — | Content before / after the `<input>` (`ogx-input__adornment--start` / `--end`), e.g. a currency or a unit. |
+| `disabled` | `boolean` | — | Disables the `<input>` and adds `ogx-input-wrapper--disabled`. |
+
+### `Checkbox`
+A styled checkbox: a visually hidden `<input type="checkbox" class="ogx-checkbox__input">` and a drawn `.ogx-checkbox__box`, inside a `<label class="ogx-checkbox-wrapper">`. Other props (`checked`, `onChange`, `onMouseDown`, `tabIndex`, `aria-*`, …) go to the `<input>`. The grid's row checkboxes, column panel, list view and boolean cell editor use it.
+
+| Prop | Type | Default | Description |
+| :--- | :--- | :--- | :--- |
+| `ref` | `Ref<HTMLInputElement>` | — | Reaches the `<input>` (`forwardRef`). Since v3.3.1. |
+| `inputRef` | `Ref<HTMLInputElement>` | — | Also reaches the `<input>` (kept for compatibility). |
+| `inputClassName` | `string` | — | Classes added to the `<input>` next to `ogx-checkbox__input`. Since v3.3.1. |
+| `className` | `string` | — | Classes added to the wrapper `<label>`. |
+| `indeterminate` | `boolean` | `false` | Shows the indeterminate mark and sets the input's `indeterminate`. |
+| `label` | `string` | — | Visible label text after the box; also the accessible name. |
 
 ---
 
@@ -814,6 +902,15 @@ Passed to `valueSetter` (v3.0+).
 | `row` | `R` | The row as it was before the edit. |
 | `field` | `string` | The column field name. |
 
+### `GridValueParserParams<R>`
+Passed to `valueParser` (v3.4+).
+
+| Property | Type | Description |
+| :--- | :--- | :--- |
+| `row` | `R` | The row the text is pasted into, as stored now. |
+| `field` | `string` | The column field name. |
+| `colDef` | `GridColDef<R>` | The column. |
+
 ### `GridColumnOrderChangeParams`
 Passed to `onColumnOrderChange`.
 

package/docs/README.md

@@ -36,8 +36,9 @@ In-depth guides on the grid's functional capabilities.
 - **[Editing & Reordering](features/editing-reordering.md)** - Inline edits and Drag-and-Drop
 - **[Loading & Performance](features/loading-states.md)** - Skeletons, Lazy, and Infinite loading
 - **[Row Selection](features/selection.md)** - Multi & single choice selection
-- **[Clipboard](features/clipboard.md)** - Copy and Paste grid data
+- **[Clipboard](features/clipboard.md)** - Copy rows and ranges, paste from Excel / Sheets, clear a range with Delete
 - **[Cell Range Selection](features/cell-selection.md)** - Spreadsheet-style cell ranges, copy and a sum / average status bar
+- **[Undo & Redo](features/undo-redo.md)** - Ctrl+Z / Ctrl+Shift+Z for edits, pastes and range clears
 - **[Pinning](features/pinning.md)** - Sticky columns and rows
 - **[State Persistence](features/state-persistence.md)** - Save/Restore grid configuration
 - **[Aggregation & Pivot](features/aggregation-pivot.md)** - Data summarization and analytics
@@ -49,6 +50,7 @@ In-depth guides on the grid's functional capabilities.
 - **[Infinite Scroll](features/infinite-scroll.md)** - Advanced performance loading
 - **[Data Source](features/data-source.md)** - Server-side fetching and SSR
 - **[Export Guide](features/export-guide.md)** - Excel, CSV, JSON, and Print
+- **[AI Toolkit](features/ai-toolkit.md)** - JSON Schema of the grid state for your own model, and a validator for its replies (`@opencorestack/opengridx/ai`)
 
 ---
 

package/docs/architecture/datagrid-orchestration.md

@@ -20,6 +20,11 @@ in an effect, so **keep the call order when you move or add a hook**. In particu
 - `useGridCellSelection` runs after `useGridSpanning` (it needs `getSpanOrigin` and the span caches) and
   before `useGridKeyboardNavigation`, which receives its Shift-key handlers. `useGridCellSelectionApi` runs
   after the keyboard hook because it reads and sets `focusedCell`.
+- `useGridBatchEdit` is created before `useGridEditing` (single edits store through it, so an undo right after an
+  edit reads the stored row before the next render). The history hook needs the focus and selection hooks, so it runs
+  late (36c); commits reach it through `useGridEditCommitChannel` (12a), whose listener it sets in a layout effect.
+  `useGridClipboardPaste` (36b) and `useGridUndoRedo` listen for keys on the grid root with native listeners, which
+  fire before React's delegated `onKeyDown` of the viewport; they act only on cell targets with no editor open.
 - `useGridLiveRowSelection` prunes the selection, and `useGridPageCorrection` corrects a page past the
   end, in effects that run before the later hooks' effects.
 
@@ -40,7 +45,9 @@ in an effect, so **keep the call order when you move or add a hook**. In particu
 | 10 | `useGridRowIdOf` | `hooks/core/useGridRowIdOf.ts` | `getRowIdOf` and its stable event-handler twin |
 | 11 | `useGridApiRefBinding` | `hooks/core/useGridApiRefBinding.ts` | Binds the `apiRef` prop (layout effect) |
 | 12 | `useGridHierarchy` | `hooks/core/useGridHierarchy.ts` | `useTreeData` + `useRowGrouping`, the active handlers and `rowMetaMap` |
-| 13 | `useGridEditing` | `hooks/features/useGridEditing.ts` | Cell editing state and handlers |
+| 12a | `useGridEditCommitChannel` | `hooks/core/useGridUndoRedo.ts` | Stable `emit` / `setListener` pair: the commit paths below report stored changes through `emit`, and `useGridUndoRedo` (36c) registers the listener (v3.4) |
+| 12b | `useGridBatchEdit` | `hooks/features/useGridBatchEdit.ts` | Batch edits (v3.4): `applyEdits` runs `valueSetter` → `processRowUpdate` once per row (rows in parallel, failures isolated and sent to `onProcessRowUpdateError`) and stores every successful row in one `replaceRows` update; `getRow` sees rows stored since the last render; `storeRow` stores a single edit |
+| 13 | `useGridEditing` | `hooks/features/useGridEditing.ts` | Cell editing state and handlers; stores through `useGridBatchEdit.storeRow` and reports the committed change to the channel |
 | 14 | `useGridLiveRowSelection` | `hooks/core/useGridLiveRowSelection.ts` | Selection without removed rows |
 | 15 | `useGridDataSource` | `hooks/features/useGridDataSource.ts` | Server fetching |
 | 16 | `useServerTreeChildren` | `hooks/features/useServerTreeChildren.ts` | Lazy server tree children |
@@ -67,6 +74,8 @@ in an effect, so **keep the call order when you move or add a hook**. In particu
 | 35 | `useGridKeyboardNavigation` | `hooks/core/useGridKeyboardNavigation.ts` | Focus and keyboard handling; takes `cellSelection.keyboard` (Shift+navigation, Escape, Ctrl/Cmd+A) |
 | 36 | `useGridPointerFocusHandlers` | `hooks/core/useGridFocusHandlers.ts` | Cell and header click focus |
 | 36a | `useGridCellSelectionApi` | `hooks/core/useGridCellSelectionApi.ts` | Keeps the range anchor and the focused cell together (layout effect: a new anchor moves focus; focus moved to another data cell collapses the range), clears a range whose corner is gone (`'dataChange'`), and installs `getCellSelectionModel`, `setCellSelectionModel`, `selectCellRange`, `clearCellSelection`, `getSelectedCells`, `copySelectedCells` (once per `apiRef`, reading the latest values from a ref) |
+| 36b | `useGridClipboardPaste` | `hooks/core/useGridClipboardPaste.ts` | Paste and range clear (v3.4): `paste` and Delete/Backspace listeners on the grid root (only for cell targets, not editors or nested grids), TSV parsing (`utils/parsing.ts`), placement against the renderable rows and range columns (`utils/editing/targets.ts`), the batch edit, the new selection, `onBeforeClipboardPaste` / `onClipboardPaste`, and `apiRef.pasteText`. Inert without `cellSelection` except for `pasteText` |
+| 36c | `useGridUndoRedo` | `hooks/core/useGridUndoRedo.ts` | History (v3.4, `undoRedo`): records the channel's changes, replays them as batch edits with an `expect` value per cell (stale cells skipped), queues undo/redo, selects and scrolls to the affected cells, Ctrl/Cmd+Z / Shift+Z / Ctrl+Y on the grid root, `onHistoryChange`, and `apiRef.undo` / `redo` / `canUndo` / `canRedo` / `clearHistory` |
 | 37 | `useGridColumnMenuHandlers` | `hooks/core/useGridHeaderHandlers.ts` | Column menu Hide / Pin (`pinColumnTo` in `utils/pinning`) |
 | 38 | `useGridAriaRows` | `hooks/core/useGridAriaRows.ts` | `aria-rowcount` and `aria-rowindex` bases |
 | 39 | `useGridSpanRowWindow` | `hooks/features/useGridSpanRenderWindow.ts` | Render window widened to whole row spans |

package/docs/customization/theming.md

@@ -340,4 +340,13 @@ const purpleTheme: GridTheme = {
 - The dark mode overrides are in the same file under `@media (prefers-color-scheme: dark)`
 - The CSS entry point for the entire library is `lib/styles/opengridx.css` (single barrel import)
 - BEM class prefix: `ogx__` (e.g. `ogx__cell`, `ogx__header-cell`)
+- **Form controls** — the toolbar search, column-panel search, filter value box and the text / number / date cell
+  editors render through the shared `Input` (v3.3.1+): their `<input>` keeps its own class (`ogx-global-search__input`,
+  `ogx-column-visibility-panel__search-input`, `ogx-filter__value-input`, `ogx__edit-input`) and also has `ogx-input`,
+  and sits inside a `div.ogx-input-wrapper`. Target it with a descendant selector (`.ogx-global-search input`), not a
+  child one (`.ogx-global-search > input`). Cell editors' wrappers also have `ogx-input-wrapper--cell` (fills the cell,
+  no border, background or focus shadow; `ogx-input-wrapper--error` adds an inset `--ogx-color-error` edge). The boolean
+  editor and list-view row checkbox are the shared `Checkbox` (`ogx-checkbox-wrapper`, `ogx-checkbox__box`; the `<input>`
+  keeps `ogx__edit-checkbox` and is visually hidden). `Input.css` loads first in `opengridx.css`, so component rules
+  override it at equal specificity.
 - Variable prefix: `--ogx-` (e.g. `--ogx-color-primary`)

package/docs/features/ai-toolkit.md

@@ -0,0 +1,119 @@
+# AI Toolkit: Grid Schema & Validator
+
+*Since v3.4.0* · Demo: [AI: Grid Schema & Validator](https://opencorestack.github.io/OpenGridX/ai-schema)
+
+Let users drive the grid in plain language ("paid orders over $10k in the North, biggest first") with the model your app already uses. The `@opencorestack/opengridx/ai` entry point gives you the two pieces the grid can own:
+
+- **`getGridAiSchema(columns, options?)`** turns your column definitions into a JSON Schema (draft 2020-12) of the grid state a model may return: filters, sort, row grouping, aggregation, pivot and column visibility, each limited to what the columns allow.
+- **`validateGridAiState(json, columns, options?)`** checks the model's reply against the columns and returns the state that is safe to apply, plus a list of what it dropped.
+
+OpenGridX never calls an AI service and bundles no AI SDK. Your app sends the prompt, the schema and the current state to its own model (with structured output), and passes the reply to the validator.
+
+```ts
+import { getGridAiSchema, validateGridAiState } from '@opencorestack/opengridx/ai';
+
+const schema = getGridAiSchema(columns, { include: ['filter', 'sort', 'grouping', 'aggregation'] });
+
+async function ask(prompt: string) {
+  // Your own endpoint calls your own model, with `schema` as the structured-output format.
+  const res = await fetch('/api/grid-assistant', {
+    method: 'POST',
+    headers: { 'Content-Type': 'application/json' },
+    body: JSON.stringify({ prompt, schema, currentState: { filterModel, sortModel } }),
+  });
+  const { state, errors } = validateGridAiState(await res.text(), columns);
+  if (errors.length) console.info('Dropped from the reply:', errors);
+  if (state.filterModel) setFilterModel(state.filterModel);
+  if (state.sortModel) setSortModel(state.sortModel);
+  if (state.rowGroupingModel) setRowGroupingModel(state.rowGroupingModel);
+  if (state.aggregationModel) setAggregationModel(state.aggregationModel);
+}
+```
+
+The entry point has no React import and no dependencies (about 4.5 kB gzipped). Importing `@opencorestack/opengridx` never loads it, and it works on a server too, so you can validate the reply in the same endpoint that calls the model.
+
+## Privacy rules
+
+- **No row data by default.** The schema is built from column definitions only: `field`, `headerName`, `description`, `type`, the operators of the type, `valueOptions` and the allowed aggregation functions. The grid never reads a row for it.
+- **`aiExamples` is real data.** `GridColDef.aiExamples` puts example values into the schema to help the model ("Acme" → `customer`). Those values are sent to the model. List only what you are happy to share; leave it out for anything personal. `options.examples: false` drops all of them.
+- **`valueOptions` are sent.** The options of a `singleSelect` column become an `enum` in the schema. If an option list is itself sensitive, mark the column `filterable: false` or pass a copy of the columns without it.
+- **Always validate before applying.** Model output is untrusted input. Apply `state`, never the raw reply; show `errors` (or log them) so users can see what was ignored. Show the change to the user and keep it easy to undo.
+- **Check `schemaVersion`.** The schema carries `schemaVersion: 1`. It changes only when the shape of the schema changes, so you can cache prompts or fine-tuning data per version. The validator accepts a `schemaVersion` key in the reply and reports any value other than 1.
+
+## `getGridAiSchema(columns, options?)`
+
+Returns a plain JSON object (no functions), deterministic for the same columns and options, so you can memoise it with the columns.
+
+| Part (state key) | Option name | Shape | Taken from the columns |
+| :--- | :--- | :--- | :--- |
+| `filterModel` | `'filter'` | `GridFilterModel`: `items`, `logicOperator`, nested AND/OR groups up to 3 levels, `quickFilterValues` | Fields with `filterable !== false`; per field the operators of `getOperatorsForType(type)`; `value` typed per column type (number, `YYYY-MM-DD` string, boolean, `valueOptions` enum or a list of them for `isAnyOf`) |
+| `sortModel` | `'sort'` | `GridSortItem[]` | Fields with `sortable !== false` |
+| `rowGroupingModel` | `'grouping'` | `string[]` | Fields with `groupable !== false` |
+| `aggregationModel` | `'aggregation'` | field → function | `type: 'number'` (or `aggregable: true`) columns get every built-in function, other columns `count`; never `aggregable: false`; limited by `availableAggregationFunctions` |
+| `pivotModel` | `'pivot'` | `GridPivotModel` | Groupable fields as row and column labels; value fields as for aggregation (`sum`, `avg`, `count`, `min`, `max`) |
+| `columnVisibilityModel` | `'columnVisibility'` | field → boolean | Fields with `hideable !== false` |
+
+Each filter item is a `oneOf` per field (`field` is a `const`, `operator` an `enum`, `value` typed by the column), which the main structured-output APIs accept. A part that no column allows is left out of the schema.
+
+| Option | Default | Description |
+| :--- | :--- | :--- |
+| `include` | every part | Parts to offer: `'filter' \| 'sort' \| 'grouping' \| 'aggregation' \| 'pivot' \| 'columnVisibility'` |
+| `exclude` | none | Parts to leave out; wins over `include` |
+| `descriptions` | `true` | Put each column's `headerName` and `description` into the schema, so the model can map the user's words ("revenue") to a field (`amt_usd`) |
+| `examples` | `true` | Include the columns' `aiExamples`. Columns without `aiExamples` never send example values |
+
+Columns whose field starts with `__` (the grid's own `__check__`, `__group__` …) are skipped, so `apiRef.current.getAllColumns()` can be passed as is. The `columns` parameter takes any object with the `GridColDef` properties above (`GridAiColumn`); renderers, getters and formatters are ignored.
+
+Example for two columns:
+
+```ts
+getGridAiSchema(
+  [
+    { field: 'amt_usd', headerName: 'Revenue', type: 'number' },
+    { field: 'status', headerName: 'Status', type: 'singleSelect', valueOptions: ['Open', 'Paid'], groupable: false },
+  ],
+  { include: ['filter', 'sort'], descriptions: false },
+);
+// {
+//   $schema: 'https://json-schema.org/draft/2020-12/schema', schemaVersion: 1, title: 'OpenGridX grid state',
+//   type: 'object', additionalProperties: false,
+//   properties: {
+//     filterModel: { type: 'object', additionalProperties: false, properties: {
+//       items: { type: 'array', items: { anyOf: [{ $ref: '#/$defs/filterItem' }, { $ref: '#/$defs/filterGroup1' }] } },
+//       logicOperator: { enum: ['and', 'or'] },
+//       quickFilterValues: { type: 'array', items: { type: 'string' } } } },
+//     sortModel: { type: 'array', items: { type: 'object', additionalProperties: false, required: ['field', 'sort'],
+//       properties: { field: { enum: ['amt_usd', 'status'] }, sort: { enum: ['asc', 'desc'] } } } },
+//   },
+//   $defs: {
+//     filterItem: { oneOf: [
+//       { type: 'object', required: ['field', 'operator'], additionalProperties: false, properties: {
+//         field: { const: 'amt_usd' }, operator: { enum: ['=', '!=', '>', '>=', '<', '<=', 'isEmpty', 'isNotEmpty'] },
+//         value: { type: 'number' } } },
+//       { type: 'object', required: ['field', 'operator'], additionalProperties: false, properties: {
+//         field: { const: 'status' }, operator: { enum: ['isAnyOf', 'is', 'not'] },
+//         value: { anyOf: [{ enum: ['Open', 'Paid'] }, { type: 'array', items: { enum: ['Open', 'Paid'] } }] } } },
+//     ] },
+//     filterGroup1: { … items: filterItem | filterGroup2 }, filterGroup2: { … }, filterGroup3: { … items: filterItem },
+//   },
+// }
+```
+
+## `validateGridAiState(json, columns, options?)`
+
+Returns `{ state, errors }`, where `state` is a `GridAiState` (`filterModel`, `sortModel`, `rowGroupingModel`, `aggregationModel`, `pivotModel`, `columnVisibilityModel`, each present only when the reply contained it) and `errors` is a list of `{ path, message }`, such as `{ path: 'filterModel.items[2].field', message: 'Unknown field "revenue"' }`.
+
+- `json` may be an object or a JSON string. Bad JSON gives one error and an empty state.
+- Unknown parts, unknown fields, fields a column does not allow (`filterable: false` …), operators that do not fit the column type, and functions or enum values outside the allowed list are **dropped**, each with an error. Parts outside `options.include` / `options.exclude` are dropped too.
+- Values are coerced to the column type with the same rules as clipboard paste: `"1,200"`, `"$1,200"` → `1200`, `"12%"` → `0.12`; `"yes"` / `"no"` / `"1"` / `"0"` → booleans; dates (ISO or anything `Date.parse` reads) → the local day as `"YYYY-MM-DD"`, as the filter panel writes it; `singleSelect` values match an option value or label, case-insensitively, and become the option's value. A filter without a usable value is dropped.
+- `asc` / `desc`, `and` / `or`, operators and function names are matched case-insensitively and written in their canonical spelling.
+- A filter group left empty is removed; groups nested deeper than 3 levels are dropped.
+- Lists are read up to 200 entries and at most 100 errors are listed, so a runaway reply stays cheap.
+- It never throws, never returns a field the columns do not allow, and reads only own keys of the reply (never `__proto__`), so a reply cannot reach `Object.prototype`.
+
+Applying an empty part is meaningful: `{ sortModel: [] }` clears the sort. Only apply the parts present in `state`.
+
+## Related
+
+- [Filtering](filtering.md), [Sorting & Pagination](sorting-pagination.md), [Aggregation & Pivot](aggregation-pivot.md), [Tree Data & Grouping](tree-data-grouping.md): the models the schema describes.
+- [API Reference: AI Toolkit](../API_REFERENCE.md)

package/docs/features/clipboard.md

@@ -101,3 +101,91 @@ ID	Name	Email	Status
 ```
 
 When pasted into Excel or Google Sheets, this content will automatically be distributed into the correct cells.
+
+---
+
+## 📥 Paste from Excel and Google Sheets (v3.4)
+
+With `cellSelection` on, **Ctrl/Cmd+V** pastes tab-separated text into the grid's **editable** cells. Each value is parsed for its column and saved like an edit: `valueSetter`, then `processRowUpdate` **once per row**, then the grid stores every row that succeeded in one update. Demo: **Paste from Excel** (`/clipboard-paste`).
+
+```tsx
+<DataGrid
+  rows={rows}
+  columns={columns}          // columns with editable: true
+  cellSelection
+  processRowUpdate={saveRow}
+  onClipboardPaste={({ updated, skipped, failed, text }) =>
+    toast(`${updated.length} rows updated, ${skipped.length} cells skipped`)}
+/>
+```
+
+- Paste works while focus is in the grid and no editor is open. In an open editor, Ctrl/Cmd+V is the input's own paste.
+- The grid reads the `paste` event (`text/plain`), so the browser asks for no clipboard permission.
+- `disableClipboardPaste` turns the shortcut off. `apiRef.current.pasteText(text, anchor?)` still works, for a toolbar "Paste" button that reads the clipboard itself.
+
+### Where values land
+
+| Clipboard | Selection | Result |
+| :--- | :--- | :--- |
+| One value | One cell | That cell |
+| One value | A range | Every cell of the range (Excel's "fill selection") |
+| A block | One cell | The block, from that cell to the right and down |
+| A block | A range | The block from the range's top-left cell; cells past the range, the last row or the last column are dropped |
+
+No rows are created. Only displayed rows are reached: rows on other pages and inside collapsed groups are not. After the paste the pasted area becomes the selection, and one Ctrl/Cmd+Z undoes all of it (with `undoRedo`).
+
+### How text is parsed
+
+The clipboard is read as Excel and Sheets write it: tabs between columns, `\r\n` or `\n` between rows, quoted fields that may hold tabs, line breaks and doubled quotes. A trailing empty line is ignored. Each cell is then parsed for its column:
+
+| Column type | Accepted | Otherwise |
+| :--- | :--- | :--- |
+| `string` (default), `image` | The text as is (an `image` column takes the URL) | — |
+| `number` | `1234.5`, `1,234.5`, `-12`, `(12)`, `12%` (→ 0.12), `1e3`; currency symbols and spaces stripped | skipped, `'invalidValue'` |
+| `date` | ISO `2026-10-07` (that local day), and what `Date.parse` accepts. The value keeps the kind the cell holds: a `Date`, a timestamp, or a `YYYY-MM-DD` string | skipped |
+| `boolean` | `true`/`false`, `yes`/`no` (the grid's `Yes`/`No` labels), `1`/`0`, any case | skipped |
+| `singleSelect` | An option value or an option label, any case; the option's value is stored | skipped |
+| An empty cell | `null` for number, date, boolean and singleSelect; `''` for string | — |
+
+`1,5` is not read as a number: in a decimal-comma locale use a `valueParser`.
+
+### `valueParser`
+
+`GridColDef.valueParser(text, { row, field, colDef })` replaces the parser for one column. Throw (or return `undefined`) to reject the text: the cell is skipped with reason `'invalidValue'`.
+
+```tsx
+{
+  field: 'price',
+  type: 'number',
+  editable: true,
+  // "1.234,5" → 1234.5
+  valueParser: (text) => {
+    const n = Number(text.replace(/[\s€]/g, '').split('.').join('').replace(',', '.'));
+    if (Number.isNaN(n)) throw new Error('not a number');
+    return n;
+  },
+}
+```
+
+### What is skipped
+
+`result.skipped` lists every cell that was not written, with a reason:
+
+| Reason | When |
+| :--- | :--- |
+| `'notEditable'` | The column is not `editable`, `isCellEditable` returned false, the row is a synthetic row (group header, subtotal, tree auto-parent, pivot Grand Total), or the cell is covered by a span |
+| `'invalidValue'` | The text does not parse for the column type, or `valueParser` rejected it |
+
+A row whose `valueSetter` or `processRowUpdate` throws or rejects is listed in `result.failed` and reported to `onProcessRowUpdateError`, as for a single edit; the other rows are still saved. Cells that already hold the pasted value are left alone.
+
+### Events
+
+- `onClipboardPaste(result)` fires after every paste, once every row has settled: `{ updated, failed, skipped, text }`.
+- `onBeforeClipboardPaste({ text, anchor })` runs first. Return `false` to cancel the paste, or a string to paste instead (for example to strip a header line). A throw cancels the paste.
+- Above 10,000 cells a paste logs a development warning.
+
+---
+
+## 🧹 Clear a range with Delete (v3.4)
+
+With `cellSelection` on and a range of **more than one cell**, **Delete** or **Backspace** empties every editable cell of the range: `''` in string and image columns, `null` elsewhere. It is one batch edit through `valueSetter` and `processRowUpdate`, so one undo. Non-editable cells and synthetic rows are left alone. On a single cell nothing changes (Delete is not bound). `disableRangeClear` turns it off; `disableClipboardPaste` does not affect it.

package/docs/features/editing-reordering.md

@@ -115,6 +115,56 @@ const columns: GridColDef[] = [
 
 Enter and Escape keydowns that bubble out of a custom editor also commit and cancel. An error thrown by `renderEditCell` is contained to its cell (the cell shows `⚠`), like `renderCell`.
 
+### Building custom editors with `Input`
+The built-in text, number and date editors are the exported `Input` component with `variant="cell"` (since v3.3.1). Use it in `renderEditCell` and a custom editor looks like the built-in ones: it fills the cell, has no border, background or focus ring of its own (the editing cell's outline shows), and uses the cell's font.
+
+```tsx
+import { useEffect, useRef, useState } from 'react';
+import { Input } from '@opencorestack/opengridx';
+import type { GridColDef, GridRenderEditCellParams } from '@opencorestack/opengridx';
+
+const isAmount = (t: string) => t.trim() !== '' && Number(t) >= 0;
+
+function PriceEditor({ value, onValueChange, onCommit, onCancel }: GridRenderEditCellParams) {
+  const [text, setText] = useState(String(value ?? ''));
+  const ref = useRef<HTMLInputElement>(null);
+  useEffect(() => { ref.current?.focus(); ref.current?.select(); }, []);
+  const valid = isAmount(text);
+
+  return (
+    <Input
+      ref={ref}              // reaches the <input>, on React 18 and 19
+      variant="cell"
+      startAdornment="$"     // or endAdornment="kg"
+      error={!valid}         // red inner edge + aria-invalid
+      inputMode="decimal"
+      value={text}
+      onChange={e => {
+        setText(e.target.value);
+        if (isAmount(e.target.value)) onValueChange(Number(e.target.value));
+      }}
+      onKeyDown={e => {
+        if (e.key === 'Enter') { e.stopPropagation(); if (valid) onCommit(); }
+        if (e.key === 'Escape') { e.stopPropagation(); onCancel(); }
+      }}
+      onBlur={() => (valid ? onCommit() : onCancel())}
+    />
+  );
+}
+
+const columns: GridColDef[] = [
+  { field: 'price', type: 'number', editable: true, renderEditCell: params => <PriceEditor {...params} /> },
+];
+```
+
+- `ref` reaches the `<input>` (focus it and select its text when the editor opens, as the built-in editors do).
+- `inputClassName` adds classes to the `<input>`; `className` goes to the `.ogx-input-wrapper` div around it.
+- `error` adds `ogx-input-wrapper--error` (an inset `--ogx-color-error` edge in the cell variant, drawn over the cell outline) and `aria-invalid="true"`.
+- Stop propagation of the Enter / Escape you handle yourself, or the grid also commits / cancels when they bubble out.
+- The grid's boolean editor is the exported `Checkbox`; its `<input>` is visually hidden and `ref` / `inputClassName` reach it.
+
+Live example: the *Custom Cell Editors* demo page (`/custom-editors`).
+
 ### Computed columns (`valueGetter` + `valueSetter`)
 An editable column with a `valueGetter` edits the derived value. Give it a `valueSetter` so the commit can write the value back to the fields it comes from; otherwise the commit writes `row[field]`, which the `valueGetter` ignores, and a development warning is logged.
 

package/docs/features/keyboard-navigation.md

@@ -37,6 +37,17 @@ With [`cellSelection`](cell-selection.md) on (v3.3), on a data cell:
 | **Ctrl+Shift+Home** / **Ctrl+Shift+End** (Cmd on macOS) | Extend to the first / last cell of the page. |
 | **Shift+PageUp** / **Shift+PageDown** | Extend one page up / down. |
 | **Escape** | Collapse the range to the anchor (when not editing). |
+| **Ctrl+V** (Cmd+V) | Paste tab-separated text into the editable cells from the range's top-left cell (v3.4, see [Clipboard](clipboard.md#-paste-from-excel-and-google-sheets-v34)). Off with `disableClipboardPaste`. |
+| **Delete** / **Backspace** | On a range of more than one cell: empty its editable cells in one edit (v3.4). Off with `disableRangeClear`. |
+
+With `undoRedo` on (v3.4, see [Undo & Redo](undo-redo.md)), while focus is on a cell and no editor is open:
+
+| Key | Action |
+| :--- | :--- |
+| **Ctrl+Z** (Cmd+Z) | Undo the last edit, paste or range clear. |
+| **Ctrl+Shift+Z** (Cmd+Shift+Z) or **Ctrl+Y** | Redo. |
+
+Inside an open editor these keys belong to the input (its own paste and undo).
 
 A plain arrow key after a range collapses it to the newly focused cell. Shift+Space still selects the row.
 

package/docs/features/undo-redo.md

@@ -0,0 +1,79 @@
+# Undo & Redo
+
+`undoRedo` (v3.4) lets users undo and redo their cell edits, pastes and range clears. It is off by default: your app may already own Ctrl+Z, and undo writes data. Demo: **Undo & Redo** (`/undo-redo`).
+
+```tsx
+import { DataGrid, useGridApiRef, type GridHistoryChangeParams } from '@opencorestack/opengridx';
+
+function Budget({ rows, columns, saveRow }) {
+  const apiRef = useGridApiRef();
+  const [history, setHistory] = useState<GridHistoryChangeParams>({ canUndo: false, canRedo: false, size: 0 });
+
+  return (
+    <>
+      <button disabled={!history.canUndo} onClick={() => apiRef.current.undo()}>Undo</button>
+      <button disabled={!history.canRedo} onClick={() => apiRef.current.redo()}>Redo</button>
+      <DataGrid
+        rows={rows}
+        columns={columns}
+        apiRef={apiRef}
+        cellSelection               // for paste and range clear; undo works without it
+        undoRedo                    // or { limit: 50 }; default 100 actions
+        onHistoryChange={setHistory}
+        processRowUpdate={saveRow}  // undo and redo save through it too
+      />
+    </>
+  );
+}
+```
+
+## Keys
+
+| Key | Action |
+| :--- | :--- |
+| **Ctrl+Z** (Cmd+Z) | Undo |
+| **Ctrl+Shift+Z** (Cmd+Shift+Z) or **Ctrl+Y** | Redo |
+
+Only while focus is in the grid (a cell) and no editor is open. Inside an editor, a text field you render in a cell, or anywhere else on the page, the keys keep their native meaning (the input's own undo). After an undo or redo the affected cells become the selection (their bounding rectangle, with `cellSelection`; otherwise focus moves to the first one) and the first one is scrolled into view.
+
+## What is recorded
+
+Each committed action is a list of cell changes `{ id, field, before, after }`:
+
+| Action | Recorded |
+| :--- | :--- |
+| A single-cell edit | 1 change |
+| A paste or a range clear | Every cell that was written (skipped cells are not) |
+| Values `processRowUpdate` changed itself (a recomputed `total`) | Not recorded: only the fields the user changed. Your recomputation runs again on undo |
+
+An action is recorded **only after `processRowUpdate` succeeded**, with `after` read from the stored row through `valueGetter`. A row that `processRowUpdate` rejected is not recorded, so history never claims a change your app refused. A change whose stored value equals the old one (for example normalised back by `processRowUpdate`) is not recorded either.
+
+A new action after an undo clears the redo stack. Beyond `limit` actions the oldest is dropped.
+
+**Not undoable:** sorting, filtering, column changes, row reordering, row selection and cell selection. These are view state, not data.
+
+## How undo writes
+
+Undo writes the `before` values as a new batch edit, so `valueSetter` and `processRowUpdate` run as for any edit and your app persists the undo the way it persists edits. Redo writes the `after` values. One `processRowUpdate` call per row; rows run in parallel; a row that fails is reported to `onProcessRowUpdateError`, keeps its part of the action on the stack to try again, and does not stop the others.
+
+### Stale entries
+
+If a cell no longer holds its recorded `after` value (it was edited again, or the `rows` prop brought new data), undo **skips that cell** with reason `'changed'` and applies the rest. A row that no longer exists is skipped with reason `'missing'`. Values are compared, not row objects, so an app that re-fetches its rows after saving keeps a working history. Redo checks the same way against the value undo wrote.
+
+```ts
+const result = await apiRef.current.undo();
+// { updated: [3, 7], failed: [], skipped: [{ id: 5, field: 'price', reason: 'changed' }] }
+```
+
+## API
+
+| Member | Description |
+| :--- | :--- |
+| `undoRedo?: boolean \| { limit?: number }` | Turns history on. Default `false`; `limit` default 100. Turning it off clears the history. |
+| `onHistoryChange?({ canUndo, canRedo, size })` | Fired when what can be undone or redone changes. `size` is the number of actions that can be undone. |
+| `apiRef.current.undo()` | Undoes the last action. Resolves with a `GridBatchEditResult` once every row has settled. |
+| `apiRef.current.redo()` | Redoes the last undone action. |
+| `apiRef.current.canUndo()` / `canRedo()` | Whether there is something to undo / redo. |
+| `apiRef.current.clearHistory()` | Forgets every action. |
+
+Undo and redo calls run one after another, each on the rows the previous one stored.

package/docs/roadmap.md

@@ -83,7 +83,7 @@ This document tracks the current status of features in `OpenGridX` and outlines
 | Release | Target | Headline | Also in it |
 | :--- | :--- | :--- | :--- |
 | **3.3.0** ✅ | shipped 7 Oct | **Cell range selection** (opt-in `cellSelection` prop): mouse drag, Shift+click, Shift+arrows; Ctrl+C / Cmd+C copies the block as TSV | Selection status bar (count, sum, average of selected cells); wrapped header text; React Compiler compatibility check |
-| **3.4.0** | 20 Nov | **Paste from Excel / Google Sheets** into the selection, through `processRowUpdate` (values parsed per column type, non-editable cells skipped, `onClipboardPasteError`). **Undo / redo** for cell edits and pastes (Ctrl+Z, Ctrl+Shift+Z / Ctrl+Y, `apiRef.undo()` / `redo()`) | **AI toolkit, part 1** in a new `@opencorestack/opengridx/ai` entry point: `getGridAiSchema(columns)` (JSON Schema of the filter, sort, grouping, aggregation, pivot and visibility models the columns allow) and `validateGridAiState(json, columns)` (drops unknown fields and operators, coerces values, returns errors) |
+| **3.4.0** ✅ | shipped 8 Oct | **Paste from Excel / Google Sheets** into the selection, through `processRowUpdate` (values parsed per column type or `valueParser`, non-editable cells skipped, `onClipboardPaste` summary); **Delete clears a range**; built-in inputs and editors use the shared `Input` / `Checkbox` (`Input variant="cell"`). **Undo / redo** for cell edits and pastes (Ctrl+Z, Ctrl+Shift+Z / Ctrl+Y, `apiRef.undo()` / `redo()`) | **AI toolkit, part 1** in a new `@opencorestack/opengridx/ai` entry point: `getGridAiSchema(columns)` (JSON Schema of the filter, sort, grouping, aggregation, pivot and visibility models the columns allow) and `validateGridAiState(json, columns)` (drops unknown fields and operators, coerces values, returns errors) |
 | **3.5.0** | 15 Dec | **AI toolkit, part 2**: `aiAssistant={{ onPrompt }}` prompt panel that calls the app's own model, shows the proposed changes as removable chips and applies them with undo; `createGridAgentTools(apiRef)` (plain tool objects for CopilotKit, the Vercel AI SDK or WebMCP) | Header filter row; **fill handle** as a stretch goal (moves to Q1 2027 if 3.3–3.4 run late) |
 | Freeze | 19 Dec – 5 Jan | Bug fixes only | — |