@opencorestack/opengridx 3.2.2 → 3.4.0

package/lib/utils/parsing.ts

@@ -0,0 +1,252 @@
+import type { GridColDef, GridValidRowModel } from '../types';
+import { toDate } from './values';
+
+/**
+ * Text → typed values: the TSV reader clipboard paste uses, and the per-column-type parsers paste,
+ * `GridColDef.valueParser` defaults and the `/ai` validator share. Pure and React-free.
+ *
+ * Every pattern here is linear (CodeQL scans every push): no adjacent quantifiers that can match the
+ * same characters.
+ */
+
+/** A parsed value, or `{ ok: false }` when the text does not fit the column type. */
+export type GridParsedValue = { ok: true; value: unknown } | { ok: false };
+
+const INVALID: GridParsedValue = { ok: false };
+const valid = (value: unknown): GridParsedValue => ({ ok: true, value });
+
+/**
+ * Splits tab-separated text the way Excel, Google Sheets and LibreOffice write it: tabs between
+ * columns, `\r\n`, `\n` or `\r` between rows. A field that starts with a double quote is quoted: it
+ * may hold tabs, line breaks and doubled quotes (`""` → `"`), the reverse of `escapeTsvField`. A
+ * quote inside an unquoted field is kept as is. A trailing empty line is ignored, so `"a\tb\n"` is one
+ * row. Empty text gives no rows.
+ */
+export function parseTsv(text: string): string[][] {
+    const rows: string[][] = [];
+    if (text === '') return rows;
+    let row: string[] = [];
+    let field = '';
+    let i = 0;
+    const n = text.length;
+    let fieldStart = true;
+    while (i < n) {
+        const ch = text[i];
+        if (fieldStart && ch === '"') {
+            // A quoted field: read to the closing quote, `""` being one quote.
+            let j = i + 1;
+            let value = '';
+            let closed = false;
+            while (j < n) {
+                const q = text[j];
+                if (q === '"') {
+                    if (text[j + 1] === '"') {
+                        value += '"';
+                        j += 2;
+                        continue;
+                    }
+                    closed = true;
+                    j += 1;
+                    break;
+                }
+                value += q;
+                j += 1;
+            }
+            if (!closed) {
+                // No closing quote: not a quoted field after all, read the quote as text.
+                field += ch;
+                i += 1;
+                fieldStart = false;
+                continue;
+            }
+            field += value;
+            i = j;
+            fieldStart = false;
+            continue;
+        }
+        fieldStart = false;
+        if (ch === '\t') {
+            row.push(field);
+            field = '';
+            fieldStart = true;
+            i += 1;
+        } else if (ch === '\n' || ch === '\r') {
+            row.push(field);
+            rows.push(row);
+            row = [];
+            field = '';
+            fieldStart = true;
+            i += ch === '\r' && text[i + 1] === '\n' ? 2 : 1;
+        } else {
+            field += ch;
+            i += 1;
+        }
+    }
+    // The last line, unless the text ended with a line break (Excel always adds one).
+    if (!fieldStart || row.length > 0 || field !== '') {
+        row.push(field);
+        rows.push(row);
+    }
+    return rows;
+}
+
+const PLAIN_NUMBER = /^\d+(?:\.\d*)?(?:e[+-]?\d+)?$/i;
+const LEADING_DOT_NUMBER = /^\.\d+(?:e[+-]?\d+)?$/i;
+const GROUPED_NUMBER = /^\d{1,3}(?:,\d{3})+(?:\.\d*)?$/;
+// Currency symbols (Unicode Sc) and every kind of space, including the no-break spaces Excel uses
+// as a thousands separator.
+const STRIPPED_CHARS = /[\p{Sc}\s]/gu;
+
+/**
+ * A number as spreadsheets copy it: `1234.5`, `1,234.5` (comma thousands groups only), `-12`,
+ * `(12)` (accounting negative), `12%` (→ 0.12), `1e3`, with currency symbols and spaces stripped.
+ * Empty text is `null`. `1,5` is not accepted (it is ambiguous): use a `valueParser` for
+ * decimal-comma locales.
+ */
+export function parseNumberText(text: string): GridParsedValue {
+    let s = text.replace(STRIPPED_CHARS, '');
+    if (s === '') return text.trim() === '' ? valid(null) : INVALID;
+    let negative = false;
+    if (s.startsWith('(') && s.endsWith(')')) {
+        negative = true;
+        s = s.slice(1, -1);
+    }
+    if (s.startsWith('-') || s.startsWith('+') || s.startsWith('−')) {
+        if (s[0] !== '+') negative = !negative;
+        s = s.slice(1);
+    }
+    let percent = false;
+    if (s.endsWith('%')) {
+        percent = true;
+        s = s.slice(0, -1);
+    }
+    if (GROUPED_NUMBER.test(s)) s = s.split(',').join('');
+    else if (!PLAIN_NUMBER.test(s) && !LEADING_DOT_NUMBER.test(s)) return INVALID;
+    let value = Number(s);
+    if (!Number.isFinite(value)) return INVALID;
+    if (percent) value /= 100;
+    if (negative) value = -value;
+    return valid(value);
+}
+
+const ISO_DATE_PREFIX = /^(\d{4}-\d{2}-\d{2})/;
+const pad2 = (n: number) => String(n).padStart(2, '0');
+const localDay = (date: Date) => `${date.getFullYear()}-${pad2(date.getMonth() + 1)}-${pad2(date.getDate())}`;
+
+/**
+ * A date: ISO `2026-10-07` (read as that local calendar day) or anything `Date.parse` accepts. Empty
+ * text is `null`. The result takes the kind of `current` (the value the cell holds now), as the date
+ * editor does: a timestamp stays a timestamp, a date string stays a `YYYY-MM-DD` string (an ISO
+ * date-time string keeps its time part); otherwise it is a `Date`.
+ */
+export function parseDateText(text: string, current?: unknown): GridParsedValue {
+    const trimmed = text.trim();
+    if (trimmed === '') return valid(null);
+    const date = toDate(trimmed);
+    if (!date) return INVALID;
+    if (typeof current === 'number') return valid(date.getTime());
+    if (typeof current === 'string') {
+        const day = localDay(date);
+        return valid(ISO_DATE_PREFIX.test(current) && current.length > 10 ? day + current.slice(10) : day);
+    }
+    return valid(date);
+}
+
+/** Text read as `true` / `false`, besides the grid's own `Yes` / `No` cell labels. Lower case. */
+const TRUE_WORDS = new Set(['true', 'yes', '1']);
+const FALSE_WORDS = new Set(['false', 'no', '0']);
+
+export interface GridBooleanLabels {
+    /** Text shown for `true` (the grid shows `Yes`). */
+    trueLabel?: string;
+    /** Text shown for `false` (the grid shows `No`). */
+    falseLabel?: string;
+}
+
+/**
+ * A boolean: `true`/`false`, `yes`/`no` (the grid's own `Yes` / `No` cell labels), `1`/`0` and any
+ * `labels` given, case-insensitive. Empty text is `null`.
+ */
+export function parseBooleanText(text: string, labels?: GridBooleanLabels): GridParsedValue {
+    const s = text.trim().toLowerCase();
+    if (s === '') return valid(null);
+    if (labels?.trueLabel !== undefined && s === labels.trueLabel.trim().toLowerCase()) return valid(true);
+    if (labels?.falseLabel !== undefined && s === labels.falseLabel.trim().toLowerCase()) return valid(false);
+    if (TRUE_WORDS.has(s)) return valid(true);
+    if (FALSE_WORDS.has(s)) return valid(false);
+    return INVALID;
+}
+
+type ValueOption = NonNullable<GridColDef['valueOptions']>[number];
+
+/**
+ * A `singleSelect` value: the option whose value or label matches the text, case-insensitive (values
+ * first). Returns the option's own value, so a numeric option stays a number. Empty text is `null`.
+ */
+export function parseSingleSelectText(text: string, options: readonly ValueOption[] | undefined): GridParsedValue {
+    const s = text.trim();
+    if (s === '') return valid(null);
+    if (!options || options.length === 0) return INVALID;
+    const lower = s.toLowerCase();
+    for (const option of options) {
+        const value = typeof option === 'object' ? option.value : option;
+        if (String(value).toLowerCase() === lower) return valid(value);
+    }
+    for (const option of options) {
+        if (typeof option === 'object' && option.label.toLowerCase() === lower) return valid(option.value);
+    }
+    return INVALID;
+}
+
+type ParserColumn = Pick<GridColDef, 'type' | 'valueOptions'>;
+
+export interface GridParseTextOptions {
+    /** The value the cell holds now: a parsed date takes its kind (see `parseDateText`). */
+    current?: unknown;
+    /** Extra boolean labels, besides `Yes` / `No`. */
+    booleanLabels?: GridBooleanLabels;
+}
+
+/**
+ * Parses cell text by the column `type`, without `valueParser`:
+ *
+ * | type | accepted |
+ * | :--- | :--- |
+ * | `string` (default), `image` | the text as is (an empty cell is `''`) |
+ * | `number` | `parseNumberText` |
+ * | `date` | `parseDateText` |
+ * | `boolean` | `parseBooleanText` |
+ * | `singleSelect` | `parseSingleSelectText` |
+ *
+ * An empty cell is `null` for every type but `string` / `image`.
+ */
+export function parseValueByType(text: string, colDef: ParserColumn | undefined, options?: GridParseTextOptions): GridParsedValue {
+    switch (colDef?.type) {
+        case 'number': return parseNumberText(text);
+        case 'date': return parseDateText(text, options?.current);
+        case 'boolean': return parseBooleanText(text, options?.booleanLabels);
+        case 'singleSelect': return parseSingleSelectText(text, colDef.valueOptions);
+        default: return valid(text);
+    }
+}
+
+/**
+ * Parses the text pasted into one cell: the column's `valueParser` when it has one (a throw, or a
+ * returned `undefined`, rejects the text), otherwise `parseValueByType`.
+ */
+export function parseCellText<R extends GridValidRowModel>(
+    text: string,
+    colDef: GridColDef<R>,
+    row: R,
+    options?: GridParseTextOptions,
+): GridParsedValue {
+    const { valueParser } = colDef;
+    if (!valueParser) return parseValueByType(text, colDef as unknown as ParserColumn, options);
+    let value: unknown;
+    try {
+        value = valueParser(text, { row, field: colDef.field, colDef });
+    } catch {
+        return INVALID;
+    }
+    return value === undefined ? INVALID : valid(value);
+}

package/llms.txt

@@ -1,6 +1,6 @@
 # OpenGridX — AI Agent Context
 # Package: @opencorestack/opengridx
-# Version: 3.2.2
+# Version: 3.4.0
 # Docs: https://opencorestack.github.io/OpenGridX/
 # This file is machine-readable. AI developers: start here.
 
@@ -78,6 +78,7 @@ export default function App() {
 | localeText        | GridLocaleText | —  | Override pager / no-rows strings: paginationRowsPerPage, paginationOf(from,to,count), paginationPage(page,count), noRowsLabel |
 | rowHeight         | number    | 52      | Row height in pixels                   |
 | headerHeight      | number    | 56      | Header height in pixels                |
+| wrapHeaderText    | boolean   | false   | Wrap header titles within headerHeight (2 lines at 56px, 3 at 72, 4 at 88; ellipsis on the last line). Header never grows: raise headerHeight for more lines. Class ogx__header-cell--wrap. Per column: GridColDef.wrapHeaderText (3.3.0+) |
 | loading           | boolean   | false   | No rows: skeleton rows (or slots.loadingOverlay). Rows shown: they stay, a progress bar (.ogx__loading-bar) runs along the top, or slots.loadingOverlay is shown over them |
 | noRowsLabel       | string    | 'No Data' | Empty state message                  |
 | density           | 'compact'/'standard'/'comfortable' | 'standard' | 32px / rowHeight / 72px rows |
@@ -92,6 +93,16 @@ export default function App() {
 | onRowSelectionModelChange  | (model: GridRowId[]) => void  | Selection change callback. Also fires once with ids of removed rows pruned (client-owned rows) |
 | disableRowSelectionOnClick | boolean                       | Prevent click toggling selection    |
 | disableClipboardCopy       | boolean                       | Turn off the grid's Ctrl/Cmd+C copy (copySelectedRows still works) |
+| cellSelection              | boolean (3.3.0+)              | Spreadsheet-style cell ranges: drag (auto-scrolls), Shift+click, Shift+arrows/Home/End/PageUp/PageDown, Ctrl/Cmd+A = every data cell of the page, Escape collapses. Ctrl/Cmd+C then copies the range as TSV (no header line) instead of the selected rows. Ranges never change the row selection |
+| cellSelectionModel         | GridCellSelectionModel        | Controlled range: readonly { anchor: { id, field }, head: { id, field } }[] (0 or 1 range). Corners are ids/fields: the range follows sorting; cleared ('dataChange') when a corner is no longer displayed |
+| onCellSelectionModelChange | (model, { reason }) => void   | reason: 'pointer' | 'keyboard' | 'selectAll' | 'api' | 'clear' | 'dataChange' |
+| showCellSelectionStats     | boolean                       | Status bar: Count (non-empty), Sum and Average (numeric) of the range; slots.cellSelectionStats replaces it |
+| disableClipboardPaste      | boolean (3.4.0+)              | With cellSelection, Ctrl/Cmd+V pastes TSV (Excel/Sheets) into editable cells: one value fills a range; a block goes from the range's top-left (or focused) cell, cut to the range and grid edges; no rows created. Parsed per column type, then valueSetter + processRowUpdate once per row. true = shortcut off (apiRef.pasteText still works) |
+| onClipboardPaste           | (result) => void (3.4.0+)     | After every paste: { updated: id[], failed: {id, error}[], skipped: {id, field, reason: 'notEditable'/'invalidValue'}[], text } |
+| onBeforeClipboardPaste     | ({ text, anchor }) => boolean / string | Return false to cancel, a string to paste instead; a throw cancels |
+| disableRangeClear          | boolean (3.4.0+)              | With cellSelection, Delete/Backspace on a multi-cell range empties editable cells ('' strings, null otherwise) as one edit; true = off |
+| undoRedo                   | boolean / { limit } (3.4.0+)  | Undo/redo of edits, pastes, range clears (default off, 100 actions). Ctrl/Cmd+Z, Ctrl/Cmd+Shift+Z, Ctrl+Y on a cell with no editor open. Recorded only after processRowUpdate succeeds; replayed through valueSetter + processRowUpdate; cells changed since are skipped ('changed', compared by value), removed rows ('missing') |
+| onHistoryChange            | ({ canUndo, canRedo, size }) => void | History change (size = undoable actions) |
 
 ### Sorting
 | Prop              | Type                        | Description                     |
@@ -240,6 +251,7 @@ There are no getRowClassName / getCellClassName / theme props: use GridColDef.ce
 | renderEditCell    | (params: GridRenderEditCellParams<R>) => ReactNode     | Custom editor: call params.onValueChange(v), params.onCommit(), params.onCancel() |
 | valueGetter       | ({row, field, value}) => unknown                       | Computed value; used by sort, filter, quick search, aggregation, copy, export. Must be pure (quick filter caches per row object); a throw reads as undefined + dev warning |
 | valueSetter       | ({value, row, field}) => R                             | Write an edited value back onto the row (editable valueGetter columns) |
+| valueParser       | (text, { row, field, colDef }) => unknown              | Paste parser for this column (3.4.0+), e.g. "1.234,5" → 1234.5. Throw/undefined skips the cell ('invalidValue'). Default by type: number "1,234.5"/"12%"/"$5"; date ISO or Date.parse (keeps the cell's kind); boolean true/false/yes/no/1/0; singleSelect value or label; empty → null ('' for strings) |
 | valueFormatter    | ({value, row, field}) => string                        | Format display value (value is `unknown`: cast before calling methods) |
 | cellClassName     | string / (params) => string                            | CSS class on cells                         |
 | headerClassName   | string                                                 | CSS class on header cell                   |
@@ -247,6 +259,7 @@ There are no getRowClassName / getCellClassName / theme props: use GridColDef.ce
 | rowSpan           | number / (params) => number                            | Cell row span (clamped to the row section) |
 | align             | 'left'/'center'/'right'                                | Cell content alignment                     |
 | headerAlign       | 'left'/'center'/'right'                                | Header content alignment                   |
+| wrapHeaderText    | boolean                                                | Wrap this header title; overrides the grid prop (3.3.0+) |
 | sortable          | boolean (default true)                                 | Enable sorting                             |
 | sortComparator    | (v1, v2, params1, params2) => number                   | Custom ascending comparator (3.1.0+). v1/v2 are valueGetter values incl. null/undefined; params { id, field, row, value }. Negated for desc; multi-sort tie-break chain; groups by grouping value; tree siblings; pivot row labels. Throw/NaN = 0. Ignored in server sortingMode |
 | filterable        | boolean (default true)                                 | Enable filtering and quick search          |
@@ -259,6 +272,7 @@ There are no getRowClassName / getCellClassName / theme props: use GridColDef.ce
 | groupingValueFormatter | ({field, value}) => string                        | Group row label (default "field: value")   |
 | aggregable        | boolean                                                | false = no aggregation. Summaries panel offers number columns + aggregable: true |
 | availableAggregationFunctions | string[]                                   | Restrict aggregation functions for this column |
+| aiExamples        | unknown[]                                              | Example values put into getGridAiSchema's schema (3.4.0+). SENT TO THE MODEL: real data, opt-in. Primitives only, max 10. Unused by the grid |
 
 ---
 
@@ -307,6 +321,22 @@ apiRef.current.autosizeColumns(fields?)
 apiRef.current.copySelectedRows()      // → Promise<void>; rejects if the write fails. Copies every selected row that passes
                                        //   the filter (all pages, collapsed groups, pinned rows), visible columns in screen order
 
+// Cell range selection (cellSelection, 3.3.0+); inert while cellSelection is off
+apiRef.current.selectCellRange({ id: 1, field: 'a' }, { id: 5, field: 'c' }) // anchor = active cell
+apiRef.current.setCellSelectionModel(model)
+apiRef.current.getCellSelectionModel()  // → GridCellSelectionModel
+apiRef.current.getSelectedCells()      // → { id, field, value }[]; synthetic rows and span-covered cells left out
+apiRef.current.copySelectedCells()     // → Promise<void>; TSV, no header line
+apiRef.current.clearCellSelection()
+
+// Paste and undo/redo (3.4.0+)
+apiRef.current.pasteText(text, anchor?) // → Promise<GridBatchEditResult>; anchor default: range top-left, else focused cell
+apiRef.current.undo()                   // → Promise<GridBatchEditResult> (undoRedo)
+apiRef.current.redo()
+apiRef.current.canUndo()                // → boolean
+apiRef.current.canRedo()
+apiRef.current.clearHistory()
+
 // Aggregation
 apiRef.current.getAggregationResult()  // → Record<string, unknown> | null (null in pivot mode)
 apiRef.current.getAggregationModel()   // → GridAggregationModel | null
@@ -342,6 +372,22 @@ const processRowUpdate = (newRow: Person) => {
 
 Double-click or Enter opens the editor; Enter / Tab / blur commits; Escape cancels. An edit whose row scrolls, pages or filters away is committed, not dropped.
 
+Custom editors (3.3.1+): build them on the exported `Input` with `variant="cell"` — it fills the cell with no border/background/focus ring, like the built-in editors. `ref` reaches the `<input>` (forwardRef, React 18 + 19), `inputClassName` styles the `<input>` (`className` the wrapper), `startAdornment` / `endAdornment` add a unit, `error` adds an inset error edge and `aria-invalid`. Stop propagation of the Enter/Escape you handle.
+
+```tsx
+import { Input } from '@opencorestack/opengridx';
+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 = text.trim() !== '' && Number(text) >= 0;
+  return <Input ref={ref} variant="cell" startAdornment="$" error={!valid} value={text}
+    onChange={e => { setText(e.target.value); const n = Number(e.target.value); if (e.target.value.trim() !== '' && n >= 0) onValueChange(n); }}
+    onKeyDown={e => { if (e.key === 'Enter') { e.stopPropagation(); if (valid) onCommit(); } if (e.key === 'Escape') { e.stopPropagation(); onCancel(); } }}
+    onBlur={() => (valid ? onCommit() : onCancel())} />;
+}
+```
+
 ---
 
 ## SERVER-SIDE DATA SOURCE
@@ -510,6 +556,27 @@ await printGrid(rows, columns, 'My Report Title');
 
 ---
 
+## AI TOOLKIT (@opencorestack/opengridx/ai, 3.4.0+)
+
+Separate entry point: no React, no dependencies, ~4.5 kB gzip; never loaded by the core import. OpenGridX calls no AI service: the app sends { prompt, schema, currentState } to its own model (structured output) and validates the reply.
+
+```ts
+import { getGridAiSchema, validateGridAiState } from '@opencorestack/opengridx/ai';
+
+const schema = getGridAiSchema(columns, { include: ['filter', 'sort', 'grouping', 'aggregation'] });
+const reply = await fetch('/api/grid-assistant', { method: 'POST', body: JSON.stringify({ prompt, schema, currentState }) });
+const { state, errors } = validateGridAiState(await reply.text(), columns);
+if (state.filterModel) setFilterModel(state.filterModel);   // apply only the parts present
+if (state.sortModel) setSortModel(state.sortModel);
+```
+
+- getGridAiSchema(columns, { include?, exclude?, descriptions = true, examples = true }) → JSON Schema draft 2020-12 with `schemaVersion: 1`. Parts (option name → key): filter → filterModel (items as oneOf per field, AND/OR groups ≤ 3 levels, quickFilterValues), sort → sortModel, grouping → rowGroupingModel, aggregation → aggregationModel, pivot → pivotModel, columnVisibility → columnVisibilityModel. Fields from filterable / sortable / groupable / hideable / aggregable !== false; operators = the column type's filter operators; aggregation: number (or aggregable: true) columns get sum/avg/count/min/max/unique, others count, limited by availableAggregationFunctions; singleSelect valueOptions become enums. Fields starting with `__` are skipped. Deterministic; reads no rows.
+- validateGridAiState(json | jsonString, columns, { include?, exclude? }) → { state: GridAiState, errors: { path, message }[] }. Drops unknown parts, fields, disallowed fields, wrong operators, enum values outside the list; coerces values like clipboard paste ("1,200"/"$1,200" → 1200, "12%" → 0.12, yes/no/1/0 → boolean, dates → "YYYY-MM-DD", singleSelect by value or label, case-insensitive); removes empty groups; lists capped at 200 entries, errors at 100. Never throws; never reads `__proto__`.
+- Privacy: no row data by default; `aiExamples` and `valueOptions` ARE sent; always apply `state`, never the raw reply.
+- Types (from /ai): GridAiColumn, GridAiPart, GridAiSchema, GridAiSchemaOptions, GridAiState, GridAiValidateOptions, GridAiValidationError, GridAiValidationResult.
+
+---
+
 ## CSS CUSTOMIZATION
 
 All CSS variables use the `--ogx-` prefix and are declared on `:root` by the stylesheet. Override them on a wrapper (or use DataGridThemeProvider, which sets the same variables):
@@ -530,8 +597,10 @@ Derived tokens (e.g. `--ogx-grid-cell-focus-border`, which defaults to the prima
 Class names use the `ogx__` BEM prefix, e.g.:
 - `ogx__row`, `ogx__row--selected`, `ogx__row--even`, `ogx__row--odd`
 - `ogx__cell`, `ogx__cell--focused`, `ogx__cell--editing`
-- `ogx__header-cell`, `ogx__header-cell--sorted`
+- Cell ranges (3.3.0+): `ogx__cell--range`, `ogx__cell--range-top|bottom|left|right` (inset box-shadow outline), `ogx--range-dragging` on the root during a drag; variables `--ogx-range-background`, `--ogx-range-border` (theme keys `grid.rangeBackground`, `grid.rangeBorder`)
+- `ogx__header-cell`, `ogx__header-cell--sorted`, `ogx__header-cell--wrap` (wrapHeaderText, 3.3.0+)
 - Sticky wrappers: `ogx__sticky-top` (header + top-pinned rows), `ogx__sticky-bottom` (bottom-pinned rows + aggregation footer)
+- Form controls (3.3.1+): the toolbar search, column-panel search, filter value box and text/number/date editors render through `Input`: the `<input>` keeps its class (`ogx-global-search__input`, `ogx-column-visibility-panel__search-input`, `ogx-filter__value-input`, `ogx__edit-input`) inside a `div.ogx-input-wrapper` (`ogx-input-wrapper--cell` for editors) — use descendant selectors (`.ogx-global-search input`), not `> input`. The boolean editor and list-view row checkbox are the shared `Checkbox` (`.ogx-checkbox__box`; hidden `<input>`)
 
 ---
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@opencorestack/opengridx",
-  "version": "3.2.2",
+  "version": "3.4.0",
   "description": "OpenGridX: High-performance React data infrastructure. Unlock advanced Row Grouping, Excel Export, and Column Pinning without the usual \"Pro\" gatekeeping. Built for speed, scale, and complete architectural freedom. Fully open, virtualization-ready, and feature-complete.",
   "type": "module",
   "main": "./dist/opengridx.umd.js",
@@ -12,6 +12,11 @@
       "import": "./dist/opengridx.es.js",
       "require": "./dist/opengridx.umd.js"
     },
+    "./ai": {
+      "types": "./dist/ai.d.ts",
+      "import": "./dist/ai.es.js",
+      "require": "./dist/ai.cjs"
+    },
     "./styles": {
       "types": "./dist/opengridx.css.d.ts",
       "default": "./dist/opengridx.css"
@@ -23,6 +28,7 @@
     "!lib/**/*.test.ts",
     "!lib/**/*.test.tsx",
     "!lib/**/__screenshots__",
+    "!lib/**/__snapshots__",
     "docs/architecture",
     "docs/assets",
     "docs/components",
@@ -45,7 +51,7 @@
   "scripts": {
     "dev": "vite",
     "build": "tsc --project tsconfig.build.json && vite build",
-    "build:lib": "tsc --project tsconfig.build.json && vite build --config vite.config.lib.js && cp lib/styles/opengridx.css.d.ts dist/opengridx.css.d.ts && node scripts/check-bundle.mjs",
+    "build:lib": "tsc --project tsconfig.build.json && vite build --config vite.config.lib.js && vite build --config vite.config.lib.js --mode ai && cp lib/styles/opengridx.css.d.ts dist/opengridx.css.d.ts && node scripts/check-bundle.mjs",
     "lint": "eslint .",
     "typecheck": "tsc -p tsconfig.json --noEmit && tsc -p tsconfig.test.json --noEmit && tsc -p e2e/tsconfig.json",
     "preview": "vite preview",
@@ -55,7 +61,9 @@
     "test:smoke": "node scripts/smoke.mjs",
     "test:watch": "vitest --project unit",
     "coverage": "vitest run --coverage",
-    "prepublishOnly": "npm run build:lib"
+    "prepublishOnly": "npm run build:lib",
+    "wiki:build": "node scripts/build-wiki.mjs",
+    "check:compiler": "node scripts/check-react-compiler.mjs"
   },
   "keywords": [
     "react",
@@ -106,6 +114,7 @@
     }
   },
   "devDependencies": {
+    "@babel/core": "^7.29.7",
     "@eslint/js": "^9.39.1",
     "@playwright/test": "^1.58.2",
     "@testing-library/jest-dom": "^7.0.0",
@@ -117,8 +126,9 @@
     "@vitejs/plugin-react": "^5.1.1",
     "@vitest/browser-playwright": "^4.1.11",
     "@vitest/coverage-v8": "^4.1.11",
+    "babel-plugin-react-compiler": "^1.0.0",
     "eslint": "^9.39.1",
-    "eslint-plugin-react-hooks": "^7.0.1",
+    "eslint-plugin-react-hooks": "^7.1.1",
     "eslint-plugin-react-refresh": "^0.4.24",
     "exceljs": "^4.4.0",
     "globals": "^16.5.0",