Data grid v3

One write path

Every editor, paste, fill, cut and clear funnels through a single `applyEdits` call, so `rows` stays the only owner of the data and the edited-cell set can't drift from it. `onEdit` fires once per commit with the whole batch.

parse rejects, it doesn't blank

A column's `parse` returns the stored value — or `undefined` to reject the write. A paste of 40 cells over a read-only column and three bad numbers writes what it can and reports the rest as rejected, rather than clearing them.

The clipboard is real TSV

Copy emits CRLF rows and Excel-quoted fields, so a value carrying a tab, a newline or a quote survives a round trip through Sheets. Paste runs the inverse parser and lands the block with its top-left corner on the selection's, clipped to the grid.

Fill repeats the pattern

Dragging the corner square over a taller or wider region cycles the source rectangle through it, the way Sheets does. Filling across columns re-parses through the target column, so text survives a type change.

One render per resize

A column drag moves a single guideline element by transform and commits the width once, on drop. Writing state per frame would re-render every visible row and hitch the drag; a custom property on an ancestor would invalidate style for every cell in the table.

The selection outlives the page

Ranges are addressed by index into the full row list, not the visible page, so paging never renumbers a selection — and arrowing off the bottom edge turns the page instead of dead-ending.

Scroll fills the frame first

In scroll mode the first batch is `pageSize` rows, but a batch that does not overflow the scroller leaves nothing to scroll and no way to reach the rest. So the grid keeps appending batches until the scroller overflows, then waits for the reader to near the end. A search, a filter, a chip or a sort resets the count, since they change what the rows are; an edit does not, since it changes a cell and not the list.

A group reorders the rows, it doesn't just head them

Grouping sorts the filtered rows into group order and draws each group as its own card, so row 7 of the selection is the seventh row you can see, whatever group it sits in: the rectangle, the arrow keys, the clipboard and the fill handle all walk the table as drawn. Collapsing a group removes its rows from that list the way a filter does, so what you cannot see you cannot select or paste over. Export ignores the collapse: it is a way of reading the table, not a way of leaving rows out of it.

The header is only a renderer

Every control in the toolbar writes to state the caller can own: `search`, `filters`, `chip`, `sort`, `hiddenColumns` and `groupBy` all take a value and hand back a change. `onViewChange` hands out the other half — the visible rows, the counts, the chip options with their live counts, the filter vocabulary and the column lists — so an external header can render exactly what the built-in one does. `hideHeader` then drops the band entirely and the grid keeps every bit of its behaviour: nothing about searching, filtering or sorting lives in the toolbar, only its controls do.

The picker hides, it doesn't gate

Hiding a column is a reader's preference, so it lives in the grid and can be persisted through `onHiddenColumnsChange`. Whether a column exists for a viewer at all is the caller's decision, made by leaving it out of `columns`: a hidden column is still one click from visible, and its values are still in the rows.

Hover spells the cell out

A cell truncates to one line, so hovering a CLIPPED one shows its full value in a tooltip after the SDK's standard 1s delay — long enough that sweeping the pointer across a grid stays quiet. A cell showing all of its text has nothing to add and stays quiet. Skipped over the controls, where a tip would sit on top of the thing you are about to click, and over `actions` columns, whose buttons carry their own labels. It is ONE tooltip for the grid, moved over the hovered cell, not one mounted per cell.

Durations are minutes

A `type: "duration"` cell stores plain minutes and shows `1h 30m` / `45m` / `4h 00m` — minutes alone under an hour, and always two digits once there is an hour, so a column of them lines up. It reads back `1h 30m`, `1h`, `90m`, `1:30`, `1.5h` or a bare `90`, which is what makes a paste from a timesheet land.

Chips for object types

A `type: "chips"` cell holds an array of `options` values — deliverables, formats, ministries — rendered as badges with the rest collapsed into `+N` (`maxChips`). Clicking opens a checkable list of the vocabulary; the clipboard carries the labels comma-joined, and a pasted label the vocabulary doesn't know is dropped rather than stored.

Person cells are Avatar groups

A `type: "user"` cell hands the row's ids straight to `<Avatar people max={3} version="v2-initials" />` — the overlapping cluster, per-person tooltips and the `+N` overflow chip all come from the avatar primitive rather than being re-drawn here.

A clickable column is not a link

`onClick` on a column makes its cells clickable while they still read as data — no link colour, just a pointer cursor and an underline on hover. The click is claimed but the press is not, so the cell still selects and copies; inline editing is off for that column, since one click cannot both open an editor and go somewhere. Use `type: "link"` instead when the value IS a URL and you want it to look like one.

Columns with their own control

Status and person columns render a real select and a real picker. Enter on such a cell clicks that control rather than opening a textarea, so the keyboard and the mouse do the same thing.