@updog/data-editor 0.1.10 → 0.1.11

package/index.d.ts

@@ -372,37 +372,63 @@ declare var export_default = {
       redo: "Redo",
     },
     validation: {
-      required: "This field is required",
-      invalidNumber: "Invalid number",
-      invalidEmail: "Invalid email address",
-      invalidDate: "Invalid date",
       endDateBeforeStart: "End date must be after start date",
+      invalidDate: "Invalid date",
+      invalidEmail: "Invalid email address",
+      invalidFormat: "Invalid format",
+      invalidNumber: "Invalid number",
+      invalidOption: "Invalid option",
+      outOfRange: "Out of range",
+      required: "This field is required",
       valueMustBeUnique: "Value must be unique",
     },
     license: {
       loading: "Loading data editor",
-      errors: {
-        LICENSE_INVALID: {
+    },
+    connecting: {
+      label: "Connecting to server…",
+    },
+    errors: {
+      RENDER_ERROR: {
+        title: "Something went wrong",
+        text: "Please close this window and try again",
+      },
+      license: {
+        invalid: {
           title: "Invalid license",
           text: "Please contact support for assistance.",
         },
-        MISSING_API_KEY: {
+        missing: {
           title: "Missing API key",
           text: "No API key was provided. Please configure a valid API key.",
         },
-        DOMAIN_NOT_ALLOWED: {
+        domain_not_allowed: {
           title: "Domain not allowed",
           text: "This domain is not authorized for this license. Please check your domain settings.",
         },
-        SUBSCRIPTION_INACTIVE: {
+        subscription_inactive: {
           title: "Subscription inactive",
           text: "Your subscription is no longer active. Please renew to continue.",
         },
       },
-    },
-    errorState: {
-      title: "Something went wrong",
-      text: "Please close this window and try again",
+      scale: {
+        bootstrap_failed: {
+          title: "Couldn't connect to the server",
+          text: "The server returned an error. Please refresh the page or contact support.",
+        },
+        workspace_lost: {
+          title: "Connection lost",
+          text: "The session ended unexpectedly. Refresh the page to reconnect.",
+        },
+        unreachable: {
+          title: "Server unreachable",
+          text: "Check your connection and refresh the page.",
+        },
+        server_error: {
+          title: "Server error",
+          text: "The server returned an error. Please refresh the page or contact support.",
+        },
+      },
     },
     uploader: {
       steps: {
@@ -519,1100 +545,1702 @@ type ExpandPluralKeys<T> = T extends Record<string, unknown>
 type DataEditorTranslations = DeepPartial<ExpandPluralKeys<typeof export_default>>;
 
 /**
- * ChunkedProcessor — Generic utility for processing items in prioritized chunks
- * with cancellation support via generation counter.
+ * Base row shape. Each key is a column ID, each value is the cell data.
+ * Extend this with your own type via the `<DataEditor<TRow>>` generic for
+ * type-safe column access. When the generic is omitted, rows are typed as
+ * `Record<string, unknown>`.
  *
- * Used to break O(N) synchronous operations into non-blocking background work:
- *   1. Priority items are processed synchronously first (e.g. viewport rows)
- *   2. Remaining items are processed in chunks via MessageChannel
- *   3. Between chunks the browser can paint frames and handle events
+ * @example
+ * ```ts
+ * type Employee = { id: string; name: string; email: string };
+ * <DataEditor<Employee> columns={...} primaryKey="id" />
+ * ```
+ */
+type DataEditorRow = Record<string, unknown>;
+/** Sort direction. */
+type SortDirection = "asc" | "desc";
+/** Current sort state. `null` means no active sort. */
+type SortState = {
+    columnId: string;
+    direction: SortDirection;
+} | null;
+type Filters = {
+    search: string;
+    matchCase: boolean;
+    matchEntireCell: boolean;
+    errorMessageFilters: string[];
+    showOnlyNewRows: boolean;
+    showOnlyEditedRows: boolean;
+    showOnlyEmptyCells: boolean;
+    /** When true, show only rows flagged for deletion (bin mode). All other filters are bypassed. */
+    showOnlyDeletedRows: boolean;
+    filterColumns: string[] | null;
+    /** Per-column value filters. Key = column ID, value = allowed display-formatted strings. */
+    columnValueFilters: Record<string, string[]>;
+    /** Per-column numeric range filters. Key = column ID. */
+    columnRangeFilters: Record<string, {
+        min?: number;
+        max?: number;
+    }>;
+    /** Per-column date range filters. Key = column ID, values are ISO date strings (YYYY-MM-DD). */
+    columnDateRangeFilters: Record<string, {
+        min?: string;
+        max?: string;
+    }>;
+};
+
+/**
+ * A built-in declarative validator. Mode-symmetric: the SDK ships a TS
+ * interpreter, the Updog Scale Go binary ships a Go interpreter, and both
+ * agree on pass/fail outcomes per `api/validators.json`.
+ */
+type BuiltInValidator = {
+    type: "required";
+    message?: string;
+} | {
+    type: "regex";
+    pattern: string;
+    flags?: string;
+    message?: string;
+} | {
+    type: "oneOf";
+    values: string[];
+    message?: string;
+} | {
+    type: "range";
+    min?: number;
+    max?: number;
+    message?: string;
+} | {
+    type: "email";
+    message?: string;
+} | {
+    type: "date";
+    format?: "YYYY-MM-DD" | "DD/MM/YYYY";
+    message?: string;
+} | {
+    type: "numeric";
+    message?: string;
+};
+/**
+ * Server-mode-only escape hatch: an expression evaluated by the Go binary
+ * via expr-lang. Skipped at runtime in client mode (warned at mount).
+ */
+type ExpressionValidator = {
+    type: "expression";
+    expr: string;
+    message?: string;
+};
+/**
+ * Client-mode-only escape hatch: a JS predicate run inline. Dropped (with
+ * one warn per column) when the SDK serializes the schema for server mode.
+ */
+type FunctionValidator = {
+    type: "function";
+    fn: CellValidator;
+};
+/**
+ * The validator-rule union accepted by `DataEditorColumn.validators`.
+ * - Built-ins and `expression` are declarative objects (cross the wire).
+ * - `function` wraps a `CellValidator`; client-mode-only, dropped+warned in server mode.
  *
- * Uses MessageChannel instead of setTimeout(0) to avoid the browser's ~4ms
- * minimum delay imposed on nested setTimeouts, reducing scheduling overhead
- * from ~6ms/chunk to ~1ms/chunk.
+ * Named `ValidatorRule` (not `Validator`) so it doesn't clash with the
+ * runtime `Validator` class in `core/Validator.ts`.
+ */
+type ValidatorRule = BuiltInValidator | ExpressionValidator | FunctionValidator;
+
+/** Severity level for a validation message. */
+type ValidationLevel = "error";
+/**
+ * A single validation message attached to a cell.
+ * Return this from a `CellValidator` to flag a problem.
+ */
+type ValidationError = {
+    level: ValidationLevel;
+    /** Human-readable message shown in the cell tooltip. */
+    message: string;
+};
+type ValidationResult = ValidationError[] | null;
+/**
+ * A function that validates a single cell value.
+ * Return a `ValidationError` to flag a problem, or `null` if the value is valid.
  *
- * Cancellation uses the same generation counter pattern as FilterEngine:
- * calling cancel() or run() again increments the generation, and any
- * in-flight MessageChannel callbacks silently exit when they detect
- * their generation is stale.
+ * A `ValidationError` with `level: "error"` flags the cell in the grid but
+ * does not block submission — invalid rows are delivered to `onComplete`
+ * alongside valid ones, tagged via the `isValid` flag.
  *
- * This class has zero domain knowledge — it works with any item type.
+ * To use a `CellValidator` in the `validators` array, wrap it as
+ * `{ type: "function", fn: (value, row) => ... }`. For declarative rules,
+ * pass a built-in object literal — e.g. `{ type: "required" }`,
+ * `{ type: "email" }`. See `ValidatorRule` for the full union.
+ *
+ * @param value - The current cell value.
+ * @param row - The full row, useful for cross-field checks.
  */
-type ChunkedProcessorCallbacks<T> = {
-    /** All items to process (excluding priority items). */
-    all: T[];
-    /** Items processed synchronously before any chunking begins. */
-    priority: T[];
-    /** Called for each batch of items (priority batch first, then chunks). */
-    onChunk: (items: T[]) => void;
-    /** Called after each chunk with (processed so far, total). */
-    onProgress: (processed: number, total: number) => void;
-    /** Called once when all items have been processed. */
-    onComplete: () => void;
-    /** Called when processing is cancelled via cancel(). */
-    onCancel: () => void;
+type CellValidator = (value: unknown, row: DataEditorRow) => ValidationError | null;
+/** Text input cell. This is the default editor when no `editor` is specified. */
+type TextEditorCell = {
+    type: "text";
 };
-declare class ChunkedProcessor<T> {
-    private _generation;
-    private _isRunning;
-    private _chunkSize;
-    private _activeOnCancel;
-    private _channel;
-    private _pendingChunkFn;
-    constructor(chunkSize?: number);
-    get isRunning(): boolean;
-    get chunkSize(): number;
-    run(params: ChunkedProcessorCallbacks<T>): void;
-    cancel(): void;
-}
-
-type RegisterSourceOptions = {
-    name: string;
-    id?: DataSourceId;
-    isDeletable?: boolean;
-    isInitialData?: boolean;
+/** Date picker cell. Optionally restrict the selectable date range. */
+type DateEditorCell = {
+    type: "date";
+    /** Earliest selectable date. */
+    minDate?: Date;
+    /** Latest selectable date. */
+    maxDate?: Date;
 };
-type MergeEntry<TRow> = {
-    row: TRow;
-    sourceId: DataSourceId;
-    isNew: boolean;
-    isEdited: boolean;
+/** Dropdown select cell. The user picks from a fixed list of options. */
+type SelectEditorCell = {
+    type: "select";
+    /** The list of options shown in the dropdown. Each string is both the stored value and the display label. */
+    options: string[];
 };
-type RemovalPlan<TRow> = {
-    rowsToDelete: Set<TRowId>;
-    rowsToRestore: Array<{
-        rowId: TRowId;
-        row: TRow;
-        originalSourceId: DataSourceId;
-        isNew: boolean;
-        isEdited: boolean;
-    }>;
+/** Number input cell with locale-aware formatting. */
+type NumberEditorCell = {
+    type: "number";
+    /** Maximum number of decimal digits allowed. When omitted, decimals are unrestricted. */
+    decimalPlaces?: number;
+    /** Character used as the decimal point (e.g. `"."` or `","`). Defaults to the browser locale. */
+    decimalSeparator?: string;
+    /** Character inserted between groups of three digits (e.g. `","` or `"."`). Defaults to the browser locale. */
+    thousandsSeparator?: string;
+    /** Extra characters to allow beyond digits, decimal separator, and minus sign (e.g. `"%-"`). When defined, minus is only kept if explicitly included. */
+    allowChars?: string;
 };
-type ExtendedRemovalPlan<TRow> = RemovalPlan<TRow> & {
-    sourceId: DataSourceId;
-    repairedEntries: Array<{
-        sourceId: DataSourceId;
-        rowId: TRowId;
-        before: MergeEntry<TRow>;
-        after: MergeEntry<TRow> | null;
-    }>;
+/**
+ * Controls how a cell is edited.
+ *
+ * - `"text"` — plain text input (default).
+ * - `"date"` — date picker with optional min/max bounds.
+ * - `"select"` — dropdown with a fixed list of options.
+ * - `"number"` — number input with locale-aware formatting.
+ */
+type CellEditor = TextEditorCell | DateEditorCell | SelectEditorCell | NumberEditorCell;
+/** Dropdown filter shown in the sidebar Filters panel. */
+type SelectColumnFilter = {
+    type: "select";
+    /** Label displayed above the filter. */
+    label?: string;
+    /** Placeholder text when nothing is selected. */
+    placeholder?: string;
+    /** Fixed list of filter options. When omitted, options are derived from column values. */
+    options?: string[];
+    /** Allow selecting multiple values at once. */
+    multiple?: boolean;
 };
-declare class SourceManager<TRow extends DataEditorRow = DataEditorRow> {
-    private readonly _defaultSourceId;
-    private readonly overrides;
-    private readonly sources;
-    private readonly mergedRows;
-    getSourceId(rowId: TRowId): DataSourceId;
-    setSourceId(rowId: TRowId, sourceId: DataSourceId): void;
-    deleteSourceId(rowId: TRowId): void;
-    getOverrides(): ReadonlyMap<TRowId, DataSourceId>;
-    register(options: RegisterSourceOptions): DataSourceId;
-    /**
-     * Re-insert a source using a full captured state, preserving
-     * isVisible, isLoading, rowCount, etc. Used by SourceLifecycle.restore.
-     * If the source already exists, overwrites its state.
-     */
-    restoreState(state: DataSourceState): void;
-    has(sourceId: DataSourceId): boolean;
-    get(sourceId: DataSourceId): DataSourceState | undefined;
-    delete(sourceId: DataSourceId): void;
-    setLoading(sourceId: DataSourceId, isLoading: boolean): void;
-    finalizeAllSources(): void;
-    values(): IterableIterator<DataSourceState>;
-    getHiddenSourceIds(): Set<DataSourceId>;
-    saveMergeSnapshot(sourceId: DataSourceId, rowId: TRowId, existingRow: TRow, previousSourceId: DataSourceId, isNew: boolean, isEdited: boolean): void;
-    /**
-     * Public so commands can re-install merge entries during undo of a remove.
-     */
-    restoreMergeEntry(sourceId: DataSourceId, rowId: TRowId, entry: MergeEntry<TRow>): void;
-    /**
-     * Pure — computes the full removal plan without mutating any state.
-     * Callers run applyRemovalPlan(plan) to commit.
-     */
-    planRemoval(sourceId: DataSourceId): ExtendedRemovalPlan<TRow> | null;
-    /**
-     * Mutates internal state per plan produced by planRemoval.
-     */
-    applyRemovalPlan(plan: ExtendedRemovalPlan<TRow>): void;
-    clear(): void;
-    private getUniqueName;
-}
-
-type ServerDataManagerDeps<TRow extends DataEditorRow = DataEditorRow> = {
-    clear(): void;
-    setLoading(isLoading: boolean): void;
-    registerSource(options: RegisterSourceOptions): DataSourceId;
-    setSourceLoading(sourceId: DataSourceId, isLoading: boolean): void;
-    getLocalRowCount(): number;
-    replaceServerRows(sourceId: DataSourceId, rows: ServerRow<TRow>[], offset: number, counts?: ServerQueryCounts): void;
-    appendServerRows(rows: ServerRow<TRow>[], counts?: ServerQueryCounts): void;
-    prependServerRows(rows: ServerRow<TRow>[], offset: number, counts?: ServerQueryCounts): void;
-    applyServerRowMeta(rows: ServerRow<TRow>[], counts?: ServerQueryCounts): void;
+/** Numeric min/max range filter shown in the sidebar Filters panel. */
+type NumberRangeColumnFilter = {
+    type: "number-range";
+    /** Label displayed above the filter. */
+    label?: string;
 };
-type FetchDirection = "forward" | "backward" | "jump";
-declare class ServerDataManager<TRow extends DataEditorRow = DataEditorRow> {
-    private _offset;
-    private _totalCount;
-    private _isFetching;
-    private readonly _pageSize;
-    private readonly _maxBufferRows;
-    private _filters;
-    private _sources;
-    private _sort;
-    private _filterOptions;
-    private _filterOptionsFetched;
-    private _abortController;
-    private _syncAbort;
-    private _lastVisibleStart;
-    private _debouncedFetch;
-    private readonly _config;
-    private readonly _dataStoreRef;
-    private readonly _sourceLabel;
-    private _onChanged;
-    constructor(config: DataEditorServer<TRow>, dataStoreRef: ServerDataManagerDeps<TRow>, sourceLabel: string);
-    get offset(): number;
-    get totalCount(): number | null;
-    get isFetching(): boolean;
-    get pageSize(): number;
-    get maxBufferRows(): number;
-    setOnChanged(callback: () => void): void;
-    setOffset(offset: number): void;
-    setTotalCount(count: number): void;
-    private setFetching;
-    getExcess(currentCount: number, newCount: number): number;
-    shouldFetch(visibleStart: number, visibleEnd: number, loadedCount: number): FetchDirection | null;
-    /**
-     * Full reload — abort in-flight, clear store, fetch first page.
-     * Called on initial load, search/filter/sort changes, and resetFilters.
-     */
-    reload(): void;
-    /**
-     * Scroll-driven pagination with velocity-based debouncing.
-     * Called from CanvasGrid on every scroll event.
-     */
-    handleScroll(visibleStart: number, visibleEnd: number): void;
-    /**
-     * Fetch a single page based on scroll position and current window state.
-     */
-    private fetchPage;
-    /**
-     * Re-query the current viewport and replace row data, metadata, and counts.
-     * Called after successful edits and find-and-replace mutations.
-     * Each call aborts the previous in-flight sync.
-     */
-    syncCurrentView(): void;
-    /**
-     * Merge filter keys into server filter state and reload.
-     * Called by DataStore.setFilters() in server mode and by filter components.
-     */
-    setFilters(filters: Partial<Filters>): void;
-    /**
-     * Set sort state and reload.
-     */
-    setSort(sort: SortState): void;
-    /**
-     * Restrict query to visible sources and reload.
-     * Pass `undefined` to include all sources.
-     */
-    setSources(sources: string[] | undefined): void;
-    /**
-     * Clear all filters and sort, then reload.
-     */
-    resetFilters(): void;
-    /**
-     * One-time fetch of filter option dictionaries for sidebar filter controls.
-     */
-    fetchFilterOptions(): void;
-    getFilterOptions(): FilterOptionsResponse | null;
-    get onEdit(): (params: EditParams, options?: ServerCallOptions) => Promise<EditResponse | void>;
-    get filters(): Record<string, unknown>;
-    get sort(): SortState;
-    get sources(): string[] | undefined;
-    get onSourceRemove(): ((params: SourceRemoveParams) => Promise<void>) | undefined;
-    get onColumnDelete(): ((params: ColumnDeleteParams) => Promise<EditResponse | void>) | undefined;
-    get onColumnEdit(): ((params: ColumnEditParams) => Promise<EditResponse | void>) | undefined;
-    get hasExport(): boolean;
-    private _exportAbortController;
-    export(format: DataEditorFormat, allRows: boolean, rtl: boolean): Promise<void>;
-    clear(): void;
-    destroy(): void;
-}
-
-/**
- * A post-resolution selection rectangle in stable coordinate space.
- * Produced by grid-layer resolvers from CellRange[] in grid-index space.
- * Consumed by DataStore operations and server sync.
- */
-type SelectionRect = {
-    readonly fields: readonly string[];
-    readonly rowIds: readonly TRowId[];
+/** Date min/max range filter shown in the sidebar Filters panel. */
+type DateRangeColumnFilter = {
+    type: "date-range";
+    /** Label displayed above the filter. */
+    label?: string;
 };
-
 /**
- * ServerEditBuilder — Stateless coordinate translator for server-delegated edits.
- *
- * Converts frontend coordinates (TRowId, column index, grid ranges) into
- * `EditParams` with `Region[]` that the server can interpret.
+ * Filter control shown in the sidebar Filters panel for a column.
  *
- * Does NOT call `onEdit`. Only builds params.
- * DataStore calls the builder, then sends the result to the server.
+ * - `"select"` — dropdown to pick one or more values.
+ * - `"number-range"` — two inputs for min and max number.
+ * - `"date-range"` — two date pickers for start and end date.
+ */
+type ColumnFilter = SelectColumnFilter | NumberRangeColumnFilter | DateRangeColumnFilter;
+/** Lock mode for a column. `"all"` locks for every row; `"default"` locks only default-source rows. */
+type ColumnLockMode = "all" | "default";
+/**
+ * Defines a column in the editor grid.
  *
- * Responsibilities:
- *   - TRowId → ServerRowId translation via primaryKey
- *   - Grid index → column ID translation via columns array
- *   - Filter/sort context attachment from ServerDataManager
+ * @example
+ * ```ts
+ * const columns: DataEditorColumn[] = [
+ *   { id: "name", title: "Full Name", size: 200, validators: [{ type: "required", message: "Name is required" }] },
+ *   { id: "email", title: "Email", size: 250, validators: [{ type: "required", message: "Email is required" }, { type: "email", message: "Invalid email" }], unique: true },
+ *   { id: "role", title: "Role", editor: { type: "select", options: ["Admin", "Editor", "Viewer"] } },
+ *   { id: "salary", title: "Salary", validators: [{ type: "numeric", message: "Must be a number" }], formatter: (v) => v ? `$${v}` : "" },
+ * ];
+ * ```
  */
-
-type ServerEditDeps<TRow extends DataEditorRow = DataEditorRow> = {
-    getPrimaryKey: () => string;
-    getRowById: (id: TRowId) => TRow | undefined;
-    getColumnIds: () => string[];
-    getFilters: () => Record<string, unknown>;
-    getSort: () => SortState;
-    getLockedColumns: () => ReadonlyMap<string, ColumnLockMode>;
-};
-declare class ServerEditBuilder<TRow extends DataEditorRow = DataEditorRow> {
-    private readonly _deps;
-    constructor(deps: ServerEditDeps<TRow>);
-    resolveServerRowId(rowId: TRowId): ServerRowId | undefined;
-    buildRegion(rowIds: TRowId[], columnIds: string[]): Region;
+type DataEditorColumn = {
+    /** Unique column identifier. Must match the keys in your row data. */
+    id: string;
+    /** Column header text shown to the user. */
+    title: string;
     /**
-     * Collapse rowIds × columnIds into minimal Region[].
-     * - All columns → omit column fields (row-only regions).
-     * - Contiguous columns in schema order → single fromColumn/toColumn span.
-     * - Non-contiguous → one region per contiguous column group.
-     * Rows are expressed as fromRow/toRow using first/last of the provided array.
+     * One or more validators run on every edit. Accepts:
+     * - Built-in object literals: `{ type: "required" | "email" | "regex" | "range" | "oneOf" | "date" | "numeric", ... }`.
+     * - `{ type: "expression", expr }` — server-mode only. Warned in client mode.
+     * - `{ type: "function", fn }` — client-mode only. Dropped+warned in server mode.
+     *
+     * See `_specs/VALIDATIONS.md` §4.5 for the per-mode support matrix.
      */
-    buildRegions(rowIds: TRowId[], columnIds: string[]): Region[];
+    validators?: ValidatorRule[];
     /**
-     * Collapse columnIds into minimal column-only Region[] (all rows implied).
-     * - All columns → `{ allSelected: true }`.
-     * - Contiguous in schema order → single `{ fromColumn, toColumn }`.
-     * - Non-contiguous → one region per contiguous group.
+     * When `true`, the editor flags duplicate values in this column as errors.
+     * The error message is localized via the `translations` prop
+     * (`dataEditor.validation.valueMustBeUnique`).
      */
-    buildColumnRegions(columnIds: string[]): Region[];
+    unique?: boolean;
     /**
-     * Build minimal Region[] from multiple selection rectangles.
-     * Each rect is collapsed independently, preserving disjoint selections.
+     * Column IDs to revalidate when this column changes. Use for cross-field
+     * rules like "end date must be after start date".
      */
-    buildRegionsFromRects(rects: SelectionRect[]): Region[];
-    buildAllSelectedRegion(): Region;
-    buildColumnRegion(columnId: string): Region;
-    buildRowRegion(fromRowId: TRowId, toRowId: TRowId): Region;
-    cellEdit(rowId: TRowId, field: string, value: unknown): EditParams;
-    clear(target: Region[]): EditParams;
-    paste(source: Region[], target: Region[], cut?: boolean): EditParams;
-    pasteExternal(target: Region[], values: unknown[][]): EditParams;
-    fill(source: Region[], target: Region[]): EditParams;
-    transform(target: Region[], transform: TransformParams): EditParams;
-    deleteRows(rowRanges: [TRowId, TRowId][]): EditParams;
-    restoreRows(rowRanges: [TRowId, TRowId][]): EditParams;
-    deleteAllRows(): EditParams;
-    restoreAllRows(): EditParams;
-    insertRow(anchorRowId: TRowId | undefined, position: InsertParams["position"], values: unknown[][], columnIds: string[]): EditParams;
+    dependentFields?: string[];
+    /** Format the display value without changing stored data. E.g. add `$` prefix. */
+    formatter?: (value: string) => string;
     /**
-     * Returns null when all columns are selected (caller decides representation).
-     * Otherwise returns contiguous column spans as `{ fromColumn, toColumn }` regions.
+     * Transform a value before it enters the store. Runs when rows are uploaded
+     * to the data editor.
      */
-    private collapseColumns;
-    private viewContext;
-}
-
-/**
- * Categories of internal errors surfaced through the `onError` callback.
- *
- * - `PARSE_ERROR` — file parsing failed (corrupt CSV, invalid XLSX, etc.).
- * - `RENDER_ERROR` — component render failed (caught by error boundary).
- * - `TRANSFORM_ERROR` — data transformation failed (column transform, value mapping).
- * - `VALIDATION_ERROR` — validation execution failed (validator threw instead of returning).
- * - `WORKER_ERROR` — Web Worker failed (filter worker, chat transform worker).
- * - `COMMAND_ERROR` — undo/redo command failed.
- * - `OPERATION_ERROR` — general operation failed (bulk mutations, imports).
- */
-type UpdogErrorCode = "PARSE_ERROR" | "RENDER_ERROR" | "TRANSFORM_ERROR" | "VALIDATION_ERROR" | "WORKER_ERROR" | "COMMAND_ERROR" | "OPERATION_ERROR";
-/**
- * An internal error caught by the SDK and passed to `onError`. The SDK
- * recovers gracefully where possible — `onError` is for your logging and
- * monitoring (Sentry, Datadog, etc.).
- *
- * @example
- * ```ts
- * onError={(error) => {
- *   Sentry.captureException(error.originalError ?? error, {
- *     tags: { code: error.code, source: error.source },
- *   });
- * }}
- * ```
- */
-type UpdogError = {
-    /** The error category. */
-    code: UpdogErrorCode;
-    /** Human-readable description. */
-    message: string;
-    /** Module or subsystem that raised the error. */
-    source: string;
-    /** The underlying thrown value, when available. */
-    originalError?: unknown;
+    transformer?: (value: unknown) => unknown;
+    /** How the cell is edited. Defaults to text input. */
+    editor?: CellEditor;
+    /** Adds a filter control for this column in the sidebar Filters panel. */
+    filter?: ColumnFilter;
+    /**
+     * Whether this column can be pinned to the left (right in RTL) via the
+     * header context menu. @default true
+     */
+    pinnable?: boolean;
+    /** Column width in pixels. @default 150 */
+    size?: number;
+    /**
+     * Controls whether cells in this column are locked. A column locked via
+     * configuration cannot be unlocked from the UI.
+     * - `true` | `"all"` — locked for every row.
+     * - `"default"` — locked only for default-source rows; rows added manually,
+     *   duplicated, or imported remain editable.
+     * - `false` | `undefined` — not locked.
+     */
+    locked?: boolean | ColumnLockMode;
 };
 
-declare class ErrorHandler {
-    private onError?;
-    constructor(onError?: (error: UpdogError) => void);
-    handleError(error: UpdogError): void;
-}
-
+/** Params passed to `findAndReplace.onFind` when the user types a search query. */
+type FindParams = {
+    /** The search string. */
+    search: string;
+    /** When `true`, matching is case-sensitive. */
+    matchCase?: boolean;
+    /** When `true`, the entire cell value must equal the search string. */
+    matchEntireCell?: boolean;
+    /** Restrict search to these columns. `null` or omitted = all columns. */
+    columnIds?: string[] | null;
+    /** Current view filters so the server can scope matches to the active filter set. */
+    filters?: QueryFilters;
+    /** Current sort state so match ordering follows the visual row order. */
+    sort?: SortState;
+};
+/** A single match location returned by the server. */
+type FindMatch = {
+    /** Row position in the current filtered+sorted view (for grid scrolling). */
+    rowIndex: number;
+    /** Column ID where the match occurs. */
+    columnId: string;
+    /** Character offset within the cell value (for inline highlight). */
+    startIndex: number;
+    /** 0-based position in the ordered match list (for counter display). */
+    matchIndex: number;
+};
+/** Response from `findAndReplace.onFind`. */
+type FindResponse = {
+    /** Total number of matches across all rows. */
+    totalCount: number;
+    /** The first match. Omit when `totalCount` is 0. */
+    current?: FindMatch;
+};
+/** Params passed to `findAndReplace.onNavigate` when the user clicks prev/next. */
+type FindNavigateParams = FindParams & {
+    /** Navigation direction. */
+    direction: "next" | "prev";
+    /** Current match position so the server knows where to navigate from. */
+    currentMatchIndex: number;
+};
+/** Params passed to `findAndReplace.onReplace`. */
+type ReplaceParams = FindParams & {
+    /** The replacement text. */
+    replacement: string;
+    /** When `true`, replace all matches. When omitted or `false`, replace only `target`. */
+    all?: boolean;
+    /** The specific match to replace. Required when `all` is not `true`. */
+    target?: FindMatch;
+};
+/** Response from `findAndReplace.onReplace`. */
+type ReplaceResponse = {
+    /** Remaining match count after replacement. */
+    totalCount: number;
+    /** Next match to navigate to after replacement. Omit when none left. */
+    current?: FindMatch;
+};
+/** Server-side find and replace configuration. */
+type FindAndReplaceConfig = {
+    /** Called when the user types a search query. Returns total count and first match. */
+    onFind: (params: FindParams) => Promise<FindResponse>;
+    /** Called when the user clicks prev/next arrows. Returns the target match. */
+    onNavigate: (params: FindNavigateParams) => Promise<FindMatch>;
+    /** Called when the user clicks Replace or Replace All. */
+    onReplace: (params: ReplaceParams) => Promise<ReplaceResponse>;
+};
+type StoreMode = "client" | "server";
+type ServerRowId = string | number;
+/** Row-level status flags returned by the server. Drive row filters and sidebar counts. */
+type ServerRowStatus = {
+    edited?: boolean;
+    new?: boolean;
+    deleted?: boolean;
+    hasErrors?: boolean;
+    hasEmptyCells?: boolean;
+};
+/** Server-reported change for a single cell. The current value lives in `fields`. */
+type ServerCellChange = {
+    original: unknown;
+};
+/** Server-reported validation error for a single cell. */
+type ServerCellError = {
+    message: string;
+    code?: number | string;
+};
+/** Per-row metadata returned by the server in server-delegated mode. */
+type ServerRowMeta = {
+    /** Row-level status flags — drive row filters and sidebar counts. */
+    status?: ServerRowStatus;
+    /** Cell-level change tracking. Key = field name. */
+    changes?: Record<string, ServerCellChange>;
+    /** Cell-level validation errors. Key = field name. */
+    errors?: Record<string, ServerCellError[]>;
+};
+/** Per-source row count returned by the server. Drives the Data Sources sidebar. */
+type ServerSourceCount = {
+    id: string;
+    name: string;
+    count: number;
+};
+/** Aggregate row counts returned alongside a query page. Drive sidebar indicators. */
+type ServerQueryCounts = {
+    edited?: number;
+    new?: number;
+    deleted?: number;
+    errors?: number;
+    emptyCells?: number;
+    sources?: ServerSourceCount[];
+};
+type ServerRow<T extends DataEditorRow = DataEditorRow> = {
+    id: ServerRowId;
+    fields: T;
+    meta?: ServerRowMeta;
+};
+type ServerResponse<T> = {
+    data: T;
+    meta?: Record<string, unknown>;
+};
+type QueryFilters<F = Record<string, unknown>> = Partial<Filters> & F;
+type QueryParams<F = Record<string, unknown>> = {
+    filters?: QueryFilters<F>;
+    sort?: SortState;
+    /** When present, only rows belonging to these source IDs are returned. Omit to include all sources. */
+    sources?: string[];
+    offset?: number;
+    limit: number;
+    signal?: AbortSignal;
+};
+type QueryResponse<T extends DataEditorRow = DataEditorRow> = ServerResponse<{
+    rows: ServerRow<T>[];
+    totalCount: number;
+    filteredCount?: number;
+    counts?: ServerQueryCounts;
+}>;
 /**
- * DirtyTracker — Change classification and revert detection for rows.
+ * Filter options returned by `onFilterOptions` for populating sidebar filter controls in server mode.
+ * Keys are column IDs. Only include columns that have a `filter` configured.
+ */
+type FilterOptionsResponse = {
+    [columnId: string]: {
+        /** Values for `"select"` filters. Raw display strings — no formatter is applied. */
+        options?: string[];
+        /** Bounds for `"number-range"` filters. */
+        range?: {
+            min: number;
+            max: number;
+        };
+        /** Bounds for `"date-range"` filters. Values are ISO date strings (YYYY-MM-DD). */
+        dateRange?: {
+            min: string;
+            max: string;
+        };
+    };
+};
+type ServerCallOptions = {
+    signal: AbortSignal;
+};
+/**
+ * Coordinate rectangle within the server's data view.
+ * Uses ServerRowId (primary key) for rows and column ID strings for columns.
  *
- * Every row falls into one of three categories:
- *   - Clean    — matches the backend; not tracked here at all
- *   - New      — created locally (CSV import or manual add), never existed on the backend
- *   - Edited   — exists on the backend but has been modified locally
+ * Convention:
+ * - Both row fields omitted → all rows.
+ * - Both column fields omitted → all columns.
+ * - Single row: `fromRow` AND `toRow` both set, `toRow === fromRow`.
+ * - Single column: `fromColumn` AND `toColumn` both set, `toColumn === fromColumn`.
+ * - Range: both `from` and `to` set, `to !== from`.
+ * - `allSelected: true` → all rows and all columns.
+ * - Empty `{}` → used only for insert operations.
  *
- * Classification uses inverted tracking via `nonBackendRowIds`: only non-backend
- * rows (CSV imports, manual adds) are stored in the set. Since backend rows are
- * the vast majority (~1M), this inverted approach saves ~50MB by assuming any
- * row NOT in the set is a backend row.
- *   - First edit of a backend row → "edited", original row is snapshotted
- *   - First edit of a non-backend row → "new"
+ * INVALID: `from` present without `to`, or vice versa.
+ */
+type Region = {
+    fromRow?: ServerRowId;
+    toRow?: ServerRowId;
+    fromColumn?: string;
+    toColumn?: string;
+    allSelected?: boolean;
+};
+/** Describes where and how to insert a new row. */
+type InsertParams = {
+    /** Existing row to anchor the insert relative to. Omitted when appending to the end. */
+    anchorRow?: ServerRowId;
+    /** Insert before or after the anchor row. */
+    position: "above" | "below";
+    /** Column IDs matching the order of `values` entries. */
+    columns: string[];
+};
+/**
+ * Unified edit params for all data mutations in server-delegated mode.
  *
- * Smart revert: after every edit, the current row is compared field-by-field
- * against the snapshot. If all fields match the original, the row silently
- * reverts to "clean" — no dirty flag, no undo entry needed. This lets users
- * fix typos by simply typing the original value back.
+ * The combination of fields determines the operation:
+ * - `target` + `values`             → cell edit, clear, or external paste
+ * - `target` + `source`             → internal paste (+ `cut` for cut-paste)
+ * - `target` + `source` (fill)      → fill handle
+ * - `target` + `transform`          → transform / revert
+ * - `target` + `delete: true`       → mark rows for deletion
+ * - `target` + `delete: false`      → restore rows (unmark deletion)
+ * - `insert` + `values`             → create a new row
  *
- * Merge snapshots: when a CSV import overwrites an existing row, the original
- * data + classification is saved so it can be restored if the source is removed.
+ * `values` is always a 2D array. For a single cell edit: `[["newValue"]]`.
+ * For clearing: `[[""]]`. The server interprets dimensions relative to `target`:
+ * a 1×1 `values` applied to a multi-cell target means "fill all cells with this value".
+ *
+ * `filters` and `sort` provide the view context so the server can resolve
+ * which rows fall between `fromRow` and `toRow` in the current view.
+ * Omitted for single-cell edits where `fromRow` is a direct row ID.
  */
-
-type IDirtyTracker<TRow extends DataEditorRow = DataEditorRow> = {
-    markDeleted(id: TRowId): void;
-    unmarkDeleted(id: TRowId): void;
-    isDeleted(id: TRowId): boolean;
-    getDeletedRowIds(): ReadonlySet<TRowId>;
-    deletedCount(): number;
-    isDefaultSourceRow(id: TRowId): boolean;
-    isNew(id: TRowId): boolean;
-    isEdited(id: TRowId): boolean;
-    isCellDirty(id: TRowId, field: string, currentRow: TRow | undefined): boolean;
-    getOriginalCellValue(id: TRowId, field: string): unknown | undefined;
-    getOriginalRow(id: TRowId): TRow | undefined;
-    hasOriginalRow(id: TRowId): boolean;
-    trackNonBackendRow(id: TRowId): void;
-    markNew(id: TRowId): void;
-    markEdited(id: TRowId): void;
-    snapshotOriginal(id: TRowId, row: TRow): void;
-    classifyOnFirstEdit(id: TRowId, row: TRow): void;
-    checkRevert(id: TRowId, currentRow: TRow): {
-        wasNew: boolean;
-        wasEdited: boolean;
-    };
-    removeTracking(id: TRowId): void;
-    getNewRowIds(): ReadonlySet<TRowId>;
-    getEditedRowIds(): ReadonlySet<TRowId>;
-    getMergeSnapshot(id: TRowId): {
-        isNew: boolean;
-        isEdited: boolean;
-    };
-    restoreMergeClassification(id: TRowId, isNew: boolean, isEdited: boolean): void;
-    clear(): void;
+type EditParams = {
+    target: Region[];
+    source?: Region[];
+    values?: unknown[][];
+    transform?: TransformParams;
+    cut?: boolean;
+    delete?: boolean;
+    insert?: InsertParams;
+    undo?: boolean;
+    filters?: QueryFilters;
+    sort?: SortState;
+    lockedColumns?: Array<{
+        columnId: string;
+        mode: "all" | "default";
+    }>;
 };
-
-interface FlagReader {
-    hasError(id: TRowId): boolean;
-    isNew(id: TRowId): boolean;
-    isEdited(id: TRowId): boolean;
-    hasEmptyCells(id: TRowId): boolean;
-    isDeleted(id: TRowId): boolean;
-    hasDeletedRows(): boolean;
-    getSourceId(id: TRowId): string;
-    getErrorBitmask(id: TRowId, fieldOrder: string[], wordIdx: number): number;
-    getEditedBitmask(id: TRowId, fieldOrder: string[], wordIdx: number): number;
-    getErrorMessageToRows(): ReadonlyMap<string, ReadonlySet<TRowId>>;
-    getRowValidations(id: TRowId): Map<string, NonNullable<ValidationResult>> | undefined;
-}
-interface FilterRowReader<TRow extends DataEditorRow = DataEditorRow> {
-    getRowIds(): TRowId[];
-    getRowById(id: TRowId): TRow | undefined;
-    getHiddenSourceIds(): Set<DataSourceId>;
-}
-type IFilterEngine<TRow extends DataEditorRow = DataEditorRow> = {
-    getFilteredRowIds(): TRowId[] | null;
-    getBaseFilteredRowIds(): TRowId[] | null;
-    getFilterVersion(): number;
-    getFilterCriteriaVersion(): number;
-    isFiltering(): boolean;
-    getFilters(): Filters;
-    getFieldOrder(): string[];
-    getWordsPerRow(): number;
-    getShowOnlyDeletedRows(): boolean;
-    getSortState(): SortState;
-    setReaders(rowReader: FilterRowReader<TRow>, flagReader: FlagReader): void;
-    setColumns(columns: DataEditorColumn[]): void;
-    setFilters(filters: Partial<Filters>): void;
-    setSortState(state: SortState, sortType?: SortType, locales?: string[]): Promise<void>;
-    updateRowText(rowId: TRowId, row: TRow): void;
-    updateRowsText(rows: {
-        id: TRowId;
-        row: TRow;
-    }[]): void;
-    deleteRowTextCache(rowId: TRowId): void;
-    clearRowTextCacheAll(): void;
-    setRowTextCache(rowId: TRowId, row: TRow): void;
-    rebuild(): void;
-    refilterAfterColumnsChange(): void;
-    notifyRowsAdded(ids: TRowId[]): void;
-    notifyRowsDeleted(deletedIds: TRowId[]): void;
-    notifyRowsInserted(restoredIds: TRowId[], positions: number[]): void;
-    refilterAfterSourceToggle(sourceId: DataSourceId, isVisible: boolean): void;
-    refilterAfterFlagChange(): void;
-    flushPendingFlags(): void;
-    markFlagsDirty(): void;
-    testRowAgainstFilters(rowId: TRowId, row: TRow, flagReader: FlagReader, hiddenSourceIds: Set<DataSourceId>): boolean;
-    getAllRowIdsSorted(rowReader: FilterRowReader<TRow>): Promise<TRowId[]>;
-    clear(): void;
-    destroy(): void;
+type ExportParams$1<F = Record<string, unknown>> = {
+    format: "csv" | "tsv" | "xlsx" | "json" | "xml";
+    allRows: boolean;
+    rtl?: boolean;
+    filters?: QueryFilters<F>;
+    sort?: SortState;
+    signal?: AbortSignal;
+};
+/** Transform operation descriptor. `type` identifies the operation, optional fields carry parameters. */
+type TransformParams = {
+    type: string;
+    separator?: string;
+    /** When `true`, the server should delete the dynamic source columns after applying the transform. */
+    deleteSource?: boolean;
+};
+/** Params passed to `onColumnDelete` when the user deletes a dynamic column. */
+type ColumnDeleteParams = {
+    /** ID of the dynamic column to delete. */
+    columnId: string;
+    /** `true` when the server should reverse this operation (undo). Omitted on initial call and redo. */
+    undo?: boolean;
+};
+/** Params passed to `onColumnEdit` when the user renames a dynamic column. */
+type ColumnEditParams = {
+    /** ID of the dynamic column being edited. */
+    columnId: string;
+    /** New title for the column. */
+    title: string;
+    /** `true` when the server should reverse this operation (undo). Omitted on initial call and redo. */
+    undo?: boolean;
+};
+/** Server's response after applying a mutation. */
+type EditResponse = {
+    counts?: ServerQueryCounts;
+    /** Business-logic rejection. SDK reverts the optimistic update and shows `reason` in a toast. */
+    rejected?: boolean;
+    /** Why the server rejected. Shown to the user as-is. */
+    reason?: string;
+    /** The full row created by the server. Returned for insert operations. */
+    row?: ServerRow;
+    /** Updated column list. When present, the SDK replaces its columns with this list. */
+    columns?: Array<{
+        id: string;
+        title: string;
+    }>;
+};
+/**
+ * Every decision the user made during the import wizard, packed into one object.
+ * You get the raw file and the full mapping config. Parse it however you want —
+ * stream it, bulk-load it, hand it to a background job. Your call.
+ */
+type ImportMappings = {
+    /** CSV header → column ID. Headers the user left unmatched are `undefined`. */
+    columnMapping: Record<string, string | undefined>;
+    /**
+     * Value substitutions for select columns.
+     * Outer key = column ID, inner key = imported value, inner value = target option.
+     * Only present when at least one select column was matched.
+     */
+    valueMapping: Record<string, Record<string, string | undefined>>;
+    /** Column ID used to match imported rows against existing data. Same value as `DataEditorProps.primaryKey`. */
+    primaryKey: string;
+    /** Sheet name the user selected. Only present for multi-sheet XLSX files. */
+    selectedSheet?: string;
+    /** Zero-based index of the row the SDK detected as the header row. */
+    headerRowIndex: number;
+    /** Number format detected from the file contents. Affects how `"1.234,56"` vs `"1,234.56"` is read. */
+    numberFormat: "EU" | "US";
+    /**
+     * Per-column date disambiguation. Key = CSV header (not column ID).
+     * `"EU"` = day-first, `"US"` = month-first.
+     * Only includes columns where the format was ambiguous and had to be resolved.
+     */
+    dateFormats: Record<string, "EU" | "US">;
+    /**
+     * Columns the user created during import for unmatched headers.
+     * These don't exist in your schema yet — you decide whether to persist them.
+     */
+    newColumns: DataEditorColumn[];
+};
+/** Params passed to `onFileImport`. The original file, unchanged, plus everything the wizard collected. */
+type FileImportParams = {
+    /** The original file. Same bytes the user dropped into the browser. */
+    file: File;
+    /** All mapping decisions from the import wizard. */
+    mappings: ImportMappings;
+    /** Display name for this import source. Typically the file name. */
+    sourceName: string;
+    /** Fires when the user cancels the import. */
+    signal?: AbortSignal;
+};
+/**
+ * Params passed to `onRowsImport` once per chunk.
+ * The SDK already parsed the file, applied column mappings, normalized dates
+ * and numbers, and resolved value mappings. You get clean, schema-conformant rows.
+ */
+type RowsImportParams = {
+    /** Stable ID for this import session. Use it for idempotency or correlation. */
+    importId: string;
+    /** Display name for this import source. Typically the file name. */
+    sourceName: string;
+    /** Zero-based chunk index. Together with `importId`, uniquely identifies each chunk. */
+    chunkIndex: number;
+    /** `true` on the last chunk. Safe to finalize, run post-import hooks, or trigger validation. */
+    isLastChunk: boolean;
+    /** Transformed rows, keyed by column ID. Ready to store. */
+    rows: Record<string, unknown>[];
+    /** Columns the user created during import. Only present on the first chunk (`chunkIndex === 0`). */
+    newColumns?: DataEditorColumn[];
+    /** Column ID used to match imported rows against existing data. */
+    primaryKey: string;
+    /** Fires when the user cancels mid-import. Clean up any partial state. */
+    signal?: AbortSignal;
+};
+/** Your response after processing a chunk. */
+type RowsImportResponse = {
+    /** How many rows you accepted from this chunk. Drives progress reporting. */
+    accepted: number;
+    /** Per-row errors. `rowIndex` is relative to the chunk (0-based). Surfaced in the UI after import. */
+    errors?: Array<{
+        rowIndex: number;
+        message: string;
+    }>;
+};
+/** Params passed to `onSourceRemove` when the user deletes a data source. */
+type SourceRemoveParams = {
+    /** The source ID to remove. Matches the `id` from `ServerQueryCounts.sources`. */
+    sourceId: string;
+    /** Fires when the user cancels. */
+    signal?: AbortSignal;
 };
 
 /**
- * RowStore — Row storage with dual-access pattern for the grid engine.
+ * ChunkedProcessor — Generic utility for processing items in prioritized chunks
+ * with cancellation support via generation counter.
  *
- * Maintains two parallel structures:
- *   - (TRow | undefined)[]  → O(1) lookup by stable internal ID (rows[id])
- *   - TRowId[]              → O(1) lookup by visual index (required by the grid)
+ * Used to break O(N) synchronous operations into non-blocking background work:
+ *   1. Priority items are processed synchronously first (e.g. viewport rows)
+ *   2. Remaining items are processed in chunks via MessageChannel
+ *   3. Between chunks the browser can paint frames and handle events
  *
- * The grid calls getRow(index) on every frame, so index-based access must be
- * instant. Filtered views are supported by passing an alternate ID array
- * (filteredIds) to the access methods — the store itself is unaware of filters.
+ * Uses MessageChannel instead of setTimeout(0) to avoid the browser's ~4ms
+ * minimum delay imposed on nested setTimeouts, reducing scheduling overhead
+ * from ~6ms/chunk to ~1ms/chunk.
  *
- * An inverted index (rowId → visual index) is lazily rebuilt on demand for
- * O(1) reverse lookups (e.g., scrolling to a specific row after undo).
+ * Cancellation uses the same generation counter pattern as FilterEngine:
+ * calling cancel() or run() again increments the generation, and any
+ * in-flight MessageChannel callbacks silently exit when they detect
+ * their generation is stale.
  *
- * Internal row IDs are auto-generated as sequential numbers (1, 2, 3, …).
- * Using a plain array indexed by ID eliminates Map hash table overhead
- * (~10MB saved at 1M rows). Deleted slots are set to undefined (not delete)
- * to keep V8 in HOLEY_ELEMENTS mode.
+ * This class has zero domain knowledge — it works with any item type.
  */
+type ChunkedProcessorCallbacks<T> = {
+    /** All items to process (excluding priority items). */
+    all: T[];
+    /** Items processed synchronously before any chunking begins. */
+    priority: T[];
+    /** Called for each batch of items (priority batch first, then chunks). */
+    onChunk: (items: T[]) => void;
+    /** Called after each chunk with (processed so far, total). */
+    onProgress: (processed: number, total: number) => void;
+    /** Called once when all items have been processed. */
+    onComplete: () => void;
+    /** Called when processing is cancelled via cancel(). */
+    onCancel: () => void;
+};
+declare class ChunkedProcessor<T> {
+    private _generation;
+    private _isRunning;
+    private _chunkSize;
+    private _activeOnCancel;
+    private _channel;
+    private _pendingChunkFn;
+    constructor(chunkSize?: number);
+    get isRunning(): boolean;
+    get chunkSize(): number;
+    run(params: ChunkedProcessorCallbacks<T>): void;
+    cancel(): void;
+}
 
-declare class RowStore<TRow extends DataEditorRow = DataEditorRow> {
-    private rows;
-    private rowIds;
-    private rowIdCounter;
-    private rowIdToIndex;
-    private _rowIndexDirty;
-    nextRowId(): TRowId;
-    getRow(index: number, filteredIds: TRowId[] | null): TRow | undefined;
-    getRowById(id: TRowId): TRow | undefined;
-    getRowId(index: number, filteredIds: TRowId[] | null): TRowId | undefined;
-    getRowIndex(rowId: TRowId, filteredIds: TRowId[] | null): number;
-    getRowIds(): TRowId[];
-    getRowCount(): number;
-    allRows(): IterableIterator<TRow>;
-    hasRow(id: TRowId): boolean;
-    setRow(id: TRowId, row: TRow): void;
-    deleteRow(id: TRowId): void;
-    pushRowId(id: TRowId): void;
-    spliceRowId(pos: number, id: TRowId): void;
-    removeRowId(id: TRowId): void;
-    filterRowIds(predicate: (id: TRowId) => boolean): void;
-    trimFromStart(count: number): TRowId[];
-    trimFromEnd(count: number): TRowId[];
-    unshiftRowIds(ids: TRowId[]): void;
-    invalidateIndex(): void;
+type RegisterSourceOptions = {
+    name: string;
+    id?: DataSourceId;
+    isDeletable?: boolean;
+    isInitialData?: boolean;
+};
+type MergeEntry<TRow> = {
+    row: TRow;
+    sourceId: DataSourceId;
+    isNew: boolean;
+    isEdited: boolean;
+};
+type RemovalPlan<TRow> = {
+    rowsToDelete: Set<TRowId>;
+    rowsToRestore: Array<{
+        rowId: TRowId;
+        row: TRow;
+        originalSourceId: DataSourceId;
+        isNew: boolean;
+        isEdited: boolean;
+    }>;
+};
+type ExtendedRemovalPlan<TRow> = RemovalPlan<TRow> & {
+    sourceId: DataSourceId;
+    repairedEntries: Array<{
+        sourceId: DataSourceId;
+        rowId: TRowId;
+        before: MergeEntry<TRow>;
+        after: MergeEntry<TRow> | null;
+    }>;
+};
+declare class SourceManager<TRow extends DataEditorRow = DataEditorRow> {
+    private readonly _defaultSourceId;
+    private readonly overrides;
+    private readonly sources;
+    private readonly mergedRows;
+    getSourceId(rowId: TRowId): DataSourceId;
+    setSourceId(rowId: TRowId, sourceId: DataSourceId): void;
+    deleteSourceId(rowId: TRowId): void;
+    getOverrides(): ReadonlyMap<TRowId, DataSourceId>;
+    register(options: RegisterSourceOptions): DataSourceId;
+    /**
+     * Re-insert a source using a full captured state, preserving
+     * isVisible, isLoading, rowCount, etc. Used by SourceLifecycle.restore.
+     * If the source already exists, overwrites its state.
+     */
+    restoreState(state: DataSourceState): void;
+    has(sourceId: DataSourceId): boolean;
+    get(sourceId: DataSourceId): DataSourceState | undefined;
+    delete(sourceId: DataSourceId): void;
+    setLoading(sourceId: DataSourceId, isLoading: boolean): void;
+    finalizeAllSources(): void;
+    values(): IterableIterator<DataSourceState>;
+    getHiddenSourceIds(): Set<DataSourceId>;
+    saveMergeSnapshot(sourceId: DataSourceId, rowId: TRowId, existingRow: TRow, previousSourceId: DataSourceId, isNew: boolean, isEdited: boolean): void;
+    /**
+     * Public so commands can re-install merge entries during undo of a remove.
+     */
+    restoreMergeEntry(sourceId: DataSourceId, rowId: TRowId, entry: MergeEntry<TRow>): void;
+    /**
+     * Pure — computes the full removal plan without mutating any state.
+     * Callers run applyRemovalPlan(plan) to commit.
+     */
+    planRemoval(sourceId: DataSourceId): ExtendedRemovalPlan<TRow> | null;
+    /**
+     * Mutates internal state per plan produced by planRemoval.
+     */
+    applyRemovalPlan(plan: ExtendedRemovalPlan<TRow>): void;
     clear(): void;
-    private rebuildRowIdToIndex;
+    private getUniqueName;
 }
 
 /**
- * SnapshotManager — Immutable snapshot construction and listener notification
- * for React's useSyncExternalStore integration.
- *
- * Builds a DataStoreSnapshot object that React components subscribe to via
- * useSyncExternalStore(subscribe, getSnapshot). A new snapshot object is
- * created on every notify() call, which triggers React's shallow comparison
- * and re-renders only when values actually change.
+ * Internal contract: the surface a Scale client exposes to the SDK's data
+ * layer. Implemented by `ScaleClient`. Not part of the public SDK API —
+ * customers configure server mode via `server: { url }` and never see this
+ * type.
+ */
+type ScaleClientApi<TRow extends DataEditorRow = DataEditorRow, TFilters = Record<string, unknown>> = {
+    onQuery: (params: QueryParams<TFilters>) => Promise<QueryResponse<TRow>>;
+    onFilterOptions?: () => Promise<FilterOptionsResponse>;
+    onExport?: (params: ExportParams$1<TFilters>) => Promise<void>;
+    onEdit: (params: EditParams, options?: ServerCallOptions) => Promise<EditResponse | void>;
+    onFileImport?: (params: FileImportParams) => Promise<void>;
+    onRowsImport?: (params: RowsImportParams) => Promise<RowsImportResponse | void>;
+    importChunkSize?: number;
+    onSourceRemove?: (params: SourceRemoveParams) => Promise<void>;
+    onColumnDelete?: (params: ColumnDeleteParams) => Promise<EditResponse | void>;
+    onColumnEdit?: (params: ColumnEditParams) => Promise<EditResponse | void>;
+    findAndReplace?: FindAndReplaceConfig;
+    pageSize?: number;
+    scrollSensitivity?: number;
+};
+
+type ServerDataManagerDeps<TRow extends DataEditorRow = DataEditorRow> = {
+    clear(): void;
+    setLoading(isLoading: boolean): void;
+    registerSource(options: RegisterSourceOptions): DataSourceId;
+    setSourceLoading(sourceId: DataSourceId, isLoading: boolean): void;
+    getLocalRowCount(): number;
+    replaceServerRows(sourceId: DataSourceId, rows: ServerRow<TRow>[], offset: number, counts?: ServerQueryCounts): void;
+    appendServerRows(rows: ServerRow<TRow>[], counts?: ServerQueryCounts): void;
+    prependServerRows(rows: ServerRow<TRow>[], offset: number, counts?: ServerQueryCounts): void;
+    applyServerRowMeta(rows: ServerRow<TRow>[], counts?: ServerQueryCounts): void;
+};
+type FetchDirection = "forward" | "backward" | "jump";
+declare class ServerDataManager<TRow extends DataEditorRow = DataEditorRow> {
+    private _offset;
+    private _totalCount;
+    private _isFetching;
+    private readonly _pageSize;
+    private readonly _maxBufferRows;
+    private _filters;
+    private _sources;
+    private _sort;
+    private _filterOptions;
+    private _filterOptionsFetched;
+    private _abortController;
+    private _syncAbort;
+    private _lastVisibleStart;
+    private _debouncedFetch;
+    private readonly _config;
+    private readonly _dataStoreRef;
+    private readonly _sourceLabel;
+    private _onChanged;
+    constructor(config: ScaleClientApi<TRow>, dataStoreRef: ServerDataManagerDeps<TRow>, sourceLabel: string);
+    get offset(): number;
+    get totalCount(): number | null;
+    get isFetching(): boolean;
+    get pageSize(): number;
+    get maxBufferRows(): number;
+    setOnChanged(callback: () => void): void;
+    setOffset(offset: number): void;
+    setTotalCount(count: number): void;
+    private setFetching;
+    getExcess(currentCount: number, newCount: number): number;
+    shouldFetch(visibleStart: number, visibleEnd: number, loadedCount: number): FetchDirection | null;
+    /**
+     * Full reload — abort in-flight, clear store, fetch first page.
+     * Called on initial load, search/filter/sort changes, and resetFilters.
+     */
+    reload(): void;
+    /**
+     * Scroll-driven pagination with velocity-based debouncing.
+     * Called from CanvasGrid on every scroll event.
+     */
+    handleScroll(visibleStart: number, visibleEnd: number): void;
+    /**
+     * Fetch a single page based on scroll position and current window state.
+     */
+    private fetchPage;
+    /**
+     * Re-query the current viewport and replace row data, metadata, and counts.
+     * Called after successful edits and find-and-replace mutations.
+     * Each call aborts the previous in-flight sync.
+     */
+    syncCurrentView(): void;
+    /**
+     * Merge filter keys into server filter state and reload.
+     * Called by DataStore.setFilters() in server mode and by filter components.
+     */
+    setFilters(filters: Partial<Filters>): void;
+    /**
+     * Set sort state and reload.
+     */
+    setSort(sort: SortState): void;
+    /**
+     * Restrict query to visible sources and reload.
+     * Pass `undefined` to include all sources.
+     */
+    setSources(sources: string[] | undefined): void;
+    /**
+     * Clear all filters and sort, then reload.
+     */
+    resetFilters(): void;
+    /**
+     * One-time fetch of filter option dictionaries for sidebar filter controls.
+     */
+    fetchFilterOptions(): void;
+    getFilterOptions(): FilterOptionsResponse | null;
+    get onEdit(): (params: EditParams, options?: ServerCallOptions) => Promise<EditResponse | void>;
+    get filters(): Record<string, unknown>;
+    get sort(): SortState;
+    get sources(): string[] | undefined;
+    get onSourceRemove(): ((params: SourceRemoveParams) => Promise<void>) | undefined;
+    get onColumnDelete(): ((params: ColumnDeleteParams) => Promise<EditResponse | void>) | undefined;
+    get onColumnEdit(): ((params: ColumnEditParams) => Promise<EditResponse | void>) | undefined;
+    get hasExport(): boolean;
+    private _exportAbortController;
+    export(format: DataEditorFormat, allRows: boolean, rtl: boolean): Promise<void>;
+    clear(): void;
+    destroy(): void;
+}
+
+/**
+ * A post-resolution selection rectangle in stable coordinate space.
+ * Produced by grid-layer resolvers from CellRange[] in grid-index space.
+ * Consumed by DataStore operations and server sync.
+ */
+type SelectionRect = {
+    readonly fields: readonly string[];
+    readonly rowIds: readonly TRowId[];
+};
+
+/**
+ * ServerEditBuilder — Stateless coordinate translator for server-delegated edits.
  *
- * Count tracking has two tiers:
- *   - Visible counts: new/edited/error/empty rows from visible sources only.
- *     Updated incrementally via adjust*() methods on single-row edits, or
- *     recomputed in bulk when _countsDirty is set (after deletes, source changes, etc.).
- *   - Filtered counts: subset of visible counts restricted to filteredRowIds.
- *     Recomputed when _filteredCountsDirty is set (after filter changes).
+ * Converts frontend coordinates (TRowId, column index, grid ranges) into
+ * `EditParams` with `Region[]` that the server can interpret.
  *
- * Batching: multiple operations can be grouped via beginBatch()/endBatch().
- * While batching, notify() calls are deferred — only the outermost endBatch()
- * triggers a single notification, preventing intermediate snapshots from
- * reaching React during multi-step operations (fill handle, batch delete, etc.).
+ * Does NOT call `onEdit`. Only builds params.
+ * DataStore calls the builder, then sends the result to the server.
  *
- * The SnapshotStateReader interface decouples this module from all other modules.
- * DataStore implements the interface by delegating to RowStore, DirtyTracker,
- * FilterEngine, and ValidationStore, so SnapshotManager never imports them directly.
+ * Responsibilities:
+ *   - TRowId → ServerRowId translation via primaryKey
+ *   - Grid index → column ID translation via columns array
+ *   - Filter/sort context attachment from ServerDataManager
  */
 
-type Listener = () => void;
-interface SnapshotStateReader {
-    getRowCount(): number;
-    getFilteredRowIds(): TRowId[] | null;
-    getBaseFilteredRowIds(): TRowId[] | null;
-    getNewRowIds(): ReadonlySet<TRowId>;
-    getEditedRowIds(): ReadonlySet<TRowId>;
-    getRowsWithErrors(): ReadonlySet<TRowId>;
-    getRowsWithEmptyCells(): ReadonlySet<TRowId>;
-    getDeletedCount(): number;
-    isDeleted(id: TRowId): boolean;
-    getSources(): DataSourceState[];
-    isRowVisible(id: TRowId): boolean;
-    canUndo(): boolean;
-    canRedo(): boolean;
-    isLoading(): boolean;
-    isFiltering(): boolean;
-    getVersion(): number;
-    getFilterCriteriaVersion(): number;
-    getFilteredNewCount(ids: TRowId[] | null): number;
-    getFilteredEditedCount(ids: TRowId[] | null): number;
-    getFilteredDirtyCount(ids: TRowId[] | null): number;
-    getFilteredErrorCount(ids: TRowId[] | null): number;
-    getFilteredEmptyCount(ids: TRowId[] | null): number;
-    getErrorMessageCounts(filteredRowIds: TRowId[] | null): Record<string, number>;
-    hasColumnScoping(): boolean;
-    getSortState(): SortState;
-    getShowOnlyDeletedRows(): boolean;
-    /** Server-provided aggregate counts. Present only in server mode. */
-    getServerEditedCount?(): number;
-    getServerNewCount?(): number;
-    getServerErrorCount?(): number;
-    getServerEmptyCount?(): number;
-    getServerDeletedCount?(): number;
+type ServerEditDeps<TRow extends DataEditorRow = DataEditorRow> = {
+    getPrimaryKey: () => string;
+    getRowById: (id: TRowId) => TRow | undefined;
+    getColumnIds: () => string[];
+    getFilters: () => Record<string, unknown>;
+    getSort: () => SortState;
+    getLockedColumns: () => ReadonlyMap<string, ColumnLockMode>;
+};
+declare class ServerEditBuilder<TRow extends DataEditorRow = DataEditorRow> {
+    private readonly _deps;
+    constructor(deps: ServerEditDeps<TRow>);
+    resolveServerRowId(rowId: TRowId): ServerRowId | undefined;
+    buildRegion(rowIds: TRowId[], columnIds: string[]): Region;
+    /**
+     * Collapse rowIds × columnIds into minimal Region[].
+     * - All columns → omit column fields (row-only regions).
+     * - Contiguous columns in schema order → single fromColumn/toColumn span.
+     * - Non-contiguous → one region per contiguous column group.
+     * Rows are expressed as fromRow/toRow using first/last of the provided array.
+     */
+    buildRegions(rowIds: TRowId[], columnIds: string[]): Region[];
+    /**
+     * Collapse columnIds into minimal column-only Region[] (all rows implied).
+     * - All columns → `{ allSelected: true }`.
+     * - Contiguous in schema order → single `{ fromColumn, toColumn }`.
+     * - Non-contiguous → one region per contiguous group.
+     */
+    buildColumnRegions(columnIds: string[]): Region[];
+    /**
+     * Build minimal Region[] from multiple selection rectangles.
+     * Each rect is collapsed independently, preserving disjoint selections.
+     */
+    buildRegionsFromRects(rects: SelectionRect[]): Region[];
+    buildAllSelectedRegion(): Region;
+    buildColumnRegion(columnId: string): Region;
+    buildRowRegion(fromRowId: TRowId, toRowId: TRowId): Region;
+    cellEdit(rowId: TRowId, field: string, value: unknown): EditParams;
+    clear(target: Region[]): EditParams;
+    paste(source: Region[], target: Region[], cut?: boolean): EditParams;
+    pasteExternal(target: Region[], values: unknown[][]): EditParams;
+    fill(source: Region[], target: Region[]): EditParams;
+    transform(target: Region[], transform: TransformParams): EditParams;
+    deleteRows(rowRanges: [TRowId, TRowId][]): EditParams;
+    restoreRows(rowRanges: [TRowId, TRowId][]): EditParams;
+    deleteAllRows(): EditParams;
+    restoreAllRows(): EditParams;
+    insertRow(anchorRowId: TRowId | undefined, position: InsertParams["position"], values: unknown[][], columnIds: string[]): EditParams;
+    /**
+     * Returns null when all columns are selected (caller decides representation).
+     * Otherwise returns contiguous column spans as `{ fromColumn, toColumn }` regions.
+     */
+    private collapseColumns;
+    private viewContext;
 }
-declare class SnapshotManager {
-    private _visibleNewCount;
-    private _visibleEditedCount;
-    private _visibleDirtyCount;
-    private _visibleErrorCount;
-    private _visibleEmptyCount;
-    private _countsDirty;
-    private _filteredDirtyCount;
-    private _filteredNewCount;
-    private _filteredEditedCount;
-    private _filteredErrorCount;
-    private _filteredEmptyCount;
-    private _errorMessageCounts;
-    private _filteredCountsDirty;
-    private _phase;
-    private _processingInfo;
-    private snapshot;
-    private listeners;
-    private batchDepth;
-    private pendingNotify;
-    get countsDirty(): boolean;
-    markCountsDirty(): void;
-    markFilteredCountsDirty(): void;
-    adjustVisibleErrorCount(delta: number): void;
-    adjustVisibleNewCount(delta: number): void;
-    adjustVisibleEditedCount(delta: number): void;
-    adjustVisibleDirtyCount(delta: number): void;
-    subscribe: (listener: Listener) => (() => void);
-    getSnapshot: () => DataStoreSnapshot;
-    isBatching(): boolean;
-    beginBatch(): boolean;
-    endBatch(): boolean;
-    setPhase(phase: ProcessingPhase, info?: ProcessingInfo): void;
-    getPhase(): ProcessingPhase;
-    notify(reader: SnapshotStateReader): void;
-    clear(): void;
-    clearListeners(): void;
-    private recomputeVisibleCounts;
-    private recomputeFilteredCounts;
+
+/**
+ * Categories of internal errors surfaced through the `onError` callback.
+ *
+ * Existing categories cover client-side failures. `scale.*` codes cover
+ * server-mode (Updog Scale) failures. `license.*` codes cover license
+ * validation failures (previously a separate `LicenseErrorCode` enum).
+ */
+type UpdogErrorCode = "PARSE_ERROR" | "RENDER_ERROR" | "TRANSFORM_ERROR" | "VALIDATION_ERROR" | "WORKER_ERROR" | "COMMAND_ERROR" | "OPERATION_ERROR" | "license.invalid" | "license.missing" | "license.domain_not_allowed" | "license.subscription_inactive" | "license.trial_expired" | "scale.bootstrap_failed" | "scale.workspace_lost" | "scale.unreachable" | "scale.server_error";
+/**
+ * An internal error caught by the SDK and passed to `onError`. The SDK
+ * recovers gracefully where possible — `onError` is for your logging and
+ * monitoring (Sentry, Datadog, etc.).
+ *
+ * @example
+ * ```ts
+ * onError={(error) => {
+ *   Sentry.captureException(error.originalError ?? error, {
+ *     tags: { code: error.code, source: error.source },
+ *   });
+ * }}
+ * ```
+ */
+type UpdogError = {
+    /** The error category. */
+    code: UpdogErrorCode;
+    /** Human-readable description. */
+    message: string;
+    /** Module or subsystem that raised the error. */
+    source: string;
+    /** The underlying thrown value, when available. */
+    originalError?: unknown;
+};
+
+declare class ErrorHandler {
+    private onError?;
+    constructor(onError?: (error: UpdogError) => void);
+    handleError(error: UpdogError): void;
 }
 
 /**
- * ValidationStore — Cell-level validation state with incremental count tracking.
+ * DirtyTracker — Change classification and revert detection for rows.
  *
- * Stores validation results in a two-level map: rowId → fieldId → ValidationResult[].
- * Maintains a running error count and a pre-computed row-level set
- * (_rowsWithErrors) for O(1) "does this row have errors?" checks.
+ * Every row falls into one of three categories:
+ *   - Clean    — matches the backend; not tracked here at all
+ *   - New      — created locally (CSV import or manual add), never existed on the backend
+ *   - Edited   — exists on the backend but has been modified locally
  *
- * The key design decision is the ValidationDelta return type from setCellValidation().
- * Instead of directly triggering notifications, it returns a delta object describing
- * what changed (error count +/- 1, row-level error membership flipped).
- * The caller (DataStore) uses this delta for incremental snapshot count updates,
- * avoiding a full recount on every validation change.
+ * Classification uses inverted tracking via `nonBackendRowIds`: only non-backend
+ * rows (CSV imports, manual adds) are stored in the set. Since backend rows are
+ * the vast majority (~1M), this inverted approach saves ~50MB by assuming any
+ * row NOT in the set is a backend row.
+ *   - First edit of a backend row → "edited", original row is snapshotted
+ *   - First edit of a non-backend row → "new"
  *
- * Empty cell tracking (_rowsWithEmptyCells) is separate from validation — it
- * tracks rows where any visible column has a null/empty value, used by the
- * "show only rows with empty cells" filter.
+ * Smart revert: after every edit, the current row is compared field-by-field
+ * against the snapshot. If all fields match the original, the row silently
+ * reverts to "clean" — no dirty flag, no undo entry needed. This lets users
+ * fix typos by simply typing the original value back.
+ *
+ * Merge snapshots: when a CSV import overwrites an existing row, the original
+ * data + classification is saved so it can be restored if the source is removed.
  */
 
-type ValidationDelta = {
-    errorDelta: number;
-    rowErrorChanged: boolean;
-};
-type IValidationStore = {
-    setCellValidation(rowId: TRowId, field: string, result: ValidationResult): ValidationDelta;
-    getCellValidation(rowId: TRowId, field: string): ValidationResult;
-    clearRowValidations(rowId: TRowId): void;
-    hasRowErrors(rowId: TRowId): boolean;
-    getRowsWithErrors(): ReadonlySet<TRowId>;
-    getRowsWithEmptyCells(): ReadonlySet<TRowId>;
-    hasEmptyCells(rowId: TRowId): boolean;
-    checkRowEmptyCells(rowId: TRowId, row: Record<string, unknown> | undefined, fieldOrder: string[]): boolean;
-    deleteRowTracking(rowId: TRowId): void;
-    getErrorCount(): number;
-    getRowValidations(rowId: TRowId): Map<string, NonNullable<ValidationResult>> | undefined;
-    getErrorMessageToRows(): ReadonlyMap<string, ReadonlySet<TRowId>>;
+type IDirtyTracker<TRow extends DataEditorRow = DataEditorRow> = {
+    markDeleted(id: TRowId): void;
+    unmarkDeleted(id: TRowId): void;
+    isDeleted(id: TRowId): boolean;
+    getDeletedRowIds(): ReadonlySet<TRowId>;
+    deletedCount(): number;
+    isDefaultSourceRow(id: TRowId): boolean;
+    isNew(id: TRowId): boolean;
+    isEdited(id: TRowId): boolean;
+    isCellDirty(id: TRowId, field: string, currentRow: TRow | undefined): boolean;
+    getOriginalCellValue(id: TRowId, field: string): unknown | undefined;
+    getOriginalRow(id: TRowId): TRow | undefined;
+    hasOriginalRow(id: TRowId): boolean;
+    trackNonBackendRow(id: TRowId): void;
+    markNew(id: TRowId): void;
+    markEdited(id: TRowId): void;
+    snapshotOriginal(id: TRowId, row: TRow): void;
+    classifyOnFirstEdit(id: TRowId, row: TRow): void;
+    checkRevert(id: TRowId, currentRow: TRow): {
+        wasNew: boolean;
+        wasEdited: boolean;
+    };
+    removeTracking(id: TRowId): void;
+    getNewRowIds(): ReadonlySet<TRowId>;
+    getEditedRowIds(): ReadonlySet<TRowId>;
+    getMergeSnapshot(id: TRowId): {
+        isNew: boolean;
+        isEdited: boolean;
+    };
+    restoreMergeClassification(id: TRowId, isNew: boolean, isEdited: boolean): void;
     clear(): void;
 };
 
-type IValidator<TRow extends DataEditorRow = DataEditorRow> = {
-    validateRow(rowId: TRowId): void;
-    validateRows(rows: TRow[], rowIds: TRowId[]): void;
-    validateUniqueness(): Promise<void>;
-    validateCell(rowId: TRowId, field: string, oldValue?: unknown, _visited?: Set<string>): void;
-    revalidateColumn(field: string): void;
-    validateColumn(field: string, oldValues: ReadonlyMap<TRowId, unknown>): void;
-    revalidateColumnChunked(field: string, oldValues: ReadonlyMap<TRowId, unknown>, newValues: ReadonlyMap<TRowId, unknown>, processor: ChunkedProcessor<TRowId>, onComplete: () => void): void;
-    removeRow(rowId: TRowId): void;
-    destroy(): void;
-};
-
-type IValueIndex<TRow extends DataEditorRow = DataEditorRow> = {
-    setTrackedFields(fields: Set<string>): void;
-    addRow(row: TRow): void;
-    removeRow(row: TRow): void;
-    updateField(field: string, oldValue: unknown, newValue: unknown): void;
-    rebuild(rows: Iterable<TRow>): void;
-    getValues(field: string): ReadonlyMap<string, number>;
-    getVersion(): number;
-    isTracked(field: string): boolean;
-    getMinMax(field: string): {
-        min: number;
-        max: number;
-    } | null;
-    getDateMinMax(field: string): {
-        min: string;
-        max: string;
-    } | null;
-    bumpVersion(): void;
-};
-
-type RowEntry<TRow extends DataEditorRow> = {
-    rowId: TRowId;
-    row: TRow;
-    sourceId: DataSourceId;
-    isNew: boolean;
-    isEdited: boolean;
-    isDeleted: boolean;
-    originalRow?: TRow;
-};
-type OverlayEntry<TRow extends DataEditorRow> = {
-    rowId: TRowId;
-    displayValue: TRow;
-};
-type SourceSnapshot<TRow extends DataEditorRow> = {
-    state: DataSourceState;
-    ownedRows: RowEntry<TRow>[];
-    overlayRows: OverlayEntry<TRow>[];
-    rowIds: TRowId[];
-    plan: ExtendedRemovalPlan<TRow>;
-};
-type SourceLifecycleHost<TRow extends DataEditorRow> = {
-    getValidator: () => IValidator<TRow> | null;
-    pushCommand: (cmd: Command<TRow>, cost?: number) => number;
-    notify: () => void;
-    isServerStrategy: () => boolean;
-    checkRowEmptyCells: (rowId: TRowId) => void;
-    clearRowValidations: (rowId: TRowId) => void;
-};
-declare class SourceLifecycle<TRow extends DataEditorRow = DataEditorRow> {
-    private readonly sourceManager;
-    private readonly rowStore;
-    private readonly dirtyTracker;
-    private readonly filterEngine;
-    private readonly valueIndex;
-    private readonly validationStore;
-    private readonly snapshotManager;
-    private readonly host;
-    private readonly importTrackers;
-    constructor(sourceManager: SourceManager<TRow>, rowStore: RowStore<TRow>, dirtyTracker: IDirtyTracker<TRow>, filterEngine: IFilterEngine<TRow>, valueIndex: IValueIndex<TRow>, validationStore: IValidationStore, snapshotManager: SnapshotManager, host: SourceLifecycleHost<TRow>);
-    plan(sourceId: DataSourceId): ExtendedRemovalPlan<TRow> | null;
-    capture(sourceId: DataSourceId): SourceSnapshot<TRow> | null;
-    apply(plan: ExtendedRemovalPlan<TRow>): void;
-    private applyToStores;
-    restore(snapshot: SourceSnapshot<TRow>): void;
-    register(options: RegisterSourceOptions): DataSourceId;
-    trackAppend(sourceId: DataSourceId, rowIds: TRowId[], rows: TRow[], usedIdMap: boolean): void;
-    trackPrimaryKey(sourceId: DataSourceId, primaryKey: keyof TRow): void;
-    finalize(sourceId: DataSourceId): Promise<void>;
-    private pushImportCommandIfTracked;
-    private removeInternal;
-    remove(sourceId: DataSourceId): Promise<SourceSnapshot<TRow> | null>;
-    finalizeAllSources(): void;
+interface FlagReader {
+    hasError(id: TRowId): boolean;
+    isNew(id: TRowId): boolean;
+    isEdited(id: TRowId): boolean;
+    hasEmptyCells(id: TRowId): boolean;
+    isDeleted(id: TRowId): boolean;
+    hasDeletedRows(): boolean;
+    getSourceId(id: TRowId): string;
+    getErrorBitmask(id: TRowId, fieldOrder: string[], wordIdx: number): number;
+    getEditedBitmask(id: TRowId, fieldOrder: string[], wordIdx: number): number;
+    getErrorMessageToRows(): ReadonlyMap<string, ReadonlySet<TRowId>>;
+    getRowValidations(id: TRowId): Map<string, NonNullable<ValidationResult>> | undefined;
+}
+interface FilterRowReader<TRow extends DataEditorRow = DataEditorRow> {
+    getRowIds(): TRowId[];
+    getRowById(id: TRowId): TRow | undefined;
+    getHiddenSourceIds(): Set<DataSourceId>;
 }
+type IFilterEngine<TRow extends DataEditorRow = DataEditorRow> = {
+    getFilteredRowIds(): TRowId[] | null;
+    getBaseFilteredRowIds(): TRowId[] | null;
+    getFilterVersion(): number;
+    getFilterCriteriaVersion(): number;
+    isFiltering(): boolean;
+    getFilters(): Filters;
+    getFieldOrder(): string[];
+    getWordsPerRow(): number;
+    getShowOnlyDeletedRows(): boolean;
+    getSortState(): SortState;
+    setReaders(rowReader: FilterRowReader<TRow>, flagReader: FlagReader): void;
+    setColumns(columns: DataEditorColumn[]): void;
+    setFilters(filters: Partial<Filters>): void;
+    setSortState(state: SortState, sortType?: SortType, locales?: string[]): Promise<void>;
+    updateRowText(rowId: TRowId, row: TRow): void;
+    updateRowsText(rows: {
+        id: TRowId;
+        row: TRow;
+    }[]): void;
+    deleteRowTextCache(rowId: TRowId): void;
+    clearRowTextCacheAll(): void;
+    setRowTextCache(rowId: TRowId, row: TRow): void;
+    rebuild(): void;
+    refilterAfterColumnsChange(): void;
+    notifyRowsAdded(ids: TRowId[]): void;
+    notifyRowsDeleted(deletedIds: TRowId[]): void;
+    notifyRowsInserted(restoredIds: TRowId[], positions: number[]): void;
+    refilterAfterSourceToggle(sourceId: DataSourceId, isVisible: boolean): void;
+    refilterAfterFlagChange(): void;
+    flushPendingFlags(): void;
+    markFlagsDirty(): void;
+    testRowAgainstFilters(rowId: TRowId, row: TRow, flagReader: FlagReader, hiddenSourceIds: Set<DataSourceId>): boolean;
+    getAllRowIdsSorted(rowReader: FilterRowReader<TRow>): Promise<TRowId[]>;
+    clear(): void;
+    destroy(): void;
+};
 
 /**
- * Fill-level delta computations.
+ * RowStore — Row storage with dual-access pattern for the grid engine.
  *
- * Pure functions that compute ColumnDelta[] for fill handle operations.
- * Zero side effects — take a spec + row reader, return deltas.
+ * Maintains two parallel structures:
+ *   - (TRow | undefined)[]  → O(1) lookup by stable internal ID (rows[id])
+ *   - TRowId[]              → O(1) lookup by visual index (required by the grid)
  *
- * buildFillSpec()       — reads source values once, builds tiling index
- * computeFillDeltas()   — processes a chunk of target rows against the spec
+ * The grid calls getRow(index) on every frame, so index-based access must be
+ * instant. Filtered views are supported by passing an alternate ID array
+ * (filteredIds) to the access methods — the store itself is unaware of filters.
  *
- * Fill uses a tiling pattern: source values repeat cyclically.
- * For row r in fill range: srcRow = r % sourceHeight.
- * For col c in fill range: srcCol = c % sourceWidth.
+ * An inverted index (rowId → visual index) is lazily rebuilt on demand for
+ * O(1) reverse lookups (e.g., scrolling to a specific row after undo).
+ *
+ * Internal row IDs are auto-generated as sequential numbers (1, 2, 3, …).
+ * Using a plain array indexed by ID eliminates Map hash table overhead
+ * (~10MB saved at 1M rows). Deleted slots are set to undefined (not delete)
+ * to keep V8 in HOLEY_ELEMENTS mode.
  */
 
-type FillSpec = {
-    /** 2D source grid: sourceValues[row][col]. Read once — source region is always small. */
-    sourceValues: unknown[][];
-    sourceHeight: number;
-    sourceWidth: number;
-    /** Column IDs for the fill target columns. */
-    fields: string[];
-    /** Target rowId → position within the fill range, for tiling modulo. */
-    rowIdToFillIndex: ReadonlyMap<TRowId, number>;
-};
-
-type FormulaCellContext = {
-    value: unknown;
-    field: string;
-    rowId: TRowId;
-    getField: (field: string) => unknown;
-    /**
-     * Positional arguments for expression-compiled formulas.
-     * Populated by the expression evaluator when invoking multi-arg function
-     * calls. Single-arg formulas (UPPER, TRIM, etc.) still read from `value`.
-     * Undefined for all non-expression call sites — existing code is unaffected.
-     */
-    args?: readonly unknown[];
-};
-type FormulaParamType = "string" | "number" | "boolean" | "select";
-type FormulaParam = {
-    name: string;
-    label: string;
-    type: FormulaParamType;
-    required?: boolean;
-    defaultValue?: unknown;
-    options?: Array<{
-        id: string;
-        text: string;
-    }>;
-};
-type ColumnInputKind = "single" | "multiple";
-type ColumnInput = {
-    name: string;
-    label: string;
-    kind: ColumnInputKind;
-    required?: boolean;
-};
-type FormulaCategory = "text" | "number" | "logic" | "custom";
-type FormulaArity = {
-    /** Minimum number of positional arguments. 0 means "callable with no args". */
-    min: number;
-    /** Maximum number of positional arguments. Use Number.POSITIVE_INFINITY for variadic. */
-    max: number;
-};
-type FormulaBase = {
-    name: string;
-    label: string;
-    category: FormulaCategory;
-    description?: string;
-    columns?: ColumnInput[];
-    params: FormulaParam[];
-    /**
-     * The call signature of this formula when invoked from the expression
-     * language. Required. For shortcut formulas (UPPER, TRIM, ...) use
-     * { min: 1, max: 1 }. For CLEAR use { min: 0, max: 0 }. For MERGE use
-     * { min: 2, max: Number.POSITIVE_INFINITY }.
-     */
-    arity: FormulaArity;
-    /** Parameter signature shown in autocomplete, without the function name. e.g. "(text, count)" */
-    syntax?: string;
-    /**
-     * Whether this formula may be invoked from the expression parser.
-     * Defaults to true when omitted. MERGE and SPLIT set this to false
-     * because they have dedicated modals that supply their non-expression
-     * params (column lists, separator, ...).
-     */
-    expressionCallable?: boolean;
-};
-type CellFormula = FormulaBase & {
-    kind: "cell";
-    compute: (ctx: FormulaCellContext, params: Record<string, unknown>) => unknown;
-};
-type RowFormula = FormulaBase & {
-    kind: "row";
-    targetFields: (params: Record<string, unknown>) => string[];
-    compute: (ctx: FormulaCellContext, params: Record<string, unknown>) => Record<string, unknown>;
-};
-type FormulaDefinition = CellFormula | RowFormula;
-
-declare class FormulaRegistry {
-    private readonly formulas;
-    register(formula: FormulaDefinition): void;
-    get(name: string): FormulaDefinition | undefined;
-    getAll(): FormulaDefinition[];
-    getByCategory(category: string): FormulaDefinition[];
-    getExpressionCallable(): FormulaDefinition[];
+declare class RowStore<TRow extends DataEditorRow = DataEditorRow> {
+    private rows;
+    private rowIds;
+    private rowIdCounter;
+    private rowIdToIndex;
+    private _rowIndexDirty;
+    nextRowId(): TRowId;
+    getRow(index: number, filteredIds: TRowId[] | null): TRow | undefined;
+    getRowById(id: TRowId): TRow | undefined;
+    getRowId(index: number, filteredIds: TRowId[] | null): TRowId | undefined;
+    getRowIndex(rowId: TRowId, filteredIds: TRowId[] | null): number;
+    getRowIds(): TRowId[];
+    getRowCount(): number;
+    allRows(): IterableIterator<TRow>;
+    hasRow(id: TRowId): boolean;
+    setRow(id: TRowId, row: TRow): void;
+    deleteRow(id: TRowId): void;
+    pushRowId(id: TRowId): void;
+    spliceRowId(pos: number, id: TRowId): void;
+    removeRowId(id: TRowId): void;
+    filterRowIds(predicate: (id: TRowId) => boolean): void;
+    trimFromStart(count: number): TRowId[];
+    trimFromEnd(count: number): TRowId[];
+    unshiftRowIds(ids: TRowId[]): void;
+    invalidateIndex(): void;
+    clear(): void;
+    private rebuildRowIdToIndex;
 }
 
 /**
- * Paste-level delta computations.
+ * SnapshotManager — Immutable snapshot construction and listener notification
+ * for React's useSyncExternalStore integration.
  *
- * Pure functions that compute ColumnDelta[] for paste operations.
- * Zero side effects — take a spec + row reader, return deltas.
+ * Builds a DataStoreSnapshot object that React components subscribe to via
+ * useSyncExternalStore(subscribe, getSnapshot). A new snapshot object is
+ * created on every notify() call, which triggers React's shallow comparison
+ * and re-renders only when values actually change.
  *
- * buildPasteSpec()       — pre-resolves the source→target row mapping and column metadata
- * computePasteDeltas()   — processes a chunk of target rows against the spec
+ * Count tracking has two tiers:
+ *   - Visible counts: new/edited/error/empty rows from visible sources only.
+ *     Updated incrementally via adjust*() methods on single-row edits, or
+ *     recomputed in bulk when _countsDirty is set (after deletes, source changes, etc.).
+ *   - Filtered counts: subset of visible counts restricted to filteredRowIds.
+ *     Recomputed when _filteredCountsDirty is set (after filter changes).
  *
- * Designed for the same chunked execution pattern as columnTransforms:
- *   - DataStore builds the spec once
- *   - Small datasets: call computePasteDeltas() once with all target rows
- *   - Large datasets: orchestrator calls computePasteDeltas() per chunk
+ * Batching: multiple operations can be grouped via beginBatch()/endBatch().
+ * While batching, notify() calls are deferred — only the outermost endBatch()
+ * triggers a single notification, preventing intermediate snapshots from
+ * reaching React during multi-step operations (fill handle, batch delete, etc.).
+ *
+ * The SnapshotStateReader interface decouples this module from all other modules.
+ * DataStore implements the interface by delegating to RowStore, DirtyTracker,
+ * FilterEngine, and ValidationStore, so SnapshotManager never imports them directly.
  */
 
-type PasteSpec = {
-    sourceColumnIds: string[];
-    targetColumnIds: string[];
-    targetToSource: ReadonlyMap<TRowId, TRowId>;
-    selectOptionsMap: ReadonlyMap<string, ReadonlySet<string>>;
-    skipColumnIndices: ReadonlySet<number>;
-    isCut: boolean;
-};
+type Listener = () => void;
+interface SnapshotStateReader {
+    getRowCount(): number;
+    getFilteredRowIds(): TRowId[] | null;
+    getBaseFilteredRowIds(): TRowId[] | null;
+    getNewRowIds(): ReadonlySet<TRowId>;
+    getEditedRowIds(): ReadonlySet<TRowId>;
+    getRowsWithErrors(): ReadonlySet<TRowId>;
+    getRowsWithEmptyCells(): ReadonlySet<TRowId>;
+    getDeletedCount(): number;
+    isDeleted(id: TRowId): boolean;
+    getSources(): DataSourceState[];
+    isRowVisible(id: TRowId): boolean;
+    canUndo(): boolean;
+    canRedo(): boolean;
+    isLoading(): boolean;
+    isFiltering(): boolean;
+    getVersion(): number;
+    getFilterCriteriaVersion(): number;
+    getFilteredNewCount(ids: TRowId[] | null): number;
+    getFilteredEditedCount(ids: TRowId[] | null): number;
+    getFilteredDirtyCount(ids: TRowId[] | null): number;
+    getFilteredErrorCount(ids: TRowId[] | null): number;
+    getFilteredEmptyCount(ids: TRowId[] | null): number;
+    getErrorMessageCounts(filteredRowIds: TRowId[] | null): Record<string, number>;
+    hasColumnScoping(): boolean;
+    getSortState(): SortState;
+    getShowOnlyDeletedRows(): boolean;
+    /** Server-provided aggregate counts. Present only in server mode. */
+    getServerEditedCount?(): number;
+    getServerNewCount?(): number;
+    getServerErrorCount?(): number;
+    getServerEmptyCount?(): number;
+    getServerDeletedCount?(): number;
+}
+declare class SnapshotManager {
+    private _visibleNewCount;
+    private _visibleEditedCount;
+    private _visibleDirtyCount;
+    private _visibleErrorCount;
+    private _visibleEmptyCount;
+    private _countsDirty;
+    private _filteredDirtyCount;
+    private _filteredNewCount;
+    private _filteredEditedCount;
+    private _filteredErrorCount;
+    private _filteredEmptyCount;
+    private _errorMessageCounts;
+    private _filteredCountsDirty;
+    private _phase;
+    private _processingInfo;
+    private snapshot;
+    private listeners;
+    private batchDepth;
+    private pendingNotify;
+    get countsDirty(): boolean;
+    markCountsDirty(): void;
+    markFilteredCountsDirty(): void;
+    adjustVisibleErrorCount(delta: number): void;
+    adjustVisibleNewCount(delta: number): void;
+    adjustVisibleEditedCount(delta: number): void;
+    adjustVisibleDirtyCount(delta: number): void;
+    subscribe: (listener: Listener) => (() => void);
+    getSnapshot: () => DataStoreSnapshot;
+    isBatching(): boolean;
+    beginBatch(): boolean;
+    endBatch(): boolean;
+    setPhase(phase: ProcessingPhase, info?: ProcessingInfo): void;
+    getPhase(): ProcessingPhase;
+    notify(reader: SnapshotStateReader): void;
+    clear(): void;
+    clearListeners(): void;
+    private recomputeVisibleCounts;
+    private recomputeFilteredCounts;
+}
 
 /**
- * Base row shape. Each key is a column ID, each value is the cell data.
- * Extend this with your own type via the `<DataEditor<TRow>>` generic for
- * type-safe column access. When the generic is omitted, rows are typed as
- * `Record<string, unknown>`.
+ * ValidationStore — Cell-level validation state with incremental count tracking.
  *
- * @example
- * ```ts
- * type Employee = { id: string; name: string; email: string };
- * <DataEditor<Employee> columns={...} primaryKey="id" />
- * ```
- */
-type DataEditorRow = Record<string, unknown>;
-/** Sort direction. */
-type SortDirection = "asc" | "desc";
-/** Current sort state. `null` means no active sort. */
-type SortState = {
-    columnId: string;
-    direction: SortDirection;
-} | null;
-type Filters = {
-    search: string;
-    matchCase: boolean;
-    matchEntireCell: boolean;
-    errorMessageFilters: string[];
-    showOnlyNewRows: boolean;
-    showOnlyEditedRows: boolean;
-    showOnlyEmptyCells: boolean;
-    /** When true, show only rows flagged for deletion (bin mode). All other filters are bypassed. */
-    showOnlyDeletedRows: boolean;
-    filterColumns: string[] | null;
-    /** Per-column value filters. Key = column ID, value = allowed display-formatted strings. */
-    columnValueFilters: Record<string, string[]>;
-    /** Per-column numeric range filters. Key = column ID. */
-    columnRangeFilters: Record<string, {
-        min?: number;
-        max?: number;
-    }>;
-    /** Per-column date range filters. Key = column ID, values are ISO date strings (YYYY-MM-DD). */
-    columnDateRangeFilters: Record<string, {
-        min?: string;
-        max?: string;
-    }>;
-};
-
-/**
- * A single operation the LLM wants to apply to rows in the current filtered view.
+ * Stores validation results in a two-level map: rowId → fieldId → ValidationResult[].
+ * Maintains a running error count and a pre-computed row-level set
+ * (_rowsWithErrors) for O(1) "does this row have errors?" checks.
  *
- * - `edit` — `fn` is `(r, ctx) => void`. Mutates `r` in place. Changed fields
- *   become column deltas. Rows with no changes are no-ops.
- * - `delete` — `fn` is `(r, ctx) => boolean`. Truthy means "flag this row for
- *   deletion". Soft delete via `DeleteRowCommand`.
- */
-type ChatOp = {
-    action: "edit";
-    fn: string;
-} | {
-    action: "delete";
-    fn: string;
-};
-/**
- * A single chunk in the stream returned from `DataEditorChat.onMessage`.
+ * The key design decision is the ValidationDelta return type from setCellValidation().
+ * Instead of directly triggering notifications, it returns a delta object describing
+ * what changed (error count +/- 1, row-level error membership flipped).
+ * The caller (DataStore) uses this delta for incremental snapshot count updates,
+ * avoiding a full recount on every validation change.
  *
- * - `status` — progress message shown while processing (e.g. "Analyzing 500 rows...").
- * - `message` — chat reply shown to the user.
- * - `rows` — updated rows to apply to the grid. Matched by `primaryKey`.
- * - `ops` — array of per-row operations (edits and/or deletes) to apply in order.
+ * Empty cell tracking (_rowsWithEmptyCells) is separate from validation — it
+ * tracks rows where any visible column has a null/empty value, used by the
+ * "show only rows with empty cells" filter.
  */
-type ChatResponseChunk<TRow extends DataEditorRow = DataEditorRow> = {
-    type: "status";
-    content: string;
-} | {
-    type: "message";
-    content: string;
-} | {
-    type: "rows";
-    content: TRow[];
-} | {
-    type: "ops";
-    content: ChatOp[];
+
+type ValidationDelta = {
+    errorDelta: number;
+    rowErrorChanged: boolean;
 };
-/** Status of a row in the chat sample, relative to its origin snapshot. */
-type ChatRowStatus = "new" | "edited" | "original";
-/** A sample row handed to the chat callback, with its current status and validation errors. */
-type ChatRow<TRow extends DataEditorRow = DataEditorRow> = {
-    /** Row data keyed by column ID. */
-    data: TRow;
-    /** Whether the row was newly added, edited, or is unchanged. */
-    status: ChatRowStatus;
-    /** Validation errors keyed by column ID. */
-    errors: Record<string, string[]>;
-    /** The source this row belongs to. */
-    source: string;
+type IValidationStore = {
+    setCellValidation(rowId: TRowId, field: string, result: ValidationResult): ValidationDelta;
+    getCellValidation(rowId: TRowId, field: string): ValidationResult;
+    clearRowValidations(rowId: TRowId): void;
+    hasRowErrors(rowId: TRowId): boolean;
+    getRowsWithErrors(): ReadonlySet<TRowId>;
+    getRowsWithEmptyCells(): ReadonlySet<TRowId>;
+    hasEmptyCells(rowId: TRowId): boolean;
+    checkRowEmptyCells(rowId: TRowId, row: Record<string, unknown> | undefined, fieldOrder: string[]): boolean;
+    deleteRowTracking(rowId: TRowId): void;
+    getErrorCount(): number;
+    getRowValidations(rowId: TRowId): Map<string, NonNullable<ValidationResult>> | undefined;
+    getErrorMessageToRows(): ReadonlyMap<string, ReadonlySet<TRowId>>;
+    clear(): void;
 };
-/** Aggregated error count across the current view, grouped by field and message. */
-type ChatErrorSummary = {
-    /** Column ID where the error occurred. */
-    field: string;
-    /** The validation message. */
-    message: string;
-    /** How many rows hit this error. */
-    count: number;
-    /** A few example values that triggered the error. */
-    examples: string[];
+
+type IValidator<TRow extends DataEditorRow = DataEditorRow> = {
+    validateRow(rowId: TRowId): void;
+    validateRows(rows: TRow[], rowIds: TRowId[]): void;
+    validateUniqueness(): Promise<void>;
+    validateCell(rowId: TRowId, field: string, oldValue?: unknown, _visited?: Set<string>): void;
+    revalidateColumn(field: string): void;
+    validateColumn(field: string, oldValues: ReadonlyMap<TRowId, unknown>): void;
+    revalidateColumnChunked(field: string, oldValues: ReadonlyMap<TRowId, unknown>, newValues: ReadonlyMap<TRowId, unknown>, processor: ChunkedProcessor<TRowId>, onComplete: () => void): void;
+    removeRow(rowId: TRowId): void;
+    destroy(): void;
 };
-/**
- * Context about the current dataset, passed to `loadSuggestions` and extended
- * into `ChatContext` for `onMessage`.
- */
-type ChatDataContext<TRow extends DataEditorRow = DataEditorRow> = {
-    /** Full column definitions. */
-    columns: DataEditorColumn[];
-    /** Row identifier field. */
-    primaryKey: keyof TRow;
-    /** Total rows in the dataset. */
-    totalRowCount: number;
-    /** Rows in the current filtered view. */
-    filteredRowCount: number;
-    /** Sample rows, with status and errors. Size controlled by `sampleSize`. */
-    sample: ChatRow<TRow>[];
-    /** Aggregated error counts by field and message. */
-    errorSummary: ChatErrorSummary[];
-    /** Access all rows. Use for full-dataset operations. */
-    getRows: () => ChatRow<TRow>[];
+
+type IValueIndex<TRow extends DataEditorRow = DataEditorRow> = {
+    setTrackedFields(fields: Set<string>): void;
+    addRow(row: TRow): void;
+    removeRow(row: TRow): void;
+    updateField(field: string, oldValue: unknown, newValue: unknown): void;
+    rebuild(rows: Iterable<TRow>): void;
+    getValues(field: string): ReadonlyMap<string, number>;
+    getVersion(): number;
+    isTracked(field: string): boolean;
+    getMinMax(field: string): {
+        min: number;
+        max: number;
+    } | null;
+    getDateMinMax(field: string): {
+        min: string;
+        max: string;
+    } | null;
+    bumpVersion(): void;
 };
-/**
- * The full context passed to `DataEditorChat.onMessage` when the user sends
- * a prompt. Includes the prompt itself and all dataset context.
- */
-type ChatContext<TRow extends DataEditorRow = DataEditorRow> = ChatDataContext<TRow> & {
-    /** The user's chat prompt. */
-    message: string;
+
+type RowEntry<TRow extends DataEditorRow> = {
+    rowId: TRowId;
+    row: TRow;
+    sourceId: DataSourceId;
+    isNew: boolean;
+    isEdited: boolean;
+    isDeleted: boolean;
+    originalRow?: TRow;
+};
+type OverlayEntry<TRow extends DataEditorRow> = {
+    rowId: TRowId;
+    displayValue: TRow;
 };
+type SourceSnapshot<TRow extends DataEditorRow> = {
+    state: DataSourceState;
+    ownedRows: RowEntry<TRow>[];
+    overlayRows: OverlayEntry<TRow>[];
+    rowIds: TRowId[];
+    plan: ExtendedRemovalPlan<TRow>;
+};
+type SourceLifecycleHost<TRow extends DataEditorRow> = {
+    getValidator: () => IValidator<TRow> | null;
+    pushCommand: (cmd: Command<TRow>, cost?: number) => number;
+    notify: () => void;
+    isServerStrategy: () => boolean;
+    checkRowEmptyCells: (rowId: TRowId) => void;
+    clearRowValidations: (rowId: TRowId) => void;
+};
+declare class SourceLifecycle<TRow extends DataEditorRow = DataEditorRow> {
+    private readonly sourceManager;
+    private readonly rowStore;
+    private readonly dirtyTracker;
+    private readonly filterEngine;
+    private readonly valueIndex;
+    private readonly validationStore;
+    private readonly snapshotManager;
+    private readonly host;
+    private readonly importTrackers;
+    constructor(sourceManager: SourceManager<TRow>, rowStore: RowStore<TRow>, dirtyTracker: IDirtyTracker<TRow>, filterEngine: IFilterEngine<TRow>, valueIndex: IValueIndex<TRow>, validationStore: IValidationStore, snapshotManager: SnapshotManager, host: SourceLifecycleHost<TRow>);
+    plan(sourceId: DataSourceId): ExtendedRemovalPlan<TRow> | null;
+    capture(sourceId: DataSourceId): SourceSnapshot<TRow> | null;
+    apply(plan: ExtendedRemovalPlan<TRow>): void;
+    private applyToStores;
+    restore(snapshot: SourceSnapshot<TRow>): void;
+    register(options: RegisterSourceOptions): DataSourceId;
+    trackAppend(sourceId: DataSourceId, rowIds: TRowId[], rows: TRow[], usedIdMap: boolean): void;
+    trackPrimaryKey(sourceId: DataSourceId, primaryKey: keyof TRow): void;
+    finalize(sourceId: DataSourceId): Promise<void>;
+    private pushImportCommandIfTracked;
+    private removeInternal;
+    remove(sourceId: DataSourceId): Promise<SourceSnapshot<TRow> | null>;
+    finalizeAllSources(): void;
+}
+
 /**
- * Bring-your-own-AI chat configuration. When provided via the `chat` prop,
- * the editor shows a chat panel alongside the grid. You own the AI
- * integration; the SDK hands you dataset context and renders the streamed
- * response.
+ * Fill-level delta computations.
  *
- * @example
- * ```ts
- * chat={{
- *   sampleSize: 50,
- *   onMessage: async function* (context) {
- *     yield { type: "status", content: "Thinking..." };
- *     const res = await fetch("/api/ai", {
- *       method: "POST",
- *       body: JSON.stringify({
- *         prompt: context.message,
- *         columns: context.columns,
- *         sample: context.sample.map(r => r.data),
- *         errors: context.errorSummary,
- *       }),
- *     }).then(r => r.json());
- *     yield { type: "rows", content: res.updatedRows };
- *     yield { type: "ops", content: res.ops };
- *     yield { type: "message", content: res.reply };
- *   },
- * }}
- * ```
+ * Pure functions that compute ColumnDelta[] for fill handle operations.
+ * Zero side effects — take a spec + row reader, return deltas.
+ *
+ * buildFillSpec()       — reads source values once, builds tiling index
+ * computeFillDeltas()   — processes a chunk of target rows against the spec
+ *
+ * Fill uses a tiling pattern: source values repeat cyclically.
+ * For row r in fill range: srcRow = r % sourceHeight.
+ * For col c in fill range: srcCol = c % sourceWidth.
  */
-type DataEditorChat<TRow extends DataEditorRow = DataEditorRow> = {
+
+type FillSpec = {
+    /** 2D source grid: sourceValues[row][col]. Read once — source region is always small. */
+    sourceValues: unknown[][];
+    sourceHeight: number;
+    sourceWidth: number;
+    /** Column IDs for the fill target columns. */
+    fields: string[];
+    /** Target rowId → position within the fill range, for tiling modulo. */
+    rowIdToFillIndex: ReadonlyMap<TRowId, number>;
+};
+
+type FormulaCellContext = {
+    value: unknown;
+    field: string;
+    rowId: TRowId;
+    getField: (field: string) => unknown;
     /**
-     * How many rows to include in the context sample. The SDK picks a
-     * representative slice including rows with errors. When omitted, the SDK decides.
+     * Positional arguments for expression-compiled formulas.
+     * Populated by the expression evaluator when invoking multi-arg function
+     * calls. Single-arg formulas (UPPER, TRIM, etc.) still read from `value`.
+     * Undefined for all non-expression call sites — existing code is unaffected.
      */
-    sampleSize?: number;
-    /** Title shown above the suggestion list when the chat is empty. */
-    emptyTitle?: string;
-    /** How many suggestions to request from `loadSuggestions`. */
-    suggestionsCount?: number;
-    /** Optional prompt generator for the empty-state suggestion chips. */
-    loadSuggestions?: (context: ChatDataContext<TRow>) => Promise<string[]>;
+    args?: readonly unknown[];
+};
+type FormulaParamType = "string" | "number" | "boolean" | "select";
+type FormulaParam = {
+    name: string;
+    label: string;
+    type: FormulaParamType;
+    required?: boolean;
+    defaultValue?: unknown;
+    options?: Array<{
+        id: string;
+        text: string;
+    }>;
+};
+type ColumnInputKind = "single" | "multiple";
+type ColumnInput = {
+    name: string;
+    label: string;
+    kind: ColumnInputKind;
+    required?: boolean;
+};
+type FormulaCategory = "text" | "number" | "logic" | "custom";
+type FormulaArity = {
+    /** Minimum number of positional arguments. 0 means "callable with no args". */
+    min: number;
+    /** Maximum number of positional arguments. Use Number.POSITIVE_INFINITY for variadic. */
+    max: number;
+};
+type FormulaBase = {
+    name: string;
+    label: string;
+    category: FormulaCategory;
+    description?: string;
+    columns?: ColumnInput[];
+    params: FormulaParam[];
     /**
-     * Called when the user sends a message. Receives full dataset context.
-     * Returns an async iterable of response chunks — the SDK streams them
-     * into the UI.
+     * The call signature of this formula when invoked from the expression
+     * language. Required. For shortcut formulas (UPPER, TRIM, ...) use
+     * { min: 1, max: 1 }. For CLEAR use { min: 0, max: 0 }. For MERGE use
+     * { min: 2, max: Number.POSITIVE_INFINITY }.
      */
-    onMessage: (context: ChatContext<TRow>) => AsyncIterable<ChatResponseChunk<TRow>>;
-    /** Called when the user cancels a pending request. Use to abort your API call. */
-    onCancel?: () => void;
-};
-
-type ApplyFormulaOptions = {
+    arity: FormulaArity;
+    /** Parameter signature shown in autocomplete, without the function name. e.g. "(text, count)" */
+    syntax?: string;
     /**
-     * Column IDs to delete AFTER the formula has been applied.
-     * Only dynamic (user-added) columns are actually deleted; schema columns
-     * in this list are silently ignored. All operations (formula + deletes)
-     * are wrapped in a single CompoundCommand so that one Undo call restores
-     * every change, regardless of how many columns were listed.
+     * Whether this formula may be invoked from the expression parser.
+     * Defaults to true when omitted. MERGE and SPLIT set this to false
+     * because they have dedicated modals that supply their non-expression
+     * params (column lists, separator, ...).
      */
-    readonly deleteColumnsAfter?: readonly string[];
+    expressionCallable?: boolean;
 };
-declare class DataStore<TRow extends DataEditorRow = DataEditorRow> {
-    private readonly _mode;
-    isServer(): boolean;
-    isClient(): boolean;
-    private rowStore;
-    readonly formulaRegistry: FormulaRegistry;
-    private _isLoading;
-    private sourceManager;
-    readonly sourceLifecycle: SourceLifecycle<TRow>;
-    private dirtyTracker;
-    private filterEngine;
-    private validationStore;
-    private snapshotManager;
-    private history;
-    private validator;
-    private valueIndex;
-    private serverCounts;
-    private editBuilder;
-    private isUndoRedoing;
-    private pendingBatchCommands;
-    private _version;
-    private _skipNotify;
-    private _bulkMode;
-    private _editedCells;
-    private _primaryKey;
-    /** Columns that are currently locked (pre-locked from schema + user-locked at runtime). */
-    private _lockedColumns;
-    /** Columns locked via schema definition — user cannot unlock these. */
-    private _preLockedColumns;
-    /** Last-known visible row range reported by the canvas scroll handler. */
-    private _viewportStart;
-    private _viewportEnd;
-    private pendingMutations;
-    private editParamsHistory;
-    readonly errorHandler: ErrorHandler;
-    readonly server: ServerDataManager<TRow> | null;
-    private readonly strategy;
-    private readonly serverStrategy;
-    private snapshotReader;
+type CellFormula = FormulaBase & {
+    kind: "cell";
+    compute: (ctx: FormulaCellContext, params: Record<string, unknown>) => unknown;
+};
+type RowFormula = FormulaBase & {
+    kind: "row";
+    targetFields: (params: Record<string, unknown>) => string[];
+    compute: (ctx: FormulaCellContext, params: Record<string, unknown>) => Record<string, unknown>;
+};
+type FormulaDefinition = CellFormula | RowFormula;
+
+declare class FormulaRegistry {
+    private readonly formulas;
+    register(formula: FormulaDefinition): void;
+    get(name: string): FormulaDefinition | undefined;
+    getAll(): FormulaDefinition[];
+    getByCategory(category: string): FormulaDefinition[];
+    getExpressionCallable(): FormulaDefinition[];
+}
+
+/**
+ * Paste-level delta computations.
+ *
+ * Pure functions that compute ColumnDelta[] for paste operations.
+ * Zero side effects — take a spec + row reader, return deltas.
+ *
+ * buildPasteSpec()       — pre-resolves the source→target row mapping and column metadata
+ * computePasteDeltas()   — processes a chunk of target rows against the spec
+ *
+ * Designed for the same chunked execution pattern as columnTransforms:
+ *   - DataStore builds the spec once
+ *   - Small datasets: call computePasteDeltas() once with all target rows
+ *   - Large datasets: orchestrator calls computePasteDeltas() per chunk
+ */
+
+type PasteSpec = {
+    sourceColumnIds: string[];
+    targetColumnIds: string[];
+    targetToSource: ReadonlyMap<TRowId, TRowId>;
+    selectOptionsMap: ReadonlyMap<string, ReadonlySet<string>>;
+    skipColumnIndices: ReadonlySet<number>;
+    isCut: boolean;
+};
+
+/**
+ * A single operation the LLM wants to apply to rows in the current filtered view.
+ *
+ * - `edit` — `fn` is `(r, ctx) => void`. Mutates `r` in place. Changed fields
+ *   become column deltas. Rows with no changes are no-ops.
+ * - `delete` — `fn` is `(r, ctx) => boolean`. Truthy means "flag this row for
+ *   deletion". Soft delete via `DeleteRowCommand`.
+ */
+type ChatOp = {
+    action: "edit";
+    fn: string;
+} | {
+    action: "delete";
+    fn: string;
+};
+/**
+ * A single chunk in the stream returned from `DataEditorChat.onMessage`.
+ *
+ * - `status` — progress message shown while processing (e.g. "Analyzing 500 rows...").
+ * - `message` — chat reply shown to the user.
+ * - `rows` — updated rows to apply to the grid. Matched by `primaryKey`.
+ * - `ops` — array of per-row operations (edits and/or deletes) to apply in order.
+ */
+type ChatResponseChunk<TRow extends DataEditorRow = DataEditorRow> = {
+    type: "status";
+    content: string;
+} | {
+    type: "message";
+    content: string;
+} | {
+    type: "rows";
+    content: TRow[];
+} | {
+    type: "ops";
+    content: ChatOp[];
+};
+/** Status of a row in the chat sample, relative to its origin snapshot. */
+type ChatRowStatus = "new" | "edited" | "original";
+/** A sample row handed to the chat callback, with its current status and validation errors. */
+type ChatRow<TRow extends DataEditorRow = DataEditorRow> = {
+    /** Row data keyed by column ID. */
+    data: TRow;
+    /** Whether the row was newly added, edited, or is unchanged. */
+    status: ChatRowStatus;
+    /** Validation errors keyed by column ID. */
+    errors: Record<string, string[]>;
+    /** The source this row belongs to. */
+    source: string;
+};
+/** Aggregated error count across the current view, grouped by field and message. */
+type ChatErrorSummary = {
+    /** Column ID where the error occurred. */
+    field: string;
+    /** The validation message. */
+    message: string;
+    /** How many rows hit this error. */
+    count: number;
+    /** A few example values that triggered the error. */
+    examples: string[];
+};
+/**
+ * Context about the current dataset, passed to `loadSuggestions` and extended
+ * into `ChatContext` for `onMessage`.
+ */
+type ChatDataContext<TRow extends DataEditorRow = DataEditorRow> = {
+    /** Full column definitions. */
+    columns: DataEditorColumn[];
+    /** Row identifier field. */
+    primaryKey: keyof TRow;
+    /** Total rows in the dataset. */
+    totalRowCount: number;
+    /** Rows in the current filtered view. */
+    filteredRowCount: number;
+    /** Sample rows, with status and errors. Size controlled by `sampleSize`. */
+    sample: ChatRow<TRow>[];
+    /** Aggregated error counts by field and message. */
+    errorSummary: ChatErrorSummary[];
+    /** Access all rows. Use for full-dataset operations. */
+    getRows: () => ChatRow<TRow>[];
+};
+/**
+ * The full context passed to `DataEditorChat.onMessage` when the user sends
+ * a prompt. Includes the prompt itself and all dataset context.
+ */
+type ChatContext<TRow extends DataEditorRow = DataEditorRow> = ChatDataContext<TRow> & {
+    /** The user's chat prompt. */
+    message: string;
+};
+/**
+ * Bring-your-own-AI chat configuration. When provided via the `chat` prop,
+ * the editor shows a chat panel alongside the grid. You own the AI
+ * integration; the SDK hands you dataset context and renders the streamed
+ * response.
+ *
+ * @example
+ * ```ts
+ * chat={{
+ *   sampleSize: 50,
+ *   onMessage: async function* (context) {
+ *     yield { type: "status", content: "Thinking..." };
+ *     const res = await fetch("/api/ai", {
+ *       method: "POST",
+ *       body: JSON.stringify({
+ *         prompt: context.message,
+ *         columns: context.columns,
+ *         sample: context.sample.map(r => r.data),
+ *         errors: context.errorSummary,
+ *       }),
+ *     }).then(r => r.json());
+ *     yield { type: "rows", content: res.updatedRows };
+ *     yield { type: "ops", content: res.ops };
+ *     yield { type: "message", content: res.reply };
+ *   },
+ * }}
+ * ```
+ */
+type DataEditorChat<TRow extends DataEditorRow = DataEditorRow> = {
+    /**
+     * How many rows to include in the context sample. The SDK picks a
+     * representative slice including rows with errors. When omitted, the SDK decides.
+     */
+    sampleSize?: number;
+    /** Title shown above the suggestion list when the chat is empty. */
+    emptyTitle?: string;
+    /** How many suggestions to request from `loadSuggestions`. */
+    suggestionsCount?: number;
+    /** Optional prompt generator for the empty-state suggestion chips. */
+    loadSuggestions?: (context: ChatDataContext<TRow>) => Promise<string[]>;
+    /**
+     * Called when the user sends a message. Receives full dataset context.
+     * Returns an async iterable of response chunks — the SDK streams them
+     * into the UI.
+     */
+    onMessage: (context: ChatContext<TRow>) => AsyncIterable<ChatResponseChunk<TRow>>;
+    /** Called when the user cancels a pending request. Use to abort your API call. */
+    onCancel?: () => void;
+};
+
+type ApplyFormulaOptions = {
+    /**
+     * Column IDs to delete AFTER the formula has been applied.
+     * Only dynamic (user-added) columns are actually deleted; schema columns
+     * in this list are silently ignored. All operations (formula + deletes)
+     * are wrapped in a single CompoundCommand so that one Undo call restores
+     * every change, regardless of how many columns were listed.
+     */
+    readonly deleteColumnsAfter?: readonly string[];
+};
+declare class DataStore<TRow extends DataEditorRow = DataEditorRow> {
+    private readonly _mode;
+    isServer(): boolean;
+    isClient(): boolean;
+    private rowStore;
+    readonly formulaRegistry: FormulaRegistry;
+    private _isLoading;
+    private sourceManager;
+    readonly sourceLifecycle: SourceLifecycle<TRow>;
+    private dirtyTracker;
+    private filterEngine;
+    private validationStore;
+    private snapshotManager;
+    private history;
+    private validator;
+    private valueIndex;
+    private serverCounts;
+    private editBuilder;
+    private isUndoRedoing;
+    private pendingBatchCommands;
+    private _version;
+    private _skipNotify;
+    private _bulkMode;
+    private _editedCells;
+    private _primaryKey;
+    /** Columns that are currently locked (pre-locked from schema + user-locked at runtime). */
+    private _lockedColumns;
+    /** Columns locked via schema definition — user cannot unlock these. */
+    private _preLockedColumns;
+    /** Last-known visible row range reported by the canvas scroll handler. */
+    private _viewportStart;
+    private _viewportEnd;
+    private pendingMutations;
+    private editParamsHistory;
+    readonly errorHandler: ErrorHandler;
+    readonly server: ServerDataManager<TRow> | null;
+    private readonly strategy;
+    private readonly serverStrategy;
+    private snapshotReader;
     private flagReader;
     private buildErrorBitmask;
     private buildEditedBitmask;
@@ -1627,7 +2255,7 @@ declare class DataStore<TRow extends DataEditorRow = DataEditorRow> {
     private bulkMutationHost;
     private orchestrator;
     constructor(mode?: StoreMode, serverInit?: {
-        config: DataEditorServer<TRow>;
+        config: ScaleClientApi<TRow>;
         sourceLabel: string;
     }, errorHandler?: ErrorHandler);
     get mode(): StoreMode;
@@ -1803,726 +2431,164 @@ declare class DataStore<TRow extends DataEditorRow = DataEditorRow> {
      * from `meta.changes` so that `isCellDirty()` and `getOriginalCellValue()`
      * work through the existing DirtyTracker comparison logic.
      */
-    private hydrateServerMeta;
-    private hydrateRowMeta;
-    applyServerRowMeta(serverRows: ServerRow<TRow>[], counts?: ServerQueryCounts): void;
-    clear(): void;
-    destroy(): void;
-    setFilters(filters: Partial<Filters>): void;
-    getFilters(): Filters;
-    setSort(sortState: SortState, sortType?: SortType, locales?: string[]): Promise<void>;
-    handleServerScroll(visibleStart: number, visibleEnd: number): void;
-    reloadServerData(): void;
-    resetFilters(): void;
-    fetchFilterOptions(): void;
-    getFilterOptions(): FilterOptionsResponse | null;
-    get hasServerExport(): boolean;
-    serverExport(format: DataEditorFormat, allRows: boolean, rtl: boolean): Promise<void>;
-    syncWorkerFlags(): void;
-    setCellValidation(rowId: TRowId, field: string, result: ValidationResult): void;
-    getCellValidation(rowId: TRowId, field: string): ValidationResult;
-    private clearRowValidations;
-    updateRow(rowId: TRowId, field: string, value: unknown): void;
-    updateRowDirect(rowId: TRowId, field: string, value: unknown): void;
-    /**
-     * Bulk-write a single column for many rows in one pass.
-     * Skips per-row validation, notification, and snapshot adjustments.
-     * Caller must handle validation (via Validator.revalidateColumn) and notification.
-     */
-    updateColumnDirect(field: string, values: ReadonlyMap<TRowId, unknown>): void;
-    batch(fn: () => void): number | undefined;
-    canUndo(): boolean;
-    getAllRowIds(): readonly TRowId[];
-    undo(): Promise<UndoRedoResult>;
-    private _undoSync;
-    pushCommand(cmd: Command<TRow>, cost?: number): number;
-    removeCommandById(id: number): void;
-    /**
-     * Delegate to ServerStrategy. Called by ActionsDispatcher and ClipboardManager
-     * for non-cell edits (clear, paste, fill, transform).
-     */
-    syncServerEdit(params: EditParams, cmdId: number, revertFn: () => void): void;
-    fireServerEditParams(params: EditParams): void;
-    syncColumnEdit(params: ColumnEditParams, cmdId: number, revertFn: () => void): void;
-    redo(): Promise<UndoRedoResult>;
-    private _redoSync;
-    getOriginalCellValue(rowId: TRowId, field: string): unknown | undefined;
-    isCellDirty(rowId: TRowId, field: string): boolean;
-    hasRowErrors(rowId: TRowId): boolean;
-    hasEmptyCells(rowId: TRowId): boolean;
-    private checkRowEmptyCells;
-    getValidAndInvalidRows(): {
-        valid: TRow[];
-        invalid: TRow[];
-    };
-    getValidRows(): TRow[];
-    getInvalidRows(): TRow[];
-    getResultBySource(): DataEditorResult<TRow>;
-    private isRowVisible;
-    applyFormula(formulaOrName: string | CellFormula, params: Record<string, unknown>, rects: SelectionRect[], options?: ApplyFormulaOptions): Promise<void>;
-    private applyFormulaCompound;
-    private runFormulaWithReturnCommand;
-    private _runFormulaOperation;
-    private captureDeleteColumnSnapshots;
-    private applyDeleteColumnSnapshots;
-    private syncFormulaToServer;
-    private transformWorker;
-    private initTransformWorker;
-    private buildChatOpsCommand;
-    applyChatOps(ops: ChatOp[], ctx: {
-        opts: Record<string, Set<string>>;
-    }, enableDeleteRow: 'all' | 'new' | false): Promise<void>;
-    private filterDeleteIdsByPolicy;
-    private _applyChatOpsViaWorker;
-    private _applyChatOpsSync;
-    private _commitChatOps;
-    applyChatRows(incomingRows: Record<string, unknown>[], primaryKey: string): Promise<void>;
-    private syncChatTransformToServer;
-    private get revertRowReader();
-    revertColumns(fields: string[]): Promise<void>;
-    revertRange(rects: SelectionRect[]): Promise<void>;
-    private _revertInternal;
-    private _buildRevertCommand;
-    private syncRevertToServer;
-    clearColumn(field: string): Promise<void>;
-    clearColumns(fields: string[]): Promise<void>;
-    private syncClearToServer;
-    deleteColumn(columnId: string): Promise<void>;
-    deleteColumns(columnIds: readonly string[]): Promise<void>;
-    clearRange(rects: SelectionRect[]): Promise<void>;
-    private syncRangeClearToServer;
-    pasteChunked(spec: PasteSpec, targetRowIds: TRowId[], targetCell: {
-        rowId: TRowId;
-        field: string;
-    }, onComplete?: (cmdId: number) => void): void;
-    /**
-     * Store-owned paste: cost-gated sync path or chunked orchestrator.
-     * Replaces executePasteWithOverlay + pasteChunked for internal-clipboard paste.
-     */
-    pasteInternal(spec: PasteSpec, targetRowIds: TRowId[], targetCell: {
-        rowId: TRowId;
-        field: string;
-    }, validator?: IValidator<TRow>): Promise<{
-        cmdId: number;
-    } | null>;
-    /**
-     * Store-owned external paste from TSV text (OS clipboard).
-     * Replaces the pasteFromText helper in pasteUtils.
-     */
-    pasteFromText(text: string, pasteRow: number, pasteCol: number, validator?: IValidator<TRow>): Promise<{
-        cmdId: number;
-    } | null>;
-    /**
-     * Store-owned fill: cost-gated sync path or chunked orchestrator.
-     * Replaces fillChunked + the per-caller isHeavy heuristic in ActionsDispatcher.
-     */
-    fillInternal(spec: FillSpec, targetRowIds: TRowId[], targetCell: {
-        rowId: TRowId;
-        field: string;
-    }, onComplete?: (cmdId: number) => void): Promise<{
-        cmdId: number;
-    } | null>;
-    notify(): void;
-}
-
-/**
- * Command interface for undo/redo operations.
- * Each command knows how to apply and revert its changes.
- */
-interface Command<TRow extends DataEditorRow = DataEditorRow> {
-    /** Assigned by CommandHistory.push(). Used by removeById() to target specific commands. */
-    id?: number;
-    redo(store: DataStore<TRow>, validator: IValidator<TRow>): void;
-    undo(store: DataStore<TRow>, validator: IValidator<TRow>): void;
-    readonly description: string;
-    /** Target cell for selection restoration on undo/redo */
-    readonly targetCell: CellLocation;
-}
-
-/**
- * BulkMutationOrchestrator — Viewport-first chunked execution for heavy
- * column operations (split, merge, clear, paste, fill, backspace).
- *
- * When operation cost >= LARGE_OP_CELLS:
- *   1. Viewport rows are applied synchronously (instant visual result)
- *   2. Remaining rows are processed in chunks via requestIdleCallback
- *   3. Validation runs chunked after all mutations complete
- *   4. Command is pushed to history only after everything finishes
- *
- * Communicates with DataStore via BulkMutationHost interface to avoid
- * circular imports. DataStore constructs the host from its own methods.
- */
-
-type ColumnDelta = {
-    field: string;
-    oldValues: Map<TRowId, unknown>;
-    newValues: Map<TRowId, unknown>;
-};
-
-/** Severity level for a validation message. */
-type ValidationLevel = "error";
-/**
- * A single validation message attached to a cell.
- * Return this from a `CellValidator` to flag a problem.
- */
-type ValidationError = {
-    level: ValidationLevel;
-    /** Human-readable message shown in the cell tooltip. */
-    message: string;
-};
-type ValidationResult = ValidationError[] | null;
-/**
- * A function that validates a single cell value.
- * Return a `ValidationError` to flag a problem, or `null` if the value is valid.
- *
- * A `ValidationError` with `level: "error"` flags the cell in the grid but
- * does not block submission — invalid rows are delivered to `onComplete`
- * alongside valid ones, tagged via the `isValid` flag.
- *
- * Built-in validator factories: `required(msg)`, `numeric(msg)`, `email(msg)`,
- * `date(msg)`, `oneOf(values, msg)`, `endDateAfterStart(startField, msg)`.
- * Import them from the package root.
- *
- * @param value - The current cell value.
- * @param row - The full row, useful for cross-field checks.
- */
-type CellValidator = (value: unknown, row: DataEditorRow) => ValidationError | null;
-/** Text input cell. This is the default editor when no `editor` is specified. */
-type TextEditorCell = {
-    type: "text";
-};
-/** Date picker cell. Optionally restrict the selectable date range. */
-type DateEditorCell = {
-    type: "date";
-    /** Earliest selectable date. */
-    minDate?: Date;
-    /** Latest selectable date. */
-    maxDate?: Date;
-};
-/** Dropdown select cell. The user picks from a fixed list of options. */
-type SelectEditorCell = {
-    type: "select";
-    /** The list of options shown in the dropdown. Each string is both the stored value and the display label. */
-    options: string[];
-};
-/** Number input cell with locale-aware formatting. */
-type NumberEditorCell = {
-    type: "number";
-    /** Maximum number of decimal digits allowed. When omitted, decimals are unrestricted. */
-    decimalPlaces?: number;
-    /** Character used as the decimal point (e.g. `"."` or `","`). Defaults to the browser locale. */
-    decimalSeparator?: string;
-    /** Character inserted between groups of three digits (e.g. `","` or `"."`). Defaults to the browser locale. */
-    thousandsSeparator?: string;
-    /** Extra characters to allow beyond digits, decimal separator, and minus sign (e.g. `"%-"`). When defined, minus is only kept if explicitly included. */
-    allowChars?: string;
-};
-/**
- * Controls how a cell is edited.
- *
- * - `"text"` — plain text input (default).
- * - `"date"` — date picker with optional min/max bounds.
- * - `"select"` — dropdown with a fixed list of options.
- * - `"number"` — number input with locale-aware formatting.
- */
-type CellEditor = TextEditorCell | DateEditorCell | SelectEditorCell | NumberEditorCell;
-/** Dropdown filter shown in the sidebar Filters panel. */
-type SelectColumnFilter = {
-    type: "select";
-    /** Label displayed above the filter. */
-    label?: string;
-    /** Placeholder text when nothing is selected. */
-    placeholder?: string;
-    /** Fixed list of filter options. When omitted, options are derived from column values. */
-    options?: string[];
-    /** Allow selecting multiple values at once. */
-    multiple?: boolean;
-};
-/** Numeric min/max range filter shown in the sidebar Filters panel. */
-type NumberRangeColumnFilter = {
-    type: "number-range";
-    /** Label displayed above the filter. */
-    label?: string;
-};
-/** Date min/max range filter shown in the sidebar Filters panel. */
-type DateRangeColumnFilter = {
-    type: "date-range";
-    /** Label displayed above the filter. */
-    label?: string;
-};
-/**
- * Filter control shown in the sidebar Filters panel for a column.
- *
- * - `"select"` — dropdown to pick one or more values.
- * - `"number-range"` — two inputs for min and max number.
- * - `"date-range"` — two date pickers for start and end date.
- */
-type ColumnFilter = SelectColumnFilter | NumberRangeColumnFilter | DateRangeColumnFilter;
-/** Lock mode for a column. `"all"` locks for every row; `"default"` locks only default-source rows. */
-type ColumnLockMode = "all" | "default";
-/**
- * Defines a column in the editor grid.
- *
- * @example
- * ```ts
- * import { required, email, numeric } from "@updog/data-editor";
- *
- * const columns: DataEditorColumn[] = [
- *   { id: "name", title: "Full Name", size: 200, validate: required("Name is required") },
- *   { id: "email", title: "Email", size: 250, validate: [required("Email is required"), email("Invalid email")], unique: true },
- *   { id: "role", title: "Role", editor: { type: "select", options: ["Admin", "Editor", "Viewer"] } },
- *   { id: "salary", title: "Salary", validate: numeric("Must be a number"), formatter: (v) => v ? `$${v}` : "" },
- * ];
- * ```
- */
-type DataEditorColumn = {
-    /** Unique column identifier. Must match the keys in your row data. */
-    id: string;
-    /** Column header text shown to the user. */
-    title: string;
-    /**
-     * One or more validators run on every edit. Each receives the cell value and
-     * the full row, and returns a `ValidationError` to flag a problem or `null`
-     * if valid. Errors do not block submission — see `CellValidator`.
-     */
-    validate?: CellValidator | CellValidator[];
-    /**
-     * When `true`, the editor flags duplicate values in this column as errors.
-     * The error message is localized via the `translations` prop
-     * (`dataEditor.validation.valueMustBeUnique`).
-     */
-    unique?: boolean;
-    /**
-     * Column IDs to revalidate when this column changes. Use for cross-field
-     * rules like "end date must be after start date".
-     */
-    dependentFields?: string[];
-    /** Format the display value without changing stored data. E.g. add `$` prefix. */
-    formatter?: (value: string) => string;
-    /**
-     * Transform a value before it enters the store. Runs when rows are uploaded
-     * to the data editor.
-     */
-    transformer?: (value: unknown) => unknown;
-    /** How the cell is edited. Defaults to text input. */
-    editor?: CellEditor;
-    /** Adds a filter control for this column in the sidebar Filters panel. */
-    filter?: ColumnFilter;
-    /**
-     * Whether this column can be pinned to the left (right in RTL) via the
-     * header context menu. @default true
-     */
-    pinnable?: boolean;
-    /** Column width in pixels. @default 150 */
-    size?: number;
-    /**
-     * Controls whether cells in this column are locked. A column locked via
-     * configuration cannot be unlocked from the UI.
-     * - `true` | `"all"` — locked for every row.
-     * - `"default"` — locked only for default-source rows; rows added manually,
-     *   duplicated, or imported remain editable.
-     * - `false` | `undefined` — not locked.
-     */
-    locked?: boolean | ColumnLockMode;
-};
-
-/** Params passed to `findAndReplace.onFind` when the user types a search query. */
-type FindParams = {
-    /** The search string. */
-    search: string;
-    /** When `true`, matching is case-sensitive. */
-    matchCase?: boolean;
-    /** When `true`, the entire cell value must equal the search string. */
-    matchEntireCell?: boolean;
-    /** Restrict search to these columns. `null` or omitted = all columns. */
-    columnIds?: string[] | null;
-    /** Current view filters so the server can scope matches to the active filter set. */
-    filters?: QueryFilters;
-    /** Current sort state so match ordering follows the visual row order. */
-    sort?: SortState;
-};
-/** A single match location returned by the server. */
-type FindMatch = {
-    /** Row position in the current filtered+sorted view (for grid scrolling). */
-    rowIndex: number;
-    /** Column ID where the match occurs. */
-    columnId: string;
-    /** Character offset within the cell value (for inline highlight). */
-    startIndex: number;
-    /** 0-based position in the ordered match list (for counter display). */
-    matchIndex: number;
-};
-/** Response from `findAndReplace.onFind`. */
-type FindResponse = {
-    /** Total number of matches across all rows. */
-    totalCount: number;
-    /** The first match. Omit when `totalCount` is 0. */
-    current?: FindMatch;
-};
-/** Params passed to `findAndReplace.onNavigate` when the user clicks prev/next. */
-type FindNavigateParams = FindParams & {
-    /** Navigation direction. */
-    direction: "next" | "prev";
-    /** Current match position so the server knows where to navigate from. */
-    currentMatchIndex: number;
-};
-/** Params passed to `findAndReplace.onReplace`. */
-type ReplaceParams = FindParams & {
-    /** The replacement text. */
-    replacement: string;
-    /** When `true`, replace all matches. When omitted or `false`, replace only `target`. */
-    all?: boolean;
-    /** The specific match to replace. Required when `all` is not `true`. */
-    target?: FindMatch;
-};
-/** Response from `findAndReplace.onReplace`. */
-type ReplaceResponse = {
-    /** Remaining match count after replacement. */
-    totalCount: number;
-    /** Next match to navigate to after replacement. Omit when none left. */
-    current?: FindMatch;
-};
-/** Server-side find and replace configuration. */
-type FindAndReplaceConfig = {
-    /** Called when the user types a search query. Returns total count and first match. */
-    onFind: (params: FindParams) => Promise<FindResponse>;
-    /** Called when the user clicks prev/next arrows. Returns the target match. */
-    onNavigate: (params: FindNavigateParams) => Promise<FindMatch>;
-    /** Called when the user clicks Replace or Replace All. */
-    onReplace: (params: ReplaceParams) => Promise<ReplaceResponse>;
-};
-type StoreMode = "client" | "server";
-type ServerRowId = string | number;
-/** Row-level status flags returned by the server. Drive row filters and sidebar counts. */
-type ServerRowStatus = {
-    edited?: boolean;
-    new?: boolean;
-    deleted?: boolean;
-    hasErrors?: boolean;
-    hasEmptyCells?: boolean;
-};
-/** Server-reported change for a single cell. The current value lives in `fields`. */
-type ServerCellChange = {
-    original: unknown;
-};
-/** Server-reported validation error for a single cell. */
-type ServerCellError = {
-    message: string;
-    code?: number | string;
-};
-/** Per-row metadata returned by the server in server-delegated mode. */
-type ServerRowMeta = {
-    /** Row-level status flags — drive row filters and sidebar counts. */
-    status?: ServerRowStatus;
-    /** Cell-level change tracking. Key = field name. */
-    changes?: Record<string, ServerCellChange>;
-    /** Cell-level validation errors. Key = field name. */
-    errors?: Record<string, ServerCellError[]>;
-};
-/** Per-source row count returned by the server. Drives the Data Sources sidebar. */
-type ServerSourceCount = {
-    id: string;
-    name: string;
-    count: number;
-};
-/** Aggregate row counts returned alongside a query page. Drive sidebar indicators. */
-type ServerQueryCounts = {
-    edited?: number;
-    new?: number;
-    deleted?: number;
-    errors?: number;
-    emptyCells?: number;
-    sources?: ServerSourceCount[];
-};
-type ServerRow<T extends DataEditorRow = DataEditorRow> = {
-    id: ServerRowId;
-    fields: T;
-    meta?: ServerRowMeta;
-};
-type ServerResponse<T> = {
-    data: T;
-    meta?: Record<string, unknown>;
-};
-type QueryFilters<F = Record<string, unknown>> = Partial<Filters> & F;
-type QueryParams<F = Record<string, unknown>> = {
-    filters?: QueryFilters<F>;
-    sort?: SortState;
-    /** When present, only rows belonging to these source IDs are returned. Omit to include all sources. */
-    sources?: string[];
-    offset?: number;
-    limit: number;
-    signal?: AbortSignal;
-};
-type QueryResponse<T extends DataEditorRow = DataEditorRow> = ServerResponse<{
-    rows: ServerRow<T>[];
-    totalCount: number;
-    filteredCount?: number;
-    counts?: ServerQueryCounts;
-}>;
-/**
- * Filter options returned by `onFilterOptions` for populating sidebar filter controls in server mode.
- * Keys are column IDs. Only include columns that have a `filter` configured.
- */
-type FilterOptionsResponse = {
-    [columnId: string]: {
-        /** Values for `"select"` filters. Raw display strings — no formatter is applied. */
-        options?: string[];
-        /** Bounds for `"number-range"` filters. */
-        range?: {
-            min: number;
-            max: number;
-        };
-        /** Bounds for `"date-range"` filters. Values are ISO date strings (YYYY-MM-DD). */
-        dateRange?: {
-            min: string;
-            max: string;
-        };
-    };
-};
-type ServerCallOptions = {
-    signal: AbortSignal;
-};
-/**
- * Coordinate rectangle within the server's data view.
- * Uses ServerRowId (primary key) for rows and column ID strings for columns.
- *
- * Convention:
- * - Both row fields omitted → all rows.
- * - Both column fields omitted → all columns.
- * - Single row: `fromRow` AND `toRow` both set, `toRow === fromRow`.
- * - Single column: `fromColumn` AND `toColumn` both set, `toColumn === fromColumn`.
- * - Range: both `from` and `to` set, `to !== from`.
- * - `allSelected: true` → all rows and all columns.
- * - Empty `{}` → used only for insert operations.
- *
- * INVALID: `from` present without `to`, or vice versa.
- */
-type Region = {
-    fromRow?: ServerRowId;
-    toRow?: ServerRowId;
-    fromColumn?: string;
-    toColumn?: string;
-    allSelected?: boolean;
-};
-/** Describes where and how to insert a new row. */
-type InsertParams = {
-    /** Existing row to anchor the insert relative to. Omitted when appending to the end. */
-    anchorRow?: ServerRowId;
-    /** Insert before or after the anchor row. */
-    position: "above" | "below";
-    /** Column IDs matching the order of `values` entries. */
-    columns: string[];
-};
-/**
- * Unified edit params for all data mutations in server-delegated mode.
- *
- * The combination of fields determines the operation:
- * - `target` + `values`             → cell edit, clear, or external paste
- * - `target` + `source`             → internal paste (+ `cut` for cut-paste)
- * - `target` + `source` (fill)      → fill handle
- * - `target` + `transform`          → transform / revert
- * - `target` + `delete: true`       → mark rows for deletion
- * - `target` + `delete: false`      → restore rows (unmark deletion)
- * - `insert` + `values`             → create a new row
- *
- * `values` is always a 2D array. For a single cell edit: `[["newValue"]]`.
- * For clearing: `[[""]]`. The server interprets dimensions relative to `target`:
- * a 1×1 `values` applied to a multi-cell target means "fill all cells with this value".
- *
- * `filters` and `sort` provide the view context so the server can resolve
- * which rows fall between `fromRow` and `toRow` in the current view.
- * Omitted for single-cell edits where `fromRow` is a direct row ID.
- */
-type EditParams = {
-    target: Region[];
-    source?: Region[];
-    values?: unknown[][];
-    transform?: TransformParams;
-    cut?: boolean;
-    delete?: boolean;
-    insert?: InsertParams;
-    undo?: boolean;
-    filters?: QueryFilters;
-    sort?: SortState;
-    lockedColumns?: Array<{
-        columnId: string;
-        mode: "all" | "default";
-    }>;
-};
-type ExportParams$1<F = Record<string, unknown>> = {
-    format: "csv" | "tsv" | "xlsx" | "json" | "xml";
-    allRows: boolean;
-    rtl?: boolean;
-    filters?: QueryFilters<F>;
-    sort?: SortState;
-    signal?: AbortSignal;
-};
-/** Transform operation descriptor. `type` identifies the operation, optional fields carry parameters. */
-type TransformParams = {
-    type: string;
-    separator?: string;
-    /** When `true`, the server should delete the dynamic source columns after applying the transform. */
-    deleteSource?: boolean;
-};
-type FormulaParams = {
-    formula: string;
-    params: Record<string, unknown>;
-};
-/** Params passed to `onColumnDelete` when the user deletes a dynamic column. */
-type ColumnDeleteParams = {
-    /** ID of the dynamic column to delete. */
-    columnId: string;
-    /** `true` when the server should reverse this operation (undo). Omitted on initial call and redo. */
-    undo?: boolean;
-};
-/** Params passed to `onColumnEdit` when the user renames a dynamic column. */
-type ColumnEditParams = {
-    /** ID of the dynamic column being edited. */
-    columnId: string;
-    /** New title for the column. */
-    title: string;
-    /** `true` when the server should reverse this operation (undo). Omitted on initial call and redo. */
-    undo?: boolean;
-};
-/** Server's response after applying a mutation. */
-type EditResponse = {
-    counts?: ServerQueryCounts;
-    /** Business-logic rejection. SDK reverts the optimistic update and shows `reason` in a toast. */
-    rejected?: boolean;
-    /** Why the server rejected. Shown to the user as-is. */
-    reason?: string;
-    /** The full row created by the server. Returned for insert operations. */
-    row?: ServerRow;
-    /** Updated column list. When present, the SDK replaces its columns with this list. */
-    columns?: Array<{
-        id: string;
-        title: string;
-    }>;
-};
-/**
- * Every decision the user made during the import wizard, packed into one object.
- * You get the raw file and the full mapping config. Parse it however you want —
- * stream it, bulk-load it, hand it to a background job. Your call.
- */
-type ImportMappings = {
-    /** CSV header → column ID. Headers the user left unmatched are `undefined`. */
-    columnMapping: Record<string, string | undefined>;
-    /**
-     * Value substitutions for select columns.
-     * Outer key = column ID, inner key = imported value, inner value = target option.
-     * Only present when at least one select column was matched.
-     */
-    valueMapping: Record<string, Record<string, string | undefined>>;
-    /** Column ID used to match imported rows against existing data. Same value as `DataEditorProps.primaryKey`. */
-    primaryKey: string;
-    /** Sheet name the user selected. Only present for multi-sheet XLSX files. */
-    selectedSheet?: string;
-    /** Zero-based index of the row the SDK detected as the header row. */
-    headerRowIndex: number;
-    /** Number format detected from the file contents. Affects how `"1.234,56"` vs `"1,234.56"` is read. */
-    numberFormat: "EU" | "US";
+    private hydrateServerMeta;
+    private hydrateRowMeta;
+    applyServerRowMeta(serverRows: ServerRow<TRow>[], counts?: ServerQueryCounts): void;
+    clear(): void;
+    destroy(): void;
+    setFilters(filters: Partial<Filters>): void;
+    getFilters(): Filters;
+    setSort(sortState: SortState, sortType?: SortType, locales?: string[]): Promise<void>;
+    handleServerScroll(visibleStart: number, visibleEnd: number): void;
+    reloadServerData(): void;
+    resetFilters(): void;
+    fetchFilterOptions(): void;
+    getFilterOptions(): FilterOptionsResponse | null;
+    get hasServerExport(): boolean;
+    serverExport(format: DataEditorFormat, allRows: boolean, rtl: boolean): Promise<void>;
+    syncWorkerFlags(): void;
+    setCellValidation(rowId: TRowId, field: string, result: ValidationResult): void;
+    getCellValidation(rowId: TRowId, field: string): ValidationResult;
+    private clearRowValidations;
+    updateRow(rowId: TRowId, field: string, value: unknown): void;
+    updateRowDirect(rowId: TRowId, field: string, value: unknown): void;
     /**
-     * Per-column date disambiguation. Key = CSV header (not column ID).
-     * `"EU"` = day-first, `"US"` = month-first.
-     * Only includes columns where the format was ambiguous and had to be resolved.
+     * Bulk-write a single column for many rows in one pass.
+     * Skips per-row validation, notification, and snapshot adjustments.
+     * Caller must handle validation (via Validator.revalidateColumn) and notification.
      */
-    dateFormats: Record<string, "EU" | "US">;
+    updateColumnDirect(field: string, values: ReadonlyMap<TRowId, unknown>): void;
+    batch(fn: () => void): number | undefined;
+    canUndo(): boolean;
+    getAllRowIds(): readonly TRowId[];
+    undo(): Promise<UndoRedoResult>;
+    private _undoSync;
+    pushCommand(cmd: Command<TRow>, cost?: number): number;
+    removeCommandById(id: number): void;
     /**
-     * Columns the user created during import for unmatched headers.
-     * These don't exist in your schema yet — you decide whether to persist them.
+     * Delegate to ServerStrategy. Called by ActionsDispatcher and ClipboardManager
+     * for non-cell edits (clear, paste, fill, transform).
      */
-    newColumns: DataEditorColumn[];
-};
-/** Params passed to `onFileImport`. The original file, unchanged, plus everything the wizard collected. */
-type FileImportParams = {
-    /** The original file. Same bytes the user dropped into the browser. */
-    file: File;
-    /** All mapping decisions from the import wizard. */
-    mappings: ImportMappings;
-    /** Display name for this import source. Typically the file name. */
-    sourceName: string;
-    /** Fires when the user cancels the import. */
-    signal?: AbortSignal;
-};
-/**
- * Params passed to `onRowsImport` once per chunk.
- * The SDK already parsed the file, applied column mappings, normalized dates
- * and numbers, and resolved value mappings. You get clean, schema-conformant rows.
- */
-type RowsImportParams = {
-    /** Stable ID for this import session. Use it for idempotency or correlation. */
-    importId: string;
-    /** Display name for this import source. Typically the file name. */
-    sourceName: string;
-    /** Zero-based chunk index. Together with `importId`, uniquely identifies each chunk. */
-    chunkIndex: number;
-    /** `true` on the last chunk. Safe to finalize, run post-import hooks, or trigger validation. */
-    isLastChunk: boolean;
-    /** Transformed rows, keyed by column ID. Ready to store. */
-    rows: Record<string, unknown>[];
-    /** Columns the user created during import. Only present on the first chunk (`chunkIndex === 0`). */
-    newColumns?: DataEditorColumn[];
-    /** Column ID used to match imported rows against existing data. */
-    primaryKey: string;
-    /** Fires when the user cancels mid-import. Clean up any partial state. */
-    signal?: AbortSignal;
-};
-/** Your response after processing a chunk. */
-type RowsImportResponse = {
-    /** How many rows you accepted from this chunk. Drives progress reporting. */
-    accepted: number;
-    /** Per-row errors. `rowIndex` is relative to the chunk (0-based). Surfaced in the UI after import. */
-    errors?: Array<{
-        rowIndex: number;
-        message: string;
-    }>;
-};
-/** Params passed to `onSourceRemove` when the user deletes a data source. */
-type SourceRemoveParams = {
-    /** The source ID to remove. Matches the `id` from `ServerQueryCounts.sources`. */
-    sourceId: string;
-    /** Fires when the user cancels. */
-    signal?: AbortSignal;
-};
-type DataEditorServer<TRow extends DataEditorRow = DataEditorRow, TFilters = Record<string, unknown>> = {
-    onQuery: (params: QueryParams<TFilters>) => Promise<QueryResponse<TRow>>;
-    /** Fetches filter dictionaries for all filterable columns. Called once after license validation. */
-    onFilterOptions?: () => Promise<FilterOptionsResponse>;
-    /** Called when the user triggers an export. The consumer handles file generation and download. */
-    onExport?: (params: ExportParams$1<TFilters>) => Promise<void>;
-    /** Called after optimistic local apply. Return `{ rejected: true }` for business-logic errors; throw for infra failures. */
-    onEdit: (params: EditParams, options?: ServerCallOptions) => Promise<EditResponse | void>;
+    syncServerEdit(params: EditParams, cmdId: number, revertFn: () => void): void;
+    fireServerEditParams(params: EditParams): void;
+    syncColumnEdit(params: ColumnEditParams, cmdId: number, revertFn: () => void): void;
+    redo(): Promise<UndoRedoResult>;
+    private _redoSync;
+    getOriginalCellValue(rowId: TRowId, field: string): unknown | undefined;
+    isCellDirty(rowId: TRowId, field: string): boolean;
+    hasRowErrors(rowId: TRowId): boolean;
+    hasEmptyCells(rowId: TRowId): boolean;
+    private checkRowEmptyCells;
+    getValidAndInvalidRows(): {
+        valid: TRow[];
+        invalid: TRow[];
+    };
+    getValidRows(): TRow[];
+    getInvalidRows(): TRow[];
+    getResultBySource(): DataEditorResult<TRow>;
+    private isRowVisible;
+    applyFormula(formulaOrName: string | CellFormula, params: Record<string, unknown>, rects: SelectionRect[], options?: ApplyFormulaOptions): Promise<void>;
+    private applyFormulaCompound;
+    private runFormulaWithReturnCommand;
+    private _runFormulaOperation;
+    private captureDeleteColumnSnapshots;
+    private applyDeleteColumnSnapshots;
+    private syncFormulaToServer;
+    private transformWorker;
+    private initTransformWorker;
+    private buildChatOpsCommand;
+    applyChatOps(ops: ChatOp[], ctx: {
+        opts: Record<string, Set<string>>;
+    }, enableDeleteRow: 'all' | 'new' | false): Promise<void>;
+    private filterDeleteIdsByPolicy;
+    private _applyChatOpsViaWorker;
+    private _applyChatOpsSync;
+    private _commitChatOps;
+    applyChatRows(incomingRows: Record<string, unknown>[], primaryKey: string): Promise<void>;
+    private syncChatTransformToServer;
+    private get revertRowReader();
+    revertColumns(fields: string[]): Promise<void>;
+    revertRange(rects: SelectionRect[]): Promise<void>;
+    private _revertInternal;
+    private _buildRevertCommand;
+    private syncRevertToServer;
+    clearColumn(field: string): Promise<void>;
+    clearColumns(fields: string[]): Promise<void>;
+    private syncClearToServer;
+    deleteColumn(columnId: string): Promise<void>;
+    deleteColumns(columnIds: readonly string[]): Promise<void>;
+    clearRange(rects: SelectionRect[]): Promise<void>;
+    private syncRangeClearToServer;
+    pasteChunked(spec: PasteSpec, targetRowIds: TRowId[], targetCell: {
+        rowId: TRowId;
+        field: string;
+    }, onComplete?: (cmdId: number) => void): void;
     /**
-     * File import strategy. You get the raw file and the mapping config.
-     * You own parsing, transformation, and storage.
-     * Mutually exclusive with `onRowsImport`.
+     * Store-owned paste: cost-gated sync path or chunked orchestrator.
+     * Replaces executePasteWithOverlay + pasteChunked for internal-clipboard paste.
      */
-    onFileImport?: (params: FileImportParams) => Promise<void>;
+    pasteInternal(spec: PasteSpec, targetRowIds: TRowId[], targetCell: {
+        rowId: TRowId;
+        field: string;
+    }, validator?: IValidator<TRow>): Promise<{
+        cmdId: number;
+    } | null>;
     /**
-     * Rows import strategy. The SDK parses the file, applies all mappings,
-     * normalizes dates and numbers, and sends you clean rows in chunks.
-     * Called once per chunk. Awaited before sending the next chunk.
-     * Mutually exclusive with `onFileImport`.
+     * Store-owned external paste from TSV text (OS clipboard).
+     * Replaces the pasteFromText helper in pasteUtils.
      */
-    onRowsImport?: (params: RowsImportParams) => Promise<RowsImportResponse | void>;
-    /** Number of rows per import chunk when using `onRowsImport`. @default 5000 */
-    importChunkSize?: number;
-    /** Called when the user removes a data source. Delete all rows belonging to this source. */
-    onSourceRemove?: (params: SourceRemoveParams) => Promise<void>;
-    /** Called when the user deletes, undoes, or redoes a dynamic column deletion. */
-    onColumnDelete?: (params: ColumnDeleteParams) => Promise<EditResponse | void>;
-    /** Called when the user edits a dynamic column (e.g. renames it). */
-    onColumnEdit?: (params: ColumnEditParams) => Promise<EditResponse | void>;
+    pasteFromText(text: string, pasteRow: number, pasteCol: number, validator?: IValidator<TRow>): Promise<{
+        cmdId: number;
+    } | null>;
     /**
-     * Server-side find and replace. When provided, enables Find & Replace UI
-     * in server mode. The server owns all searching and replacing; the SDK
-     * handles counts, navigation, and highlighting.
+     * Store-owned fill: cost-gated sync path or chunked orchestrator.
+     * Replaces fillChunked + the per-caller isHeavy heuristic in ActionsDispatcher.
      */
-    findAndReplace?: FindAndReplaceConfig;
-    /** Number of rows per page. @default 200 */
-    pageSize?: number;
-    /** Controls how eagerly the SDK fetches data while scrolling. 0 = always debounce, 1 = fetch immediately. @default 0.5 */
-    scrollSensitivity?: number;
+    fillInternal(spec: FillSpec, targetRowIds: TRowId[], targetCell: {
+        rowId: TRowId;
+        field: string;
+    }, onComplete?: (cmdId: number) => void): Promise<{
+        cmdId: number;
+    } | null>;
+    notify(): void;
+}
+
+/**
+ * Command interface for undo/redo operations.
+ * Each command knows how to apply and revert its changes.
+ */
+interface Command<TRow extends DataEditorRow = DataEditorRow> {
+    /** Assigned by CommandHistory.push(). Used by removeById() to target specific commands. */
+    id?: number;
+    redo(store: DataStore<TRow>, validator: IValidator<TRow>): void;
+    undo(store: DataStore<TRow>, validator: IValidator<TRow>): void;
+    readonly description: string;
+    /** Target cell for selection restoration on undo/redo */
+    readonly targetCell: CellLocation;
+}
+
+/**
+ * BulkMutationOrchestrator — Viewport-first chunked execution for heavy
+ * column operations (split, merge, clear, paste, fill, backspace).
+ *
+ * When operation cost >= LARGE_OP_CELLS:
+ *   1. Viewport rows are applied synchronously (instant visual result)
+ *   2. Remaining rows are processed in chunks via requestIdleCallback
+ *   3. Validation runs chunked after all mutations complete
+ *   4. Command is pushed to history only after everything finishes
+ *
+ * Communicates with DataStore via BulkMutationHost interface to avoid
+ * circular imports. DataStore constructs the host from its own methods.
+ */
+
+type ColumnDelta = {
+    field: string;
+    oldValues: Map<TRowId, unknown>;
+    newValues: Map<TRowId, unknown>;
+};
+
+type ScaleServerConfig = {
+    url: string;
 };
 
 /** Numeric row identifier. V8 stores small integers (Smi) inline — no heap allocation. */
@@ -2779,12 +2845,6 @@ type DataEditorBaseProps<TRow extends DataEditorRow = DataEditorRow> = {
      * ```
      */
     loadData?: (onChunk: (rows: TRow[], options?: ChunkSourceOptions) => void) => Promise<void>;
-    /**
-     * Server-delegated mode. When provided, the SDK acts as a rendering head
-     * and delegates data operations (fetching, filtering, sorting, mutations)
-     * to the client's backend via callbacks.
-     */
-    server?: DataEditorServer<TRow>;
     /**
      * Called when the user clicks "Submit". Receives the edited data grouped
      * by source. Use `actions.reset()` to clear changes after a successful save.
@@ -2944,6 +3004,11 @@ type DataEditorMode = "modal" | "inline";
 type DataEditorCommonProps<TRow extends DataEditorRow = DataEditorRow> = DataEditorBaseProps<TRow> & {
     /** Your Updog license key. Validated on each open. */
     apiKey: string;
+    /**
+     * Connect to a self-hosted Updog Scale binary. When provided, the SDK
+     * delegates all data operations to the Scale server at the given URL.
+     */
+    server?: ScaleServerConfig;
     /**
      * Controls what the editor stores in `localStorage`. Set to `false` to
      * disable all local storage usage.
@@ -3050,67 +3115,6 @@ declare function downloadExampleFile(columns: DataEditorColumn[], format: DataEd
  */
 declare function exportDataEditor<TRow extends DataEditorRow>(params: ExportParams<TRow>): Promise<void>;
 
-/**
- * Creates a validator that rejects empty values.
- *
- * @param message - Error message shown when the cell is empty.
- *
- * @example
- * ```ts
- * const columns = [
- *   { id: "name", title: "Name", validate: [required("Name is required")] },
- * ];
- * ```
- */
-declare function required(message: string): CellValidator;
-/**
- * Creates a validator that rejects non-numeric values.
- *
- * @param message - Error message shown when the value is not a valid number.
- */
-declare function numeric(message: string): CellValidator;
-/**
- * Creates a validator that rejects invalid email addresses.
- *
- * @param message - Error message shown when the value is not a valid email.
- */
-declare function email(message: string): CellValidator;
-/**
- * Creates a validator that rejects values not matching `YYYY-MM-DD` or `DD/MM/YYYY`.
- *
- * @param message - Error message shown when the value is not a valid date.
- */
-declare function date(message: string): CellValidator;
-/**
- * Creates a validator that ensures this date is on or after the date in another column.
- *
- * @param startDateField - Column ID of the start-date field to compare against.
- * @param message - Error message shown when the end date is before the start date.
- *
- * @example
- * ```ts
- * const columns = [
- *   { id: "startDate", title: "Start", dependentFields: ["endDate"] },
- *   { id: "endDate", title: "End", validate: [endDateAfterStart("startDate", "End must be after start")] },
- * ];
- * ```
- */
-/**
- * Creates a validator that rejects values not in the allowed set.
- *
- * @param values - Array of allowed values (matched by strict equality).
- * @param message - Error message shown when the value is not in the set.
- *
- * @example
- * ```ts
- * const columns = [
- *   { id: "status", title: "Status", validate: [oneOf(["active", "inactive"], "Invalid status")] },
- * ];
- * ```
- */
-declare function oneOf(values: string[], message: string): CellValidator;
-declare function endDateAfterStart(startDateField: string, message: string): CellValidator;
-
 /**
  * Full-screen modal spreadsheet editor for large datasets.
  *
@@ -3127,6 +3131,7 @@ declare function endDateAfterStart(startDateField: string, message: string): Cel
  *   onClose={() => setIsOpen(false)}
  *   columns={columns}
  *   primaryKey="id"
+ *   server={{ url: scaleUrl }}
  *   loadData={async (onChunk) => onChunk(await fetchRows())}
  *   onComplete={(result, actions) => { saveChanges(result); actions.reset(); }}
  * />
@@ -3134,5 +3139,5 @@ declare function endDateAfterStart(startDateField: string, message: string): Cel
  */
 declare function DataEditor<TRow extends DataEditorRow = DataEditorRow>(allProps: DataEditorProps<TRow>): react_jsx_runtime.JSX.Element;
 
-export { DataEditor, date, downloadExampleFile, email, endDateAfterStart, exportDataEditor, numeric, oneOf, required };
-export type { CellValidator, ChatContext, ChatErrorSummary, ChatResponseChunk, ChatRow, ChatRowStatus, ChunkSourceOptions, ColumnDeleteParams, ColumnEditParams, DataEditorChat, DataEditorColumn, DataEditorFormat, DataEditorInlineProps, DataEditorLocalStorage, DataEditorModalProps, DataEditorMode, DataEditorProps, DataEditorResult, DataEditorRow, DataEditorServer, DataEditorSourceResult, DataEditorTranslations, DataEditorVariant, EditParams, EditResponse, ExportParams$1 as ExportParams, FileImportParams, FilterOptionsResponse, FindNavigateParams, FindParams, FormulaParams, ImportMappings, QueryFilters, QueryParams, QueryResponse, Region, RemoteSource, ReplaceParams, ResultRow, RowsImportParams, RowsImportResponse, ServerCallOptions, ServerCellChange, ServerCellError, ServerQueryCounts, ServerRow, ServerRowMeta, ServerRowStatus, SourceRemoveParams, TransformParams, UpdogError, UpdogErrorCode, ValidationError, ValueMatchInput, ValueMatchOutput };
+export { DataEditor, downloadExampleFile, exportDataEditor };
+export type { CellValidator, ChatContext, ChatErrorSummary, ChatResponseChunk, ChatRow, ChatRowStatus, ChunkSourceOptions, DataEditorChat, DataEditorColumn, DataEditorFormat, DataEditorInlineProps, DataEditorLocalStorage, DataEditorModalProps, DataEditorMode, DataEditorProps, DataEditorResult, DataEditorRow, DataEditorSourceResult, DataEditorTranslations, DataEditorVariant, RemoteSource, ResultRow, ScaleServerConfig, UpdogError, UpdogErrorCode, ValidationError, ValueMatchInput, ValueMatchOutput };