@updog/data-editor 0.1.81 → 0.1.83

package/index.d.ts

@@ -1,4 +1,4 @@
-import * as react_jsx_runtime from 'react/jsx-runtime';
+import * as react from 'react';
 
 declare var export_default = {
   ui: {
@@ -417,6 +417,7 @@ declare var export_default = {
       outOfRange: "Out of range",
       required: "This field is required",
       structuralMismatch: "This might be in the wrong column.",
+      tooManyDecimals: "Too many decimal places",
       valueMustBeUnique: "Value must be unique",
     },
     license: {
@@ -448,24 +449,6 @@ declare var export_default = {
           text: "Your subscription is no longer active. Please renew to continue.",
         },
       },
-      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: {
@@ -646,11 +629,12 @@ type SortState = {
     columnId: string;
     direction: SortDirection;
 } | null;
+type ErrorFilter = "all" | string[] | null;
 type Filters = {
     search: string;
     matchCase: boolean;
     matchEntireCell: boolean;
-    errorMessageFilters: string[];
+    errorFilter: ErrorFilter;
     showOnlyNewRows: boolean;
     showOnlyEditedRows: boolean;
     showOnlyEmptyCells: boolean;
@@ -673,104 +657,6 @@ type Filters = {
     }>;
 };
 
-/**
- * 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;
-} | {
-    type: "unique";
-    message?: string;
-    fn?: UniqueRemoteFn;
-};
-/** One cell in an asyncFunction batch. Row is passed by reference. */
-type AsyncValidatorCell = {
-    /** Value of the validated column for this cell. */
-    value: unknown;
-    /** The full row — for row-dependent checks. */
-    row: DataEditorRow;
-};
-/**
- * Remote existence check for `{ type: "unique" }`. Called once per sweep
- * with all distinct candidate values; report the subset that already exists —
- * return it and/or stream it via onChunk (results are unioned). `signal`
- * fires only when results can no longer be used. Client-mode only.
- */
-type UniqueRemoteFn = (values: unknown[], onChunk: (existing: unknown[]) => void, signal: AbortSignal) => Promise<unknown[] | void>;
-type AsyncFunctionValidator = {
-    type: "asyncFunction";
-    /**
-     * Called once per column per operation with every affected cell. Report
-     * failures by `index` into `cells`: return an array aligned with the input
-     * (null = valid) and/or stream sparse failures via onChunk (unioned, any
-     * order). `signal` fires only when results can no longer be used.
-     * Client-mode only. For uniqueness use `unique.fn`, not this.
-     */
-    fn: (cells: AsyncValidatorCell[], onChunk: (failures: {
-        index: number;
-        error: ValidationError;
-    }[]) => void, signal: AbortSignal) => Promise<(ValidationError | null)[] | void>;
-};
-/**
- * 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.
- *
- * Named `ValidatorRule` (not `Validator`) so it doesn't clash with the
- * runtime `Validator` class in `core/Validator.ts`.
- */
-type ValidatorRule = BuiltInValidator | ExpressionValidator | FunctionValidator | AsyncFunctionValidator;
-/**
- * Async-check state of a cell, orthogonal to errors/misplaced: "pending"
- * while a verdict is awaited, "unverified" when the check failed or timed
- * out. Idle cells carry no entry.
- */
-type CellAsyncState = "pending" | "unverified";
-
 /**
  * Severity level for a validation message.
  * - `"error"` — a validation failure: marks the row invalid, counts as an error.
@@ -809,13 +695,9 @@ type CellValidator = (value: unknown, row: DataEditorRow) => ValidationError | n
 type TextEditorCell = {
     type: "text";
 };
-/** Date picker cell. Optionally restrict the selectable date range. */
+/** Date picker cell. Bounds come from the column's `{ type: "date" }` validator. */
 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 = {
@@ -838,23 +720,19 @@ type MultiSelectEditorCell = {
     /** Splits a raw imported cell and joins on export. Omitted: import auto-detects, export joins with `", "`. */
     delimiter?: string;
 };
-/** Number input cell with locale-aware formatting. */
+/** Number input cell with locale-aware formatting. Bounds and decimal digits come from the column's `{ type: "number" }` validator. */
 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.
+ * - `"date"` — date picker; the calendar honours the column's date validator bounds.
  * - `"select"` — dropdown with a fixed list of options.
  * - `"multiselect"` — dropdown allowing zero or more options; stored as `string[]`.
  * - `"number"` — number input with locale-aware formatting.
@@ -903,7 +781,7 @@ type ColumnLockMode = "all" | "default";
  *   { 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" }, { type: "unique" }] },
  *   { 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}` : "" },
+ *   { id: "salary", title: "Salary", validators: [{ type: "number", message: "Must be a number" }], formatter: (v) => v ? `$${v}` : "" },
  * ];
  * ```
  */
@@ -914,11 +792,9 @@ type DataEditorColumn = {
     title: string;
     /**
      * One or more validators run on every edit. Accepts:
-     * - Built-in object literals: `{ type: "required" | "email" | "regex" | "range" | "oneOf" | "date" | "numeric" | "unique", ... }`.
-     * - `{ 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.
+     * - Built-in object literals: `{ type: "required" | "email" | "regex" | "number" | "oneOf" | "date" | "unique", ... }`.
+     * - `{ type: "function", fn }` — a JS predicate run inline.
+     * - `{ type: "asyncFunction", fn }` — batched remote checks.
      */
     validators?: ValidatorRule[];
     /**
@@ -955,360 +831,91 @@ type DataEditorColumn = {
     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.
+ * A built-in declarative validator — a declarative object the SDK interprets.
  */
-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 BuiltInValidator = {
+    type: "required";
+    message?: string;
+} | {
+    type: "regex";
+    pattern: string;
+    flags?: string;
+    message?: string;
+} | {
+    type: "oneOf";
+    values: string[];
+    message?: string;
+} | {
+    type: "number";
+    /** Inclusive lower bound. */
+    min?: number;
+    /** Inclusive upper bound. */
+    max?: number;
+    /** Maximum decimal digits; `0` means integers. Values with more are flagged, never rounded. */
+    decimalPlaces?: number;
+    message?: string;
+} | {
+    type: "email";
+    message?: string;
+} | {
+    type: "date";
+    min?: string;
+    max?: string;
+    message?: string;
+} | {
+    type: "unique";
+    message?: string;
+    fn?: UniqueRemoteFn;
 };
-type ServerCallOptions = {
-    signal: AbortSignal;
+/** One cell in an asyncFunction batch. Row is passed by reference. */
+type AsyncValidatorCell = {
+    /** Value of the validated column for this cell. */
+    value: unknown;
+    /** The full row — for row-dependent checks. */
+    row: DataEditorRow;
 };
 /**
- * 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.
+ * Remote existence check for `{ type: "unique" }`. Called once per sweep
+ * with all distinct candidate values; report the subset that already exists —
+ * return it and/or stream it via onChunk (results are unioned). `signal`
+ * fires only when results can no longer be used. Client-mode only.
  */
-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[];
+type UniqueRemoteFn = (values: unknown[], onChunk: (existing: unknown[]) => void, signal: AbortSignal) => Promise<unknown[] | void>;
+type AsyncFunctionValidator = {
+    type: "asyncFunction";
+    /**
+     * Called once per column per operation with every affected cell. Report
+     * failures by `index` into `cells`: return an array aligned with the input
+     * (null = valid) and/or stream sparse failures via onChunk (unioned, any
+     * order). `signal` fires only when results can no longer be used.
+     * Client-mode only. For uniqueness use `unique.fn`, not this.
+     */
+    fn: (cells: AsyncValidatorCell[], onChunk: (failures: {
+        index: number;
+        error: ValidationError;
+    }[]) => void, signal: AbortSignal) => Promise<(ValidationError | null)[] | void>;
 };
 /**
- * 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.
+ * Escape hatch: a JS predicate run inline against the cell value and its row.
  */
-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;
-};
-/** 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;
-    }>;
+type FunctionValidator = {
+    type: "function";
+    fn: CellValidator;
 };
 /**
- * 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.
+ * The validator-rule union accepted by `DataEditorColumn.validators`.
+ *
+ * Named `ValidatorRule` (not `Validator`) so it doesn't clash with the
+ * runtime `Validator` class in `core/Validator.ts`.
  */
-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";
-    /**
-     * Date order detected from the file's date columns. `"EU"` = day-first,
-     * `"US"` = month-first. One verdict for the file, since date order follows
-     * the source locale; ISO values are parsed regardless of this.
-     */
-    dateFormat: "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;
-};
+type ValidatorRule = BuiltInValidator | FunctionValidator | AsyncFunctionValidator;
 /**
- * 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.
+ * Async-check state of a cell, orthogonal to errors/misplaced: "pending"
+ * while a verdict is awaited, "unverified" when the check failed or timed
+ * out. Idle cells carry no entry.
  */
-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 CellAsyncState = "pending" | "unverified";
 
 /**
  * ChunkedProcessor — Generic utility for processing items in prioritized chunks
@@ -1353,33 +960,10 @@ declare class ChunkedProcessor<T> {
     private _pendingChunkFn;
     constructor(chunkSize?: number);
     get isRunning(): boolean;
-    get chunkSize(): number;
     run(params: ChunkedProcessorCallbacks<T>): void;
     cancel(): void;
 }
 
-/**
- * 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;
-};
-
 /**
  * A single operation the LLM wants to apply to rows in the current filtered view.
  *
@@ -1520,12 +1104,10 @@ type DataEditorChat<TRow extends DataEditorRow = DataEditorRow> = {
 
 /**
  * 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).
+ * `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";
+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";
 /**
  * An internal error caught by the SDK and passed to `onError`. The SDK
  * recovers gracefully where possible — `onError` is for your logging and
@@ -1645,272 +1227,29 @@ type UniqueConfig = {
     fn?: UniqueRemoteFn;
 };
 /**
- * Core-internal column shape produced by normalizeUniqueColumns. Uniqueness
+ * Core-internal column shape produced by normalizeColumns. Uniqueness
  * lives in `uniqueConfig` and asyncFunction rules in `asyncConfig` — the
  * single internal sources of truth — never as entries in `validators`.
  * Never exported from the package entry.
  */
-type NormalizedColumn = DataEditorColumn & {
+type NormalizedColumn = Omit<DataEditorColumn, "validators"> & {
+    validators?: ValidatorRule[];
     uniqueConfig?: UniqueConfig;
     asyncConfig?: AsyncFunctionValidator[];
+    numberConfig?: NumberConfig;
+    dateConfig?: DateConfig;
 };
-
-type PrimaryKeyInput = string | readonly string[];
-
-type RegisterSourceOptions = {
-    name: string;
-    id?: DataSourceId;
-    isDeletable?: boolean;
-    isInitialData?: boolean;
-};
-type MergeEntry<TRow> = {
-    row: TRow;
-    sourceId: DataSourceId;
-    isNew: boolean;
-    isEdited: boolean;
-    /** Diff basis the row carried before the merge. Present only when isEdited. */
-    originalRow?: TRow;
-};
-type RemovalPlan<TRow> = {
-    rowsToDelete: Set<TRowId>;
-    rowsToRestore: Array<{
-        rowId: TRowId;
-        row: TRow;
-        originalSourceId: DataSourceId;
-        isNew: boolean;
-        isEdited: boolean;
-        originalRow?: TRow;
-    }>;
-};
-type ExtendedRemovalPlan<TRow> = RemovalPlan<TRow> & {
-    sourceId: DataSourceId;
-    repairedEntries: Array<{
-        sourceId: DataSourceId;
-        rowId: TRowId;
-        before: MergeEntry<TRow>;
-        after: MergeEntry<TRow> | null;
-    }>;
+type NumberConfig = {
+    min?: number;
+    max?: number;
+    decimalPlaces?: number;
 };
-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, originalRow?: TRow): 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;
-};
-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[];
+type DateConfig = {
+    min?: string;
+    max?: 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.
- *
- * Does NOT call `onEdit`. Only builds params.
- * DataStore calls the builder, then sends the result to the server.
- *
- * Responsibilities:
- *   - TRowId → ServerRowId translation via primaryKey
- *   - Grid index → column ID translation via columns array
- *   - Filter/sort context attachment from ServerDataManager
- */
-
-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;
-}
+type PrimaryKeyInput = string | readonly string[];
 
 /**
  * DirtyTracker — Change classification and revert detection for rows.
@@ -1998,7 +1337,6 @@ type IFilterEngine<TRow extends DataEditorRow = DataEditorRow> = {
     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>;
@@ -2130,12 +1468,6 @@ interface SnapshotStateReader {
     getSortState(): SortState;
     getShowOnlyDeletedRows(): boolean;
     getPendingValidationCount(): number;
-    /** Server-provided aggregate counts. Present only in server mode. */
-    getServerEditedCount?(): number;
-    getServerNewCount?(): number;
-    getServerErrorCount?(): number;
-    getServerEmptyCount?(): number;
-    getServerDeletedCount?(): number;
 }
 declare class SnapshotManager {
     private _visibleNewCount;
@@ -2181,6 +1513,81 @@ declare class SnapshotManager {
     private recomputeFilteredCounts;
 }
 
+type RegisterSourceOptions = {
+    name: string;
+    id?: DataSourceId;
+    isDeletable?: boolean;
+    isInitialData?: boolean;
+};
+type MergeEntry<TRow> = {
+    row: TRow;
+    sourceId: DataSourceId;
+    isNew: boolean;
+    isEdited: boolean;
+    /** Diff basis the row carried before the merge. Present only when isEdited. */
+    originalRow?: TRow;
+};
+type RemovalPlan<TRow> = {
+    rowsToDelete: Set<TRowId>;
+    rowsToRestore: Array<{
+        rowId: TRowId;
+        row: TRow;
+        originalSourceId: DataSourceId;
+        isNew: boolean;
+        isEdited: boolean;
+        originalRow?: TRow;
+    }>;
+};
+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, originalRow?: TRow): 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;
+}
+
 /**
  * ValidationStore — Cell-level validation state with incremental count tracking.
  *
@@ -2227,6 +1634,26 @@ type IValidationStore = {
     clear(): 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;
+};
+
 /**
  * AsyncValidationScheduler — facade over the async annotation channel.
  *
@@ -2275,26 +1702,6 @@ type IValidator<TRow extends DataEditorRow = DataEditorRow> = {
     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;
@@ -2316,10 +1723,9 @@ type SourceSnapshot<TRow extends DataEditorRow> = {
     plan: ExtendedRemovalPlan<TRow>;
 };
 type SourceLifecycleHost<TRow extends DataEditorRow> = {
-    getValidator: () => IValidator<TRow> | null;
+    getValidator: () => IValidator<TRow>;
     pushCommand: (cmd: Command<TRow>, cost?: number) => number;
     notify: () => void;
-    isServerStrategy: () => boolean;
     checkRowEmptyCells: (rowId: TRowId) => void;
     clearRowValidations: (rowId: TRowId) => void;
 };
@@ -2350,28 +1756,19 @@ declare class SourceLifecycle<TRow extends DataEditorRow = DataEditorRow> {
 }
 
 /**
- * Fill-level delta computations.
- *
- * 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.
+ * 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[];
+};
 
-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 MultiSelectEditorConfig = {
+    options: string[];
+    delimiter?: string;
+    enableCustomValue?: boolean;
 };
 
 /**
@@ -2389,15 +1786,47 @@ type FillSpec = {
  *   - Large datasets: orchestrator calls computePasteDeltas() per chunk
  */
 
+type MultiSelectTarget = {
+    delimiter: string;
+    editor: MultiSelectEditorConfig;
+};
 type PasteSpec = {
     sourceColumnIds: string[];
     targetColumnIds: string[];
     targetToSource: ReadonlyMap<TRowId, TRowId>;
     selectOptionsMap: ReadonlyMap<string, ReadonlySet<string>>;
+    multiSelectTargets: ReadonlyMap<string, MultiSelectTarget>;
     skipColumnIndices: ReadonlySet<number>;
     isCut: boolean;
 };
 
+/**
+ * Fill-level delta computations.
+ *
+ * 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 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>;
+    /** Multiselect target fields with the delimiter resolved from the source grid. */
+    multiSelectTargets: ReadonlyMap<string, MultiSelectTarget>;
+};
+
 type ApplyFormulaOptions = {
     /**
      * Column IDs to delete AFTER the formula has been applied.
@@ -2414,9 +1843,6 @@ type UpsertOptions = {
     skipRowValidation?: boolean;
 };
 declare class DataStore<TRow extends DataEditorRow = DataEditorRow> {
-    private readonly _mode;
-    isServer(): boolean;
-    isClient(): boolean;
     private rowStore;
     readonly formulaRegistry: FormulaRegistry;
     private _isLoading;
@@ -2430,8 +1856,6 @@ declare class DataStore<TRow extends DataEditorRow = DataEditorRow> {
     private history;
     private validator;
     private valueIndex;
-    private serverCounts;
-    private editBuilder;
     private isUndoRedoing;
     private anchorMapCache;
     private pendingBatchCommands;
@@ -2439,7 +1863,6 @@ declare class DataStore<TRow extends DataEditorRow = DataEditorRow> {
     private _skipNotify;
     private _bulkMode;
     private _editedCells;
-    private _primaryKeyFields;
     /** Columns that are currently locked (pre-locked from schema + user-locked at runtime). */
     private _lockedColumns;
     /** Columns locked via schema definition — user cannot unlock these. */
@@ -2447,12 +1870,8 @@ declare class DataStore<TRow extends DataEditorRow = DataEditorRow> {
     /** 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;
@@ -2467,16 +1886,10 @@ declare class DataStore<TRow extends DataEditorRow = DataEditorRow> {
     private filterRowReader;
     private bulkMutationHost;
     private orchestrator;
-    constructor(mode?: StoreMode, serverInit?: {
-        config: ScaleClientApi<TRow>;
-        sourceLabel: string;
-    }, errorHandler?: ErrorHandler);
-    get mode(): StoreMode;
-    getEditBuilder(): ServerEditBuilder<TRow> | null;
+    constructor(errorHandler?: ErrorHandler);
     getRowId(index: number): TRowId | undefined;
     getLocalRowCount(): number;
     setValidator(validator: IValidator<TRow>): void;
-    setPrimaryKey(key: PrimaryKeyInput): void;
     isColumnLocked(field: string): boolean;
     isColumnPreLocked(field: string): boolean;
     lockColumn(field: string, mode?: ColumnLockMode): void;
@@ -2558,35 +1971,19 @@ declare class DataStore<TRow extends DataEditorRow = DataEditorRow> {
      * Flag rows as deleted. Pushes a command for undo/redo.
      * Rows stay in all stores — they are just excluded from alive-mode filters.
      */
-    deleteRows(rowIds: TRowId[], rowRanges?: [TRowId, TRowId][]): Promise<void>;
+    deleteRows(rowIds: TRowId[]): Promise<void>;
     /**
-     * Delete all visible rows at once. In server mode sends { allSelected: true }
-     * instead of enumerating every row. Locally marks all loaded rows as deleted
-     * and clears the RowStore display list.
+     * Delete all visible rows at once. Marks all loaded rows as deleted.
      */
     deleteAllRows(): Promise<void>;
-    /**
-     * Optimistic bulk delete for server mode. Marks all locally loaded rows
-     * as deleted, clears the RowStore, and adjusts counts.
-     */
-    private deleteAllServer;
     /**
      * Unflag rows (restore from deletion). Pushes a command for undo/redo.
      */
-    restoreRows(rowIds: TRowId[], rowRanges?: [TRowId, TRowId][]): Promise<void>;
+    restoreRows(rowIds: TRowId[]): Promise<void>;
     /**
-     * Restore all deleted rows at once. In server mode sends { allSelected: true }
-     * instead of enumerating every row. Locally clears all deleted flags and
-     * empties the RowStore display list (bin view becomes empty).
+     * Restore all deleted rows at once. Clears every deleted flag.
      */
     restoreAllRows(): Promise<void>;
-    /**
-     * Optimistic bulk restore for server mode. Clears all locally known deleted
-     * flags and empties the RowStore display list (we are in deleted-only view,
-     * so every visible row is being restored out). Server-provided counts will
-     * be authoritative after the sync response arrives.
-     */
-    private restoreAllDeletedServer;
     /**
      * Apply delete flags directly without cost-gating. Called by commands
      * (DeleteRowCommand.redo/undo, restore inline commands) where runHeavy
@@ -2602,16 +1999,13 @@ declare class DataStore<TRow extends DataEditorRow = DataEditorRow> {
     insertRow(sourceId: DataSourceId, row: TRow, position: number): Promise<TRowId>;
     insertRowDirect(rowId: TRowId, row: TRow, sourceId: DataSourceId, position: number): void;
     /**
-     * Ingest a single ServerRow at a specific local position.
-     * Used after the server confirms an insert and returns the full row.
-     * Source counts come from the server via counts.sources — no local source tracking.
+     * Append rows supplied by the client through `loadData`. Date columns are
+     * canonicalised to ISO, number columns to the canonical stored form, and
+     * `column.transformer` runs, matching what a file import does. `appendRows` stays a plain append, so the import path — which
+     * has already normalised through buildImportRow — never transforms twice.
      */
-    insertServerRow(serverRow: ServerRow<TRow>, position: number): TRowId;
-    /**
-     * Server-mode insert: send insert request to server, wait for response,
-     * then ingest the returned row locally. Non-optimistic.
-     */
-    insertRowServer(row: TRow, localPosition: number, anchorRowId: TRowId | undefined, insertPosition: "above" | "below", columnIds: string[]): Promise<TRowId>;
+    appendClientRows(sourceId: DataSourceId, newRows: TRow[]): TRowId[];
+    private normalizeClientRows;
     appendRows(sourceId: DataSourceId, newRows: TRow[], rowIdMap?: Map<number, TRowId>): TRowId[];
     seedInitialChanges(assignedRowIds: TRowId[], currentRows: TRow[], changes: InitialRowChange<TRow>[]): void;
     upsertRows(sourceId: DataSourceId, newRows: TRow[], options?: UpsertOptions): UpsertResult<TRow>;
@@ -2627,7 +2021,8 @@ declare class DataStore<TRow extends DataEditorRow = DataEditorRow> {
      * Called by the orchestrator after all chunks complete, before validation.
      * Deferred per-row work from updateColumnDirect is flushed here in bulk:
      * - rowTextCache cleared once instead of per-row
-     * - checkRevert run for each affected row
+     * - checkRevert and checkRowEmptyCells run for each affected row
+     * - the filter worker gets every affected row's text in one batch
      * - _editedCells populated for FindReplace incremental matching
      */
     flushBulkMode(deltas: ColumnDelta[]): void;
@@ -2640,30 +2035,12 @@ declare class DataStore<TRow extends DataEditorRow = DataEditorRow> {
      */
     getViewportRowIds(): TRowId[];
     getAllFilteredRowIds(): TRowId[];
-    replaceServerRows(sourceId: DataSourceId, serverRows: ServerRow<TRow>[], offset: number, counts?: ServerQueryCounts): void;
-    appendServerRows(serverRows: ServerRow<TRow>[], counts?: ServerQueryCounts): void;
-    prependServerRows(serverRows: ServerRow<TRow>[], newOffset: number, counts?: ServerQueryCounts): void;
-    /**
-     * Seeds DirtyTracker from server-provided row metadata.
-     * For rows with `meta.status.edited`, builds a synthetic original row
-     * 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;
@@ -2694,14 +2071,6 @@ declare class DataStore<TRow extends DataEditorRow = DataEditorRow> {
     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;
@@ -2732,7 +2101,6 @@ declare class DataStore<TRow extends DataEditorRow = DataEditorRow> {
     private _runFormulaOperation;
     private captureDeleteColumnSnapshots;
     private applyDeleteColumnSnapshots;
-    private syncFormulaToServer;
     private transformWorker;
     private initTransformWorker;
     private buildChatOpsCommand;
@@ -2744,21 +2112,17 @@ declare class DataStore<TRow extends DataEditorRow = DataEditorRow> {
     private _applyChatOpsSync;
     private _commitChatOps;
     applyChatRows(incomingRows: Record<string, unknown>[], primaryKey: PrimaryKeyInput): 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;
     purgeField(columnId: string, rowIds?: TRowId[]): void;
     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;
@@ -2798,7 +2162,7 @@ declare class DataStore<TRow extends DataEditorRow = DataEditorRow> {
  * 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. */
+    /** Assigned by CommandHistory.push() and handed back as its return value. */
     id?: number;
     redo(store: DataStore<TRow>, validator: IValidator<TRow>): void;
     undo(store: DataStore<TRow>, validator: IValidator<TRow>): void;
@@ -2827,10 +2191,6 @@ type ColumnDelta = {
     newValues: Map<TRowId, unknown>;
 };
 
-type ScaleServerConfig = {
-    url: string;
-};
-
 /** Numeric row identifier. V8 stores small integers (Smi) inline — no heap allocation. */
 type TRowId = number;
 type SortType = "text" | "number" | "date";
@@ -3384,11 +2744,6 @@ type DataEditorMode = "modal" | "inline";
 type DataEditorCommonProps<TRow extends DataEditorRow = DataEditorRow> = DataEditorBaseProps<TRow> & {
     /** Your Updog license key. Validated on each open. */
     apiKey: string;
-    /**
-     * @internal
-     * Reserved for future server-delegated mode. Not part of the public API.
-     */
-    __server?: ScaleServerConfig;
     /**
      * Controls what the editor stores in `localStorage`. Set to `false` to
      * disable all local storage usage.
@@ -3516,7 +2871,7 @@ declare function exportDataEditor<TRow extends DataEditorRow>(params: ExportPara
  * />
  * ```
  */
-declare function DataEditor<TRow extends DataEditorRow = DataEditorRow>(allProps: DataEditorProps<TRow>): react_jsx_runtime.JSX.Element;
+declare function DataEditor<TRow extends DataEditorRow = DataEditorRow>(allProps: DataEditorProps<TRow>): react.JSX.Element;
 
 export { DataEditor, downloadExampleFile, exportDataEditor };
 export type { CellValidator, ChatContext, ChatErrorSummary, ChatResponseChunk, ChatRow, ChatRowStatus, ChunkSourceOptions, CustomImportFormat, CustomImportTable, DataEditorChat, DataEditorColumn, DataEditorFormat, DataEditorInlineProps, DataEditorLocalStorage, DataEditorModalProps, DataEditorMode, DataEditorProps, DataEditorResult, DataEditorRow, DataEditorSourceResult, DataEditorTranslations, DataEditorVariant, InitialRowChange, RemoteSource, ResultRow, UpdogError, UpdogErrorCode, ValidationError, ValueMatchInput, ValueMatchOutput };