@gp-grid/core 0.8.3 → 0.9.0

package/dist/index.d.ts

@@ -159,6 +159,59 @@ interface HighlightingOptions<TData = Record<string, unknown>> {
   computeCellClasses?: (context: HighlightContext<TData>) => string[];
 }
 //#endregion
+//#region src/types/renderers.d.ts
+/** Cell renderer params */
+interface CellRendererParams<TData extends Row = Row> {
+  /** Cell value */
+  value: CellValue;
+  /** Row data */
+  rowData: TData;
+  /** Column definition */
+  column: ColumnDefinition;
+  /** Row index */
+  rowIndex: number;
+  /** Column index */
+  colIndex: number;
+  /** Is active cell */
+  isActive: boolean;
+  /** Is selected cell */
+  isSelected: boolean;
+  /** Is editing cell */
+  isEditing: boolean;
+}
+/** Edit renderer params */
+interface EditRendererParams<TData extends Row = Row> extends CellRendererParams<TData> {
+  /** Initial value */
+  initialValue: CellValue;
+  /** On value change */
+  onValueChange: (newValue: CellValue) => void;
+  /** On commit */
+  onCommit: () => void;
+  /** On cancel */
+  onCancel: () => void;
+}
+/** Header renderer params */
+interface HeaderRendererParams {
+  /** Column definition */
+  column: ColumnDefinition;
+  /** Column index */
+  colIndex: number;
+  /** Sort direction */
+  sortDirection?: SortDirection;
+  /** Sort index */
+  sortIndex?: number;
+  /** Whether column is sortable */
+  sortable: boolean;
+  /** Whether column is filterable */
+  filterable: boolean;
+  /** Whether column has an active filter */
+  hasFilter: boolean;
+  /** On sort */
+  onSort: (direction: SortDirection | null, addToExisting: boolean) => void;
+  /** On filter click */
+  onFilterClick: () => void;
+}
+//#endregion
 //#region src/types/columns.d.ts
 /** Column definition */
 interface ColumnDefinition {
@@ -174,10 +227,20 @@ interface ColumnDefinition {
   filterable?: boolean;
   /** Whether column is hidden. Hidden columns are not rendered but still exist in the definition. Default: false */
   hidden?: boolean;
+  /** Whether column is resizable by dragging the header edge. Default: true */
+  resizable?: boolean;
+  /** Minimum width in pixels when resizing. Default: 50 */
+  minWidth?: number;
+  /** Maximum width in pixels when resizing. Default: undefined (no limit) */
+  maxWidth?: number;
+  /** Whether column can be moved/reordered by dragging the header. Default: true */
+  movable?: boolean;
+  /** Whether this column acts as a drag handle for row dragging. Default: false */
+  rowDrag?: boolean;
   /** Renderer key for adapter lookup, or inline renderer function */
-  cellRenderer?: string;
-  editRenderer?: string;
-  headerRenderer?: string;
+  cellRenderer?: string | ((params: CellRendererParams) => unknown);
+  editRenderer?: string | ((params: EditRendererParams) => unknown);
+  headerRenderer?: string | ((params: HeaderRendererParams) => unknown);
   /**
    * Per-column override for column-level highlighting.
    * If defined, overrides grid-level computeColumnClasses for this column.
@@ -362,10 +425,6 @@ interface UpdateHeaderInstruction {
   column: ColumnDefinition;
   sortDirection?: SortDirection;
   sortIndex?: number;
-  /** Whether column is sortable */
-  sortable: boolean;
-  /** Whether column is filterable */
-  filterable: boolean;
   /** Whether column has an active filter */
   hasFilter: boolean;
 }
@@ -450,65 +509,83 @@ interface TransactionProcessedInstruction {
   removed: number;
   updated: number;
 }
-/** Union type of all instructions */
-type GridInstruction = /** Slot lifecycle */CreateSlotInstruction | DestroySlotInstruction | AssignSlotInstruction | MoveSlotInstruction /** Selection */ | SetActiveCellInstruction | SetSelectionRangeInstruction | UpdateVisibleRangeInstruction /** Highlighting */ | SetHoverPositionInstruction /** Editing */ | StartEditInstruction | StopEditInstruction | CommitEditInstruction /** Layout */ | SetContentSizeInstruction | UpdateHeaderInstruction /** Filter popup */ | OpenFilterPopupInstruction | CloseFilterPopupInstruction /** Fill handle */ | StartFillInstruction | UpdateFillInstruction | CommitFillInstruction | CancelFillInstruction /** Data */ | DataLoadingInstruction | DataLoadedInstruction | DataErrorInstruction /** Transactions */ | RowsAddedInstruction | RowsRemovedInstruction | RowsUpdatedInstruction | TransactionProcessedInstruction;
-/** Instruction listener: Single instruction Listener that receives a single instruction, used by frameworks to update their state */
-type InstructionListener = (instruction: GridInstruction) => void;
-/** Batch instruction listener: Batch instruction Listener that receives an array of instructions, used by frameworks to update their state */
-type BatchInstructionListener = (instructions: GridInstruction[]) => void;
-//#endregion
-//#region src/types/renderers.d.ts
-/** Cell renderer params */
-interface CellRendererParams<TData extends Row = Row> {
-  /** Cell value */
-  value: CellValue;
-  /** Row data */
-  rowData: TData;
-  /** Column definition */
-  column: ColumnDefinition;
-  /** Row index */
-  rowIndex: number;
-  /** Column index */
+/** Columns changed (after resize, reorder, etc.) */
+interface ColumnsChangedInstruction {
+  type: "COLUMNS_CHANGED";
+  columns: ColumnDefinition[];
+}
+/** Column resize started */
+interface StartColumnResizeInstruction {
+  type: "START_COLUMN_RESIZE";
   colIndex: number;
-  /** Is active cell */
-  isActive: boolean;
-  /** Is selected cell */
-  isSelected: boolean;
-  /** Is editing cell */
-  isEditing: boolean;
+  initialWidth: number;
 }
-/** Edit renderer params */
-interface EditRendererParams<TData extends Row = Row> extends CellRendererParams<TData> {
-  /** Initial value */
-  initialValue: CellValue;
-  /** On value change */
-  onValueChange: (newValue: CellValue) => void;
-  /** On commit */
-  onCommit: () => void;
-  /** On cancel */
-  onCancel: () => void;
+/** Column resize in progress */
+interface UpdateColumnResizeInstruction {
+  type: "UPDATE_COLUMN_RESIZE";
+  colIndex: number;
+  currentWidth: number;
 }
-/** Header renderer params */
-interface HeaderRendererParams {
-  /** Column definition */
-  column: ColumnDefinition;
-  /** Column index */
+/** Column resize committed */
+interface CommitColumnResizeInstruction {
+  type: "COMMIT_COLUMN_RESIZE";
   colIndex: number;
-  /** Sort direction */
-  sortDirection?: SortDirection;
-  /** Sort index */
-  sortIndex?: number;
-  /** Whether column is sortable */
-  sortable: boolean;
-  /** Whether column is filterable */
-  filterable: boolean;
-  /** Whether column has an active filter */
-  hasFilter: boolean;
-  /** On sort */
-  onSort: (direction: SortDirection | null, addToExisting: boolean) => void;
-  /** On filter click */
-  onFilterClick: () => void;
+  newWidth: number;
+}
+/** Column resize cancelled */
+interface CancelColumnResizeInstruction {
+  type: "CANCEL_COLUMN_RESIZE";
+}
+/** Column move started */
+interface StartColumnMoveInstruction {
+  type: "START_COLUMN_MOVE";
+  sourceColIndex: number;
+}
+/** Column move position updated */
+interface UpdateColumnMoveInstruction {
+  type: "UPDATE_COLUMN_MOVE";
+  currentX: number;
+  currentY: number;
+  dropTargetIndex: number | null;
+}
+/** Column move committed */
+interface CommitColumnMoveInstruction {
+  type: "COMMIT_COLUMN_MOVE";
+  sourceColIndex: number;
+  targetColIndex: number;
+}
+/** Column move cancelled */
+interface CancelColumnMoveInstruction {
+  type: "CANCEL_COLUMN_MOVE";
+}
+/** Row drag started */
+interface StartRowDragInstruction {
+  type: "START_ROW_DRAG";
+  sourceRowIndex: number;
+}
+/** Row drag position updated */
+interface UpdateRowDragInstruction {
+  type: "UPDATE_ROW_DRAG";
+  currentX: number;
+  currentY: number;
+  dropTargetIndex: number | null;
+}
+/** Row drag committed */
+interface CommitRowDragInstruction {
+  type: "COMMIT_ROW_DRAG";
+  sourceRowIndex: number;
+  targetRowIndex: number;
+}
+/** Row drag cancelled */
+interface CancelRowDragInstruction {
+  type: "CANCEL_ROW_DRAG";
 }
+/** Union type of all instructions */
+type GridInstruction = /** Slot lifecycle */CreateSlotInstruction | DestroySlotInstruction | AssignSlotInstruction | MoveSlotInstruction /** Selection */ | SetActiveCellInstruction | SetSelectionRangeInstruction | UpdateVisibleRangeInstruction /** Highlighting */ | SetHoverPositionInstruction /** Editing */ | StartEditInstruction | StopEditInstruction | CommitEditInstruction /** Layout */ | SetContentSizeInstruction | UpdateHeaderInstruction /** Filter popup */ | OpenFilterPopupInstruction | CloseFilterPopupInstruction /** Fill handle */ | StartFillInstruction | UpdateFillInstruction | CommitFillInstruction | CancelFillInstruction /** Data */ | DataLoadingInstruction | DataLoadedInstruction | DataErrorInstruction /** Transactions */ | RowsAddedInstruction | RowsRemovedInstruction | RowsUpdatedInstruction | TransactionProcessedInstruction /** Column changes */ | ColumnsChangedInstruction /** Column resize */ | StartColumnResizeInstruction | UpdateColumnResizeInstruction | CommitColumnResizeInstruction | CancelColumnResizeInstruction /** Column move */ | StartColumnMoveInstruction | UpdateColumnMoveInstruction | CommitColumnMoveInstruction | CancelColumnMoveInstruction /** Row drag */ | StartRowDragInstruction | UpdateRowDragInstruction | CommitRowDragInstruction | CancelRowDragInstruction;
+/** Instruction listener: Single instruction Listener that receives a single instruction, used by frameworks to update their state */
+type InstructionListener = (instruction: GridInstruction) => void;
+/** Batch instruction listener: Batch instruction Listener that receives an array of instructions, used by frameworks to update their state */
+type BatchInstructionListener = (instructions: GridInstruction[]) => void;
 //#endregion
 //#region src/types/options.d.ts
 /** Grid core options */
@@ -533,6 +610,14 @@ interface GridCoreOptions<TData = Row> {
   highlighting?: HighlightingOptions<TData>;
   /** Called when a cell value is changed via editing or fill drag. Requires getRowId. */
   onCellValueChanged?: (event: CellValueChangedEvent<TData>) => void;
+  /** Whether clicking and dragging any cell in a row drags the entire row instead of starting selection. Default: false */
+  rowDragEntireRow?: boolean;
+  /** Called when a row is dropped after dragging. Consumer is responsible for data reordering. */
+  onRowDragEnd?: (sourceIndex: number, targetIndex: number) => void;
+  /** Called when a column is resized. */
+  onColumnResized?: (colIndex: number, newWidth: number) => void;
+  /** Called when a column is moved/reordered. */
+  onColumnMoved?: (fromIndex: number, toIndex: number) => void;
 }
 //#endregion
 //#region src/types/input.d.ts
@@ -586,7 +671,7 @@ interface InputResult {
   /** Whether framework should focus the container element */
   focusContainer?: boolean;
   /** Type of drag operation to start (framework manages global listeners) */
-  startDrag?: "selection" | "fill";
+  startDrag?: "selection" | "fill" | "column-resize" | "column-move" | "row-drag";
 }
 /** Result from keyboard input handler */
 interface KeyboardResult {
@@ -623,13 +708,39 @@ interface InputHandlerDeps {
    * If not provided, visible index is used directly (no hidden columns).
    */
   getOriginalColumnIndex?: (visibleIndex: number) => number;
+  /** Get column widths array (indexed by visible column) */
+  getColumnWidths?: () => number[];
+}
+/** Column resize drag state */
+interface ColumnResizeDragState {
+  colIndex: number;
+  initialWidth: number;
+  currentWidth: number;
+}
+/** Column move drag state */
+interface ColumnMoveDragState {
+  sourceColIndex: number;
+  currentX: number;
+  currentY: number;
+  dropTargetIndex: number | null;
+  ghostWidth: number;
+  ghostHeight: number;
+}
+/** Row drag state */
+interface RowDragState {
+  sourceRowIndex: number;
+  currentX: number;
+  currentY: number;
+  dropTargetIndex: number | null;
+  /** Pre-computed translateY for the drop indicator inside the rows wrapper */
+  dropIndicatorY: number;
 }
 /** Current drag state for UI rendering */
 interface DragState {
   /** Whether any drag operation is active */
   isDragging: boolean;
   /** Type of active drag operation */
-  dragType: "selection" | "fill" | null;
+  dragType: "selection" | "fill" | "column-resize" | "column-move" | "row-drag" | null;
   /** Source range for fill operations */
   fillSourceRange: CellRange | null;
   /** Current fill target position */
@@ -637,85 +748,14 @@ interface DragState {
     row: number;
     col: number;
   } | null;
+  /** Column resize state (when dragType is "column-resize") */
+  columnResize: ColumnResizeDragState | null;
+  /** Column move state (when dragType is "column-move") */
+  columnMove: ColumnMoveDragState | null;
+  /** Row drag state (when dragType is "row-drag") */
+  rowDrag: RowDragState | null;
 }
 //#endregion
-//#region src/utils/positioning.d.ts
-/**
- * Calculate cumulative column positions (prefix sums)
- * Returns an array where positions[i] is the left position of column i
- * positions[columns.length] is the total width
- */
-declare const calculateColumnPositions: (columns: ColumnDefinition[]) => number[];
-/**
- * Get total width from column positions
- */
-declare const getTotalWidth: (columnPositions: number[]) => number;
-/**
- * Calculate scaled column positions when container is wider than total column widths.
- * Columns expand proportionally based on their original width ratios.
- *
- * @param columns - Column definitions with original widths
- * @param containerWidth - Available container width
- * @returns Object with positions array and widths array
- */
-declare const calculateScaledColumnPositions: (columns: ColumnDefinition[], containerWidth: number) => {
-  positions: number[];
-  widths: number[];
-};
-/**
- * Find column index at a given X coordinate
- */
-declare const findColumnAtX: (x: number, columnPositions: number[]) => number;
-//#endregion
-//#region src/utils/classNames.d.ts
-/**
- * Check if a cell is within the selection range
- */
-declare const isCellSelected: (row: number, col: number, selectionRange: CellRange | null) => boolean;
-/**
- * Check if a cell is the active cell
- */
-declare const isCellActive: (row: number, col: number, activeCell: CellPosition | null) => boolean;
-/**
- * Check if a row is within the visible range (not in overscan)
- */
-declare const isRowVisible: (row: number, visibleRowRange: {
-  start: number;
-  end: number;
-} | null) => boolean;
-/**
- * Check if a cell is being edited
- */
-declare const isCellEditing: (row: number, col: number, editingCell: {
-  row: number;
-  col: number;
-} | null) => boolean;
-/**
- * Check if a cell is in the fill preview range (vertical-only fill)
- */
-declare const isCellInFillPreview: (row: number, col: number, isDraggingFill: boolean, fillSourceRange: CellRange | null, fillTarget: {
-  row: number;
-  col: number;
-} | null) => boolean;
-/**
- * Build cell CSS classes based on state
- */
-declare const buildCellClasses: (isActive: boolean, isSelected: boolean, isEditing: boolean, inFillPreview: boolean) => string;
-/**
- * Check if a row overlaps the selection range
- */
-declare const isRowInSelectionRange: (rowIndex: number, range: CellRange | null) => boolean;
-/**
- * Check if a column overlaps the selection range
- */
-declare const isColumnInSelectionRange: (colIndex: number, range: CellRange | null) => boolean;
-//#endregion
-//#region src/utils/event-emitter.d.ts
-/**
- * Batch instruction listener for efficient state updates
- */
-type BatchInstructionListener$1 = (instructions: GridInstruction[]) => void;
-//#endregion
 //#region src/selection.d.ts
 type Direction = "up" | "down" | "left" | "right";
 interface SelectionManagerOptions {
@@ -842,6 +882,30 @@ declare class InputHandler<TData extends Row = Row> {
   private isDraggingFill;
   private fillSourceRange;
   private fillTarget;
+  private isDraggingColumnResize;
+  private resizeColIndex;
+  private resizeStartX;
+  private resizeInitialWidth;
+  private resizeCurrentWidth;
+  private isDraggingColumnMove;
+  private moveSourceColIndex;
+  private moveStartX;
+  private moveStartY;
+  private moveThresholdMet;
+  private moveShiftKey;
+  private moveGhostWidth;
+  private moveGhostHeight;
+  private moveCurrentX;
+  private moveCurrentY;
+  private moveDropTargetIndex;
+  private isDraggingRow;
+  private rowDragSourceIndex;
+  private rowDragStartX;
+  private rowDragStartY;
+  private rowDragThresholdMet;
+  private rowDragCurrentX;
+  private rowDragCurrentY;
+  private rowDragDropTargetIndex;
   constructor(core: GridCore<TData>, deps: InputHandlerDeps);
   /**
    * Update dependencies (called when options change)
@@ -875,12 +939,22 @@ declare class InputHandler<TData extends Row = Row> {
    * Handle header click event (cycle sort direction)
    */
   handleHeaderClick(colId: string, addToExisting: boolean): void;
+  /**
+   * Handle mousedown on the resize handle of a header cell.
+   * Returns InputResult with startDrag: "column-resize".
+   */
+  handleHeaderResizeMouseDown(colIndex: number, colWidth: number, event: PointerEventData): InputResult;
+  /**
+   * Handle mousedown on a header cell for potential column move.
+   * Uses a drag threshold to distinguish click (sort) vs drag (move).
+   */
+  handleHeaderMouseDown(colIndex: number, colWidth: number, colHeight: number, event: PointerEventData): InputResult;
   /**
    * Start selection drag (called by framework after handleCellMouseDown returns startDrag: 'selection')
    */
   startSelectionDrag(): void;
   /**
-   * Handle drag move event (selection or fill)
+   * Handle drag move event (selection, fill, column-resize, column-move, or row-drag)
    */
   handleDragMove(event: PointerEventData, bounds: ContainerBounds): DragMoveResult | null;
   /**
@@ -908,7 +982,7 @@ declare class InputHandler<TData extends Row = Row> {
   private calculateAutoScroll;
 }
 //#endregion
-//#region src/highlight-manager.d.ts
+//#region src/managers/highlight-manager.d.ts
 interface HighlightManagerOptions {
   getActiveCell: () => CellPosition | null;
   getSelectionRange: () => CellRange | null;
@@ -995,121 +1069,50 @@ declare class HighlightManager<TData = Record<string, unknown>> {
   destroy(): void;
 }
 //#endregion
-//#region src/sort-filter-manager.d.ts
-interface SortFilterManagerOptions<TData> {
-  /** Get all columns */
-  getColumns: () => ColumnDefinition[];
-  /** Check if sorting is enabled globally */
-  isSortingEnabled: () => boolean;
-  /** Get cached rows for distinct value computation */
+//#region src/managers/row-mutation-manager.d.ts
+interface RowMutationManagerOptions<TData> {
+  /** Get the cached rows map */
   getCachedRows: () => Map<number, TData>;
-  /** Called when sort/filter changes to trigger data refresh */
-  onSortFilterChange: () => Promise<void>;
-  /** Called after data refresh to update UI */
-  onDataRefreshed: () => void;
+  /** Set the cached rows map (for bulk operations) */
+  setCachedRows: (rows: Map<number, TData>) => void;
+  /** Get total row count */
+  getTotalRows: () => number;
+  /** Set total row count */
+  setTotalRows: (count: number) => void;
+  /** Update a single slot after row change */
+  updateSlot: (rowIndex: number) => void;
+  /** Refresh all slots after bulk changes */
+  refreshAllSlots: () => void;
+  /** Emit content size change */
+  emitContentSize: () => void;
+  /** Clear selection if it references invalid rows */
+  clearSelectionIfInvalid: (maxValidRow: number) => void;
 }
 /**
- * Manages sorting and filtering state and operations.
+ * Manages row CRUD operations and cache management.
  */
-declare class SortFilterManager<TData = Record<string, unknown>> {
+declare class RowMutationManager<TData extends Row = Row> {
   private options;
   private emitter;
-  private sortModel;
-  private filterModel;
-  private openFilterColIndex;
   onInstruction: (listener: InstructionListener) => () => void;
   private emit;
-  constructor(options: SortFilterManagerOptions<TData>);
-  setSort(colId: string, direction: SortDirection | null, addToExisting?: boolean): Promise<void>;
-  getSortModel(): SortModel[];
-  setFilter(colId: string, filter: ColumnFilterModel | string | null): Promise<void>;
-  getFilterModel(): FilterModel;
+  constructor(options: RowMutationManagerOptions<TData>);
   /**
-   * Check if a column has an active filter
+   * Get a row by index.
    */
-  hasActiveFilter(colId: string): boolean;
+  getRow(index: number): TData | undefined;
   /**
-   * Check if a column is sortable
+   * Add rows to the grid at the specified index.
+   * If no index is provided, rows are added at the end.
    */
-  isColumnSortable(colIndex: number): boolean;
+  addRows(rows: TData[], index?: number): void;
   /**
-   * Check if a column is filterable
+   * Update existing rows with partial data.
    */
-  isColumnFilterable(colIndex: number): boolean;
-  /**
-   * Get distinct values for a column (for filter dropdowns)
-   * For array-type columns (like tags), each unique array combination is returned.
-   * Arrays are sorted internally for consistent comparison.
-   * Limited to maxValues to avoid performance issues with large datasets.
-   */
-  getDistinctValuesForColumn(colId: string, maxValues?: number): CellValue[];
-  /**
-   * Open filter popup for a column (toggles if already open for same column)
-   */
-  openFilterPopup(colIndex: number, anchorRect: {
-    top: number;
-    left: number;
-    width: number;
-    height: number;
-  }): void;
-  /**
-   * Close filter popup
-   */
-  closeFilterPopup(): void;
-  /**
-   * Get sort info map for header rendering
-   */
-  getSortInfoMap(): Map<string, {
-    direction: SortDirection;
-    index: number;
-  }>;
-  destroy(): void;
-}
-//#endregion
-//#region src/row-mutation-manager.d.ts
-interface RowMutationManagerOptions<TData> {
-  /** Get the cached rows map */
-  getCachedRows: () => Map<number, TData>;
-  /** Set the cached rows map (for bulk operations) */
-  setCachedRows: (rows: Map<number, TData>) => void;
-  /** Get total row count */
-  getTotalRows: () => number;
-  /** Set total row count */
-  setTotalRows: (count: number) => void;
-  /** Update a single slot after row change */
-  updateSlot: (rowIndex: number) => void;
-  /** Refresh all slots after bulk changes */
-  refreshAllSlots: () => void;
-  /** Emit content size change */
-  emitContentSize: () => void;
-  /** Clear selection if it references invalid rows */
-  clearSelectionIfInvalid: (maxValidRow: number) => void;
-}
-/**
- * Manages row CRUD operations and cache management.
- */
-declare class RowMutationManager<TData extends Row = Row> {
-  private options;
-  private emitter;
-  onInstruction: (listener: InstructionListener) => () => void;
-  private emit;
-  constructor(options: RowMutationManagerOptions<TData>);
-  /**
-   * Get a row by index.
-   */
-  getRow(index: number): TData | undefined;
-  /**
-   * Add rows to the grid at the specified index.
-   * If no index is provided, rows are added at the end.
-   */
-  addRows(rows: TData[], index?: number): void;
-  /**
-   * Update existing rows with partial data.
-   */
-  updateRows(updates: Array<{
-    index: number;
-    data: Partial<TData>;
-  }>): void;
+  updateRows(updates: Array<{
+    index: number;
+    data: Partial<TData>;
+  }>): void;
   /**
    * Delete rows at the specified indices.
    */
@@ -1122,88 +1125,29 @@ declare class RowMutationManager<TData extends Row = Row> {
   destroy(): void;
 }
 //#endregion
-//#region src/grid-core.d.ts
-declare class GridCore<TData extends Row = Row> {
-  private columns;
-  private dataSource;
-  private rowHeight;
-  private headerHeight;
-  private overscan;
-  private sortingEnabled;
-  private getRowId?;
-  private onCellValueChanged?;
-  private scrollTop;
-  private scrollLeft;
-  private viewportWidth;
-  private viewportHeight;
-  private cachedRows;
-  private totalRows;
-  private currentPageIndex;
-  private pageSize;
-  readonly selection: SelectionManager;
-  readonly fill: FillManager;
-  readonly input: InputHandler<TData>;
-  readonly highlight: HighlightManager<TData> | null;
-  readonly sortFilter: SortFilterManager<TData>;
-  readonly rowMutation: RowMutationManager<TData>;
-  private readonly slotPool;
-  private readonly editManager;
-  private columnPositions;
-  private emitter;
-  onInstruction: (listener: InstructionListener) => () => void;
-  onBatchInstruction: (listener: BatchInstructionListener$1) => () => void;
-  private emit;
-  private emitBatch;
+//#region src/managers/scroll-virtualization-manager.d.ts
+interface ScrollVirtualizationManagerOptions {
+  getRowHeight: () => number;
+  getHeaderHeight: () => number;
+  getTotalRows: () => number;
+  getScrollTop: () => number;
+  getViewportHeight: () => number;
+}
+declare class ScrollVirtualizationManager {
   private naturalContentHeight;
   private virtualContentHeight;
   private scrollRatio;
-  private isDestroyed;
-  private _isDataLoading;
-  constructor(options: GridCoreOptions<TData>);
-  /**
-   * Initialize the grid and load initial data.
-   */
-  initialize(): Promise<void>;
+  private readonly options;
+  constructor(options: ScrollVirtualizationManagerOptions);
   /**
-   * Update viewport measurements and sync slots.
-   * When scroll virtualization is active, maps the DOM scroll position to the actual row position.
+   * Update scroll virtualization state based on current row count.
+   * Should be called whenever totalRows changes.
    */
-  setViewport(scrollTop: number, scrollLeft: number, width: number, height: number): void;
-  private fetchData;
-  private fetchAllData;
-  setSort(colId: string, direction: SortDirection | null, addToExisting?: boolean): Promise<void>;
-  setFilter(colId: string, filter: ColumnFilterModel | string | null): Promise<void>;
-  hasActiveFilter(colId: string): boolean;
-  isColumnSortable(colIndex: number): boolean;
-  isColumnFilterable(colIndex: number): boolean;
-  getDistinctValuesForColumn(colId: string, maxValues?: number): CellValue[];
-  openFilterPopup(colIndex: number, anchorRect: {
-    top: number;
-    left: number;
-    width: number;
-    height: number;
-  }): void;
-  closeFilterPopup(): void;
-  getSortModel(): SortModel[];
-  getFilterModel(): FilterModel;
-  startEdit(row: number, col: number): void;
-  updateEditValue(value: CellValue): void;
-  commitEdit(): void;
-  cancelEdit(): void;
-  getEditState(): EditState | null;
-  getCellValue(row: number, col: number): CellValue;
-  setCellValue(row: number, col: number, value: CellValue): void;
-  private clearSelectionIfInvalid;
-  private computeColumnPositions;
-  private emitContentSize;
-  private emitHeaders;
-  getColumns(): ColumnDefinition[];
-  getColumnPositions(): number[];
-  getRowCount(): number;
-  getRowHeight(): number;
-  getHeaderHeight(): number;
-  getTotalWidth(): number;
-  getTotalHeight(): number;
+  updateContentSize(): {
+    naturalHeight: number;
+    virtualHeight: number;
+    scrollRatio: number;
+  };
   /**
    * Check if scroll scaling is active (large datasets exceeding browser scroll limits).
    * When scaling is active, scrollRatio < 1 and scroll positions are compressed.
@@ -1214,6 +1158,10 @@ declare class GridCore<TData extends Row = Row> {
    * Useful for debugging or displaying actual content size.
    */
   getNaturalHeight(): number;
+  /**
+   * Get the virtual (capped) content height for DOM use.
+   */
+  getVirtualHeight(): number;
   /**
    * Get the scroll ratio used for scroll virtualization.
    * Returns 1 when no virtualization is needed, < 1 when content exceeds browser limits.
@@ -1240,742 +1188,1139 @@ declare class GridCore<TData extends Row = Row> {
    * @param virtualScrollTop Current scroll position from container.scrollTop (virtual/scaled)
    */
   getRowIndexAtDisplayY(viewportY: number, virtualScrollTop: number): number;
-  getRowData(rowIndex: number): TData | undefined;
-  /**
-   * Refresh data from the data source.
-   */
-  refresh(): Promise<void>;
-  /**
-   * Fast-path refresh for transaction-based mutations.
-   * Only re-fetches the visible window instead of all rows.
-   * Use this when data was mutated via MutableDataSource transactions.
-   */
-  refreshFromTransaction(): Promise<void>;
-  /**
-   * Refresh slot display without refetching data.
-   * Useful after in-place data modifications like fill operations.
-   */
-  refreshSlotData(): void;
   /**
-   * Add rows to the grid at the specified index.
-   * If no index is provided, rows are added at the end.
+   * Get the virtual content height for external use
+   * @internal
    */
-  addRows(rows: TData[], index?: number): void;
+  getVirtualContentHeight(): number;
+}
+//#endregion
+//#region src/managers/sort-filter-manager.d.ts
+interface SortFilterManagerOptions<TData> {
+  /** Get all columns */
+  getColumns: () => ColumnDefinition[];
+  /** Check if sorting is enabled globally */
+  isSortingEnabled: () => boolean;
+  /** Get cached rows for distinct value computation */
+  getCachedRows: () => Map<number, TData>;
+  /** Called when sort/filter changes to trigger data refresh */
+  onSortFilterChange: () => Promise<void>;
+  /** Called after data refresh to update UI */
+  onDataRefreshed: () => void;
+}
+/**
+ * Manages sorting and filtering state and operations.
+ */
+declare class SortFilterManager<TData = Record<string, unknown>> {
+  private options;
+  private emitter;
+  private sortModel;
+  private filterModel;
+  private openFilterColIndex;
+  onInstruction: (listener: InstructionListener) => () => void;
+  private emit;
+  constructor(options: SortFilterManagerOptions<TData>);
+  setSort(colId: string, direction: SortDirection | null, addToExisting?: boolean): Promise<void>;
+  getSortModel(): SortModel[];
+  setFilter(colId: string, filter: ColumnFilterModel | string | null): Promise<void>;
+  getFilterModel(): FilterModel;
   /**
-   * Update existing rows with partial data.
+   * Check if a column has an active filter
    */
-  updateRows(updates: Array<{
-    index: number;
-    data: Partial<TData>;
-  }>): void;
+  hasActiveFilter(colId: string): boolean;
   /**
-   * Delete rows at the specified indices.
+   * Check if a column is sortable
    */
-  deleteRows(indices: number[]): void;
+  isColumnSortable(colIndex: number): boolean;
   /**
-   * Get a row by index.
+   * Check if a column is filterable
    */
-  getRow(index: number): TData | undefined;
+  isColumnFilterable(colIndex: number): boolean;
   /**
-   * Set a complete row at the specified index.
-   * Use this for complete row replacement. For partial updates, use updateRows.
+   * Get distinct values for a column (for filter dropdowns)
+   * For array-type columns (like tags), each unique array combination is returned.
+   * Arrays are sorted internally for consistent comparison.
+   * Limited to maxValues to avoid performance issues with large datasets.
    */
-  setRow(index: number, data: TData): void;
+  getDistinctValuesForColumn(colId: string, maxValues?: number): CellValue[];
   /**
-   * Update the data source and refresh.
-   * Preserves grid state (sort, filter, scroll position).
-   * Cancels any active edit and clamps selection to valid range.
+   * Open filter popup for a column (toggles if already open for same column)
    */
-  setDataSource(dataSource: DataSource<TData>): Promise<void>;
+  openFilterPopup(colIndex: number, anchorRect: {
+    top: number;
+    left: number;
+    width: number;
+    height: number;
+  }): void;
   /**
-   * Update columns and recompute layout.
+   * Close filter popup
    */
-  setColumns(columns: ColumnDefinition[]): void;
+  closeFilterPopup(): void;
   /**
-   * Destroy the grid core and release all references.
-   * Call this before discarding the GridCore to ensure proper cleanup.
-   * This method is idempotent - safe to call multiple times.
+   * Get sort info map for header rendering
    */
+  getSortInfoMap(): Map<string, {
+    direction: SortDirection;
+    index: number;
+  }>;
   destroy(): void;
 }
 //#endregion
-//#region src/slot-pool.d.ts
-interface SlotPoolManagerOptions {
-  /** Get current row height */
-  getRowHeight: () => number;
-  /** Get current header height */
-  getHeaderHeight: () => number;
-  /** Get overscan count */
-  getOverscan: () => number;
-  /** Get current scroll top position (natural, not virtual) */
-  getScrollTop: () => number;
-  /** Get viewport height */
-  getViewportHeight: () => number;
-  /** Get total row count */
-  getTotalRows: () => number;
-  /** Get scroll ratio for virtualization (1 = no virtualization) */
-  getScrollRatio: () => number;
-  /** Get virtual content height */
-  getVirtualContentHeight: () => number;
-  /** Get row data by index */
-  getRowData: (rowIndex: number) => Row | undefined;
+//#region src/indexed-data-store/indexed-data-store.d.ts
+interface IndexedDataStoreOptions<TData> {
+  /** Function to extract unique ID from row. Required for mutations. */
+  getRowId: (row: TData) => RowId;
+  /** Custom field accessor for nested properties */
+  getFieldValue?: (row: TData, field: string) => CellValue;
+}
+/** Hash cache for a single row */
+interface RowSortCache {
+  /** Map: sortModelHash -> computed hashes for that sort configuration */
+  hashes: Map<string, number[]>;
 }
 /**
- * Manages the slot pool for virtual scrolling.
- * Handles slot creation, recycling, positioning, and destruction.
+ * Efficient data structure for incremental operations on grid data.
+ * Supports:
+ * - O(1) lookup by row ID
+ * - O(log n) binary insertion to maintain sort order
+ * - Filter state caching with distinct values
+ * - Hash caching for fast sorted comparisons
  */
-declare class SlotPoolManager {
-  private state;
+declare class IndexedDataStore<TData extends Row = Row> {
+  private rows;
+  private rowById;
+  private sortedIndices;
+  private sortModel;
+  private sortModelHash;
+  private filterModel;
+  private filteredIndices;
+  private distinctValues;
+  private rowSortCache;
   private options;
-  private emitter;
-  private isDestroyed;
-  onInstruction: (listener: InstructionListener) => () => void;
-  onBatchInstruction: (listener: BatchInstructionListener$1) => () => void;
-  private emit;
-  private emitBatch;
-  constructor(options: SlotPoolManagerOptions);
+  constructor(initialData: TData[] | undefined, options: IndexedDataStoreOptions<TData>);
   /**
-   * Get the slot ID for a given row index.
+   * Clear all data and internal caches.
+   * Used for proper memory cleanup when the store is no longer needed.
    */
-  getSlotForRow(rowIndex: number): string | undefined;
+  clear(): void;
   /**
-   * Get all current slots.
+   * Replace all data (used for initial load or full refresh).
    */
-  getSlots(): Map<string, SlotState>;
+  setData(data: TData[]): void;
   /**
-   * Synchronize slots with current viewport position.
-   * This implements the slot recycling strategy.
+   * Query data with sorting, filtering, and pagination.
+   * Compatible with DataSource.fetch() interface.
    */
-  syncSlots(): void;
+  query(request: DataSourceRequest): DataSourceResponse<TData>;
   /**
-   * Destroy all slots.
+   * Get row by ID.
    */
-  destroyAllSlots(): void;
+  getRowById(id: RowId): TData | undefined;
   /**
-   * Clean up resources for garbage collection.
-   * This method is idempotent - safe to call multiple times.
+   * Get row by index.
    */
-  destroy(): void;
+  getRowByIndex(index: number): TData | undefined;
   /**
-   * Refresh all slot data without changing which rows are displayed.
-   * Used after filtering/sorting when data changes.
+   * Get total row count (unfiltered).
    */
-  refreshAllSlots(): void;
+  getTotalRowCount(): number;
   /**
-   * Update a single slot's data.
+   * Get all rows as a new array.
+   * Used for direct data access when bypassing store's query system.
    */
-  updateSlot(rowIndex: number): void;
+  getAllRows(): TData[];
   /**
-   * Calculate the translateY position for a row.
-   * Handles scroll virtualization for very large datasets.
-   *
-   * When virtualization is active (scrollRatio < 1), we use viewport-relative
-   * positioning to keep translateY values small. This prevents browser rendering
-   * issues that occur at extreme pixel values (millions of pixels).
-   *
-   * Note: The header is rendered outside the content sizer, so row positions
-   * start at 0 (not headerHeight) within the rows container.
+   * Move a row from one position to another in the raw data array.
+   * This reorders the underlying data; when no sort is active, the new order
+   * is reflected immediately on the next fetch.
    */
-  private getRowTranslateY;
+  moveRow(fromIndex: number, toIndex: number): void;
   /**
-   * Get the Y offset for the rows wrapper container.
-   * When virtualization is active, this positions the wrapper so rows
-   * with small translateY values appear at the correct scroll position.
+   * Get visible row count (after filtering).
    */
-  getRowsWrapperOffset(): number;
-}
-//#endregion
-//#region src/edit-manager.d.ts
-interface EditManagerOptions {
-  /** Get column definition by index */
-  getColumn: (colIndex: number) => ColumnDefinition | undefined;
-  /** Get cell value */
-  getCellValue: (row: number, col: number) => CellValue;
-  /** Set cell value */
-  setCellValue: (row: number, col: number, value: CellValue) => void;
-  /** Callback when edit is committed (to update slot display) */
-  onCommit?: (row: number, col: number, value: CellValue) => void;
-}
-/**
- * Manages cell editing state and operations.
- */
-declare class EditManager {
-  private editState;
-  private options;
-  private emitter;
-  onInstruction: (listener: InstructionListener) => () => void;
-  private emit;
-  constructor(options: EditManagerOptions);
+  getVisibleRowCount(): number;
   /**
-   * Get the current edit state.
+   * Get distinct values for a field (for filter UI).
    */
-  getState(): EditState | null;
+  getDistinctValues(field: string): CellValue[];
   /**
-   * Check if currently editing.
+   * Add rows to the store.
+   * Rows are inserted at their correct sorted position.
    */
-  isEditing(): boolean;
+  addRows(rows: TData[]): void;
   /**
-   * Check if a specific cell is being edited.
+   * Add a single row.
    */
-  isEditingCell(row: number, col: number): boolean;
+  private addRow;
   /**
-   * Start editing a cell.
-   * Returns true if edit was started, false if cell is not editable.
+   * Remove rows by ID.
    */
-  startEdit(row: number, col: number): boolean;
+  removeRows(ids: RowId[]): void;
   /**
-   * Update the current edit value.
+   * Remove a single row by index.
    */
-  updateValue(value: CellValue): void;
+  private removeRowByIndex;
   /**
-   * Commit the current edit.
-   * Saves the value and closes the editor.
+   * Update indices after a row removal.
    */
-  commit(): void;
+  private reindexAfterRemoval;
   /**
-   * Cancel the current edit.
-   * Discards changes and closes the editor.
+   * Update a cell value.
    */
-  cancel(): void;
+  updateCell(id: RowId, field: string, value: CellValue): void;
   /**
-   * Clean up resources for garbage collection.
+   * Update multiple fields on a row.
    */
-  destroy(): void;
-}
-//#endregion
-//#region src/sorting/parallel-sort-manager.d.ts
-interface ParallelSortOptions {
-  /** Maximum number of workers (default: navigator.hardwareConcurrency || 4) */
-  maxWorkers?: number;
-  /** Threshold for parallel sorting (default: 400000) */
-  parallelThreshold?: number;
-  /** Minimum chunk size (default: 50000) */
-  minChunkSize?: number;
-}
-/**
- * Manages parallel sorting operations using a worker pool.
- * Automatically decides between single-worker and parallel sorting based on data size.
- */
-declare class ParallelSortManager {
-  private pool;
-  private parallelThreshold;
-  private minChunkSize;
-  private isTerminated;
-  constructor(options?: ParallelSortOptions);
+  updateRow(id: RowId, data: Partial<TData>): void;
   /**
-   * Check if the manager is available for use.
+   * Set the sort model. Triggers full re-sort if model changed.
    */
-  isAvailable(): boolean;
+  setSortModel(model: SortModel[]): void;
   /**
-   * Terminate all workers and clean up resources.
+   * Get current sort model.
    */
-  terminate(): void;
+  getSortModel(): SortModel[];
   /**
-   * Sort indices using values array.
-   * Automatically uses parallel sorting for large datasets.
+   * Set the filter model.
    */
-  sortIndices(values: number[], direction: SortDirection): Promise<Uint32Array>;
+  setFilterModel(model: FilterModel): void;
   /**
-   * Sort string hashes with collision detection.
-   * Automatically uses parallel sorting for large datasets.
+   * Get current filter model.
    */
-  sortStringHashes(hashChunks: Float64Array[], direction: SortDirection, originalStrings: string[]): Promise<Uint32Array>;
+  getFilterModel(): FilterModel;
   /**
-   * Multi-column sort.
-   * Automatically uses parallel sorting for large datasets.
+   * Rebuild sorted indices (full re-sort).
    */
-  sortMultiColumn(columns: number[][], directions: SortDirection[]): Promise<Uint32Array>;
-  private sortIndicesSingle;
-  private sortStringHashesSingle;
-  private sortMultiColumnSingle;
-  private sortIndicesParallel;
-  private sortStringHashesParallel;
-  private sortMultiColumnParallel;
+  private rebuildSortedIndices;
   /**
-   * Split data into chunks for parallel processing.
+   * Rebuild hash cache for all rows.
    */
-  private splitIntoChunks;
+  private rebuildHashCache;
   /**
-   * Calculate chunk boundaries without copying data.
+   * Compute and cache sort hashes for a row.
    */
-  private calculateChunkBoundaries;
+  private computeRowHashes;
   /**
-   * Detect collisions at chunk boundaries for string sorting.
+   * Compare two rows using cached hashes.
    */
-  private detectBoundaryCollisionsForStrings;
+  private compareRows;
   /**
-   * Resolve hash collisions using localeCompare.
+   * Binary search for insertion position in sortedIndices.
    */
-  private resolveCollisions;
-}
-//#endregion
-//#region src/sorting/worker-pool.d.ts
-interface WorkerPoolOptions {
-  /** Maximum number of workers (default: navigator.hardwareConcurrency ?? 4) */
-  maxWorkers?: number;
-  /** Whether to pre-warm workers on initialization */
-  preWarm?: boolean;
-}
-/**
- * Manages a pool of Web Workers for parallel task execution.
- * Workers are created lazily and reused across operations.
- */
-declare class WorkerPool {
-  private workerCode;
-  private maxWorkers;
-  private workers;
-  private workerUrl;
-  private nextRequestId;
-  private isTerminated;
-  constructor(workerCode: string, options?: WorkerPoolOptions);
+  private binarySearchInsertPosition;
   /**
-   * Get the current pool size (number of active workers).
+   * Rebuild filtered indices.
    */
-  getPoolSize(): number;
+  private rebuildFilteredIndices;
   /**
-   * Get the maximum pool size.
-   */
-  getMaxWorkers(): number;
-  /**
-   * Check if the pool is available for use.
-   */
-  isAvailable(): boolean;
-  /**
-   * Execute a single task on an available worker.
-   * Returns the worker's response.
-   */
-  execute<TRequest extends {
-    id?: number;
-  }, TResponse>(request: TRequest, transferables?: Transferable[]): Promise<TResponse>;
-  /**
-   * Execute multiple tasks in parallel across available workers.
-   * Each task is assigned to a different worker if possible.
-   * Returns results in the same order as the input requests.
-   */
-  executeParallel<TRequest extends {
-    id?: number;
-  }, TResponse>(tasks: Array<{
-    request: TRequest;
-    transferables?: Transferable[];
-  }>): Promise<TResponse[]>;
-  /**
-   * Terminate all workers and clean up resources.
-   */
-  terminate(): void;
-  /**
-   * Pre-warm workers by creating them ahead of time.
+   * Check if a row passes the current filter.
    */
-  private preWarmWorkers;
+  private rowPassesFilter;
   /**
-   * Ensure at least `count` workers exist in the pool.
+   * Get visible indices (filtered + sorted).
    */
-  private ensureWorkers;
+  private getVisibleIndices;
   /**
-   * Get an available worker, creating one if needed.
+   * Rebuild distinct values cache for all fields.
    */
-  private getAvailableWorker;
+  private rebuildDistinctValues;
   /**
-   * Create a new worker and add it to the pool.
+   * Update distinct values when a row is added or removed.
    */
-  private createWorker;
+  private updateDistinctValuesForRow;
   /**
-   * Respawn a failed worker.
+   * Update distinct value for a specific field when cell value changes.
    */
-  private respawnWorker;
+  private updateDistinctValueForField;
 }
 //#endregion
-//#region src/sorting/k-way-merge.d.ts
+//#region src/indexed-data-store/field-helpers.d.ts
 /**
- * Represents a sorted chunk with its values and offset in the original array.
+ * Default field value accessor supporting dot notation.
+ * @example
+ * getFieldValue({ user: { name: "John" } }, "user.name") // "John"
  */
-interface SortedChunk {
-  /** Sorted indices (local to this chunk) */
-  indices: Uint32Array;
-  /** Values for comparison (in same order as indices) */
-  values: Float64Array;
-  /** Offset of this chunk in the original array */
-  offset: number;
-}
+declare function getFieldValue<TData extends Row>(row: TData, field: string): CellValue;
 /**
- * Represents a sorted chunk for multi-column sorting.
+ * Set field value supporting dot notation.
+ * Creates nested objects if they don't exist.
+ * @example
+ * const obj = { user: {} };
+ * setFieldValue(obj, "user.name", "John");
+ * // obj is now { user: { name: "John" } }
  */
-interface MultiColumnSortedChunk {
-  /** Sorted indices (local to this chunk) */
-  indices: Uint32Array;
-  /** Values for comparison - array of columns, each in same order as indices */
-  columns: Float64Array[];
-  /** Sort directions for each column (1 = asc, -1 = desc) */
-  directions: Int8Array;
-  /** Offset of this chunk in the original array */
-  offset: number;
-}
+declare function setFieldValue<TData extends Row>(row: TData, field: string, value: CellValue): void;
+//#endregion
+//#region src/indexed-data-store/sorting.d.ts
 /**
- * Merge multiple sorted chunks into a single sorted result.
- * Uses a min-heap for O(n log k) time complexity.
- *
- * @param chunks - Array of sorted chunks to merge
- * @param direction - Sort direction ('asc' or 'desc')
- * @returns Uint32Array of globally sorted indices
+ * Convert a string to a sortable number using first 10 characters.
+ * Uses base-36 encoding (a-z = 0-25, 0-9 = 26-35).
  */
-declare function kWayMerge(chunks: SortedChunk[], direction: SortDirection): Uint32Array;
+declare function stringToSortableNumber(str: string): number;
 /**
- * Merge multiple sorted chunks for multi-column sorting.
- *
- * @param chunks - Array of multi-column sorted chunks
- * @returns Uint32Array of globally sorted indices
+ * Compare two cell values for sorting.
+ * Handles null/undefined, arrays, numbers, dates, and strings.
  */
-declare function kWayMergeMultiColumn(chunks: MultiColumnSortedChunk[]): Uint32Array;
+declare function compareValues(a: CellValue, b: CellValue): number;
 /**
- * Detect collision runs at chunk boundaries after merge.
- * This is used for string sorting where hashes may collide across chunks.
- *
- * @param chunks - Original sorted chunks with their hash values
- * @param _direction - Sort direction
- * @returns Array of boundary collision positions [start1, end1, start2, end2, ...]
+ * Compute a sortable hash for a cell value.
+ * Used for fast comparisons in sorted indices.
  */
-declare function detectBoundaryCollisions(chunks: SortedChunk[], _direction: SortDirection): Uint32Array;
+declare function computeValueHash(value: CellValue): number;
 //#endregion
-//#region src/data-source/client-data-source.d.ts
-interface ClientDataSourceOptions<TData> {
-  /** Custom field accessor for nested properties */
-  getFieldValue?: (row: TData, field: string) => CellValue;
-  /** Use Web Worker for sorting large datasets (default: true) */
-  useWorker?: boolean;
-  /** Options for parallel sorting (only used when useWorker is true) */
-  parallelSort?: ParallelSortOptions | false;
-}
+//#region src/filtering/index.d.ts
 /**
- * Creates a client-side data source that holds all data in memory.
- * Sorting and filtering are performed client-side.
- * For large datasets, sorting is automatically offloaded to a Web Worker.
+ * Check if two dates are on the same day.
  */
-declare function createClientDataSource<TData extends Row = Row>(data: TData[], options?: ClientDataSourceOptions<TData>): DataSource<TData>;
+declare function isSameDay(date1: Date, date2: Date): boolean;
 /**
- * Convenience function to create a data source from an array.
- * This provides backwards compatibility with the old `rowData` prop.
+ * Evaluate a text filter condition against a cell value.
  */
-declare function createDataSourceFromArray<TData extends Row = Row>(data: TData[]): DataSource<TData>;
-//#endregion
-//#region src/data-source/server-data-source.d.ts
-type ServerFetchFunction<TData> = (request: DataSourceRequest) => Promise<DataSourceResponse<TData>>;
+declare function evaluateTextCondition(cellValue: CellValue, condition: TextFilterCondition): boolean;
 /**
- * Creates a server-side data source that delegates all operations to the server.
- * The fetch function receives sort/filter/pagination params to pass to the API.
+ * Evaluate a number filter condition against a cell value.
  */
-declare function createServerDataSource<TData extends Row = Row>(fetchFn: ServerFetchFunction<TData>): DataSource<TData>;
+declare function evaluateNumberCondition(cellValue: CellValue, condition: NumberFilterCondition): boolean;
+/**
+ * Evaluate a date filter condition against a cell value.
+ */
+declare function evaluateDateCondition(cellValue: CellValue, condition: DateFilterCondition): boolean;
+/**
+ * Evaluate a column filter model against a cell value.
+ * Uses left-to-right evaluation with per-condition operators.
+ */
+declare function evaluateColumnFilter(cellValue: CellValue, filter: ColumnFilterModel): boolean;
+/**
+ * Check if a row passes all filters in a filter model.
+ */
+declare function rowPassesFilter<TData extends Row>(row: TData, filterModel: FilterModel, getFieldValue: (row: TData, field: string) => CellValue): boolean;
 //#endregion
-//#region src/indexed-data-store/indexed-data-store.d.ts
-interface IndexedDataStoreOptions<TData> {
-  /** Function to extract unique ID from row. Required for mutations. */
-  getRowId: (row: TData) => RowId;
-  /** Custom field accessor for nested properties */
-  getFieldValue?: (row: TData, field: string) => CellValue;
+//#region src/managers/transaction-manager.d.ts
+interface AddTransaction<TData> {
+  type: "ADD";
+  rows: TData[];
 }
-/** Hash cache for a single row */
-interface RowSortCache {
-  /** Map: sortModelHash -> computed hashes for that sort configuration */
-  hashes: Map<string, number[]>;
+interface RemoveTransaction {
+  type: "REMOVE";
+  rowIds: RowId[];
+}
+interface UpdateCellTransaction {
+  type: "UPDATE_CELL";
+  rowId: RowId;
+  field: string;
+  value: CellValue;
+}
+interface UpdateRowTransaction<TData> {
+  type: "UPDATE_ROW";
+  rowId: RowId;
+  data: Partial<TData>;
+}
+type Transaction<TData> = AddTransaction<TData> | RemoveTransaction | UpdateCellTransaction | UpdateRowTransaction<TData>;
+interface TransactionResult {
+  added: number;
+  removed: number;
+  updated: number;
+}
+interface TransactionManagerOptions<TData extends Row> {
+  /** Debounce time in milliseconds. Default 50. Set to 0 for sync. */
+  debounceMs: number;
+  /** The indexed data store to apply transactions to */
+  store: IndexedDataStore<TData>;
+  /** Callback when transactions are processed */
+  onProcessed?: (result: TransactionResult) => void;
 }
 /**
- * Efficient data structure for incremental operations on grid data.
- * Supports:
- * - O(1) lookup by row ID
- * - O(log n) binary insertion to maintain sort order
- * - Filter state caching with distinct values
- * - Hash caching for fast sorted comparisons
+ * Manages a queue of data mutations with debounced batch processing.
+ * Supports ADD, REMOVE, UPDATE_CELL, and UPDATE_ROW operations.
  */
-declare class IndexedDataStore<TData extends Row = Row> {
-  private rows;
-  private rowById;
-  private sortedIndices;
-  private sortModel;
-  private sortModelHash;
-  private filterModel;
-  private filteredIndices;
-  private distinctValues;
-  private rowSortCache;
+declare class TransactionManager<TData extends Row = Row> {
+  private queue;
+  private debounceTimer;
+  private pendingPromise;
   private options;
-  constructor(initialData: TData[] | undefined, options: IndexedDataStoreOptions<TData>);
+  constructor(options: TransactionManagerOptions<TData>);
   /**
-   * Clear all data and internal caches.
-   * Used for proper memory cleanup when the store is no longer needed.
+   * Queue rows to be added.
    */
-  clear(): void;
+  add(rows: TData[]): void;
   /**
-   * Replace all data (used for initial load or full refresh).
+   * Queue rows to be removed by ID.
    */
-  setData(data: TData[]): void;
+  remove(rowIds: RowId[]): void;
   /**
-   * Query data with sorting, filtering, and pagination.
-   * Compatible with DataSource.fetch() interface.
+   * Queue a cell update.
    */
-  query(request: DataSourceRequest): DataSourceResponse<TData>;
+  updateCell(rowId: RowId, field: string, value: CellValue): void;
   /**
-   * Get row by ID.
+   * Queue a row update (multiple fields).
    */
-  getRowById(id: RowId): TData | undefined;
+  updateRow(rowId: RowId, data: Partial<TData>): void;
   /**
-   * Get row by index.
+   * Force immediate processing of queued transactions.
+   * Returns a promise that resolves when processing is complete.
    */
-  getRowByIndex(index: number): TData | undefined;
+  flush(): Promise<void>;
   /**
-   * Get total row count (unfiltered).
+   * Check if there are pending transactions.
    */
-  getTotalRowCount(): number;
+  hasPending(): boolean;
   /**
-   * Get all rows as a new array.
-   * Used for direct data access when bypassing store's query system.
+   * Get count of pending transactions.
    */
-  getAllRows(): TData[];
+  getPendingCount(): number;
   /**
-   * Get visible row count (after filtering).
+   * Clear all pending transactions without processing.
    */
-  getVisibleRowCount(): number;
+  clear(): void;
   /**
-   * Get distinct values for a field (for filter UI).
+   * Schedule processing after throttle delay.
+   * Uses throttle pattern: if a timer is already pending, new transactions
+   * are added to the queue but don't reset the timer. This ensures updates
+   * are processed even when they arrive faster than the throttle interval.
    */
-  getDistinctValues(field: string): CellValue[];
+  private scheduleProcessing;
   /**
-   * Add rows to the store.
-   * Rows are inserted at their correct sorted position.
+   * Process all queued transactions.
    */
-  addRows(rows: TData[]): void;
+  private processQueue;
+}
+//#endregion
+//#region src/grid-core.d.ts
+declare class GridCore<TData extends Row = Row> {
+  private columns;
+  private dataSource;
+  private rowHeight;
+  private headerHeight;
+  private overscan;
+  private sortingEnabled;
+  private getRowId?;
+  private onCellValueChanged?;
+  private rowDragEntireRow;
+  private onRowDragEnd?;
+  private onColumnResized?;
+  private onColumnMoved?;
+  private scrollTop;
+  private scrollLeft;
+  private viewportWidth;
+  private viewportHeight;
+  private currentPageIndex;
+  private pageSize;
+  private cachedRows;
+  private totalRows;
+  readonly selection: SelectionManager;
+  readonly fill: FillManager;
+  readonly input: InputHandler<TData>;
+  readonly highlight: HighlightManager<TData> | null;
+  readonly sortFilter: SortFilterManager<TData>;
+  readonly rowMutation: RowMutationManager<TData>;
+  private readonly slotPool;
+  private readonly editManager;
+  private columnPositions;
+  private batchListeners;
+  private instructionBuffer;
+  private readonly scrollVirtualization;
+  private isDestroyed;
+  private _isDataLoading;
+  constructor(options: GridCoreOptions<TData>);
   /**
-   * Add a single row.
+   * Subscribe to batched instructions for efficient React/Vue state updates.
+   * Batch listeners receive arrays of instructions instead of individual ones.
    */
-  private addRow;
+  onBatchInstruction(listener: BatchInstructionListener): () => void;
   /**
-   * Remove rows by ID.
+   * Start buffering instructions. All emit/emitBatch calls will accumulate
+   * into an internal buffer until flushBatch() is called.
    */
-  removeRows(ids: RowId[]): void;
+  private startBatch;
   /**
-   * Remove a single row by index.
+   * Flush buffered instructions to listeners as a single batch, then
+   * stop buffering.
    */
-  private removeRowByIndex;
+  private flushBatch;
+  private emit;
+  private emitBatch;
   /**
-   * Update indices after a row removal.
+   * Initialize the grid and load initial data.
    */
-  private reindexAfterRemoval;
+  initialize(): Promise<void>;
   /**
-   * Update a cell value.
+   * Update viewport measurements and sync slots.
+   * When scroll virtualization is active, maps the DOM scroll position to the actual row position.
    */
-  updateCell(id: RowId, field: string, value: CellValue): void;
+  setViewport(scrollTop: number, scrollLeft: number, width: number, height: number): void;
+  private fetchData;
+  setSort(colId: string, direction: SortDirection | null, addToExisting?: boolean): Promise<void>;
+  setFilter(colId: string, filter: ColumnFilterModel | string | null): Promise<void>;
+  hasActiveFilter(colId: string): boolean;
+  getDistinctValuesForColumn(colId: string, maxValues?: number): CellValue[];
+  openFilterPopup(colIndex: number, anchorRect: {
+    top: number;
+    left: number;
+    width: number;
+    height: number;
+  }): void;
+  closeFilterPopup(): void;
+  getSortModel(): SortModel[];
+  getFilterModel(): FilterModel;
+  startEdit(row: number, col: number): void;
+  updateEditValue(value: CellValue): void;
+  commitEdit(): void;
+  cancelEdit(): void;
+  getEditState(): EditState | null;
+  getCellValue(row: number, col: number): CellValue;
+  setCellValue(row: number, col: number, value: CellValue): void;
+  private clearSelectionIfInvalid;
+  private computeColumnPositions;
+  private emitContentSize;
+  private emitHeaders;
   /**
-   * Update multiple fields on a row.
+   * Set the width of a column and recompute layout.
    */
-  updateRow(id: RowId, data: Partial<TData>): void;
+  setColumnWidth(colIndex: number, width: number): void;
   /**
-   * Set the sort model. Triggers full re-sort if model changed.
+   * Move a column from one index to another and recompute layout.
    */
-  setSortModel(model: SortModel[]): void;
+  moveColumn(fromIndex: number, toIndex: number): void;
   /**
-   * Get current sort model.
+   * Commit a row drag operation. Reorders data if the data source supports it,
+   * then invokes the onRowDragEnd callback.
+   *
+   * Optimized: instead of a full refresh (fetchData + rebuild all slots), we
+   * update the cachedRows map in-place to mirror the splice the data source
+   * performed, then only update the affected slots.
    */
-  getSortModel(): SortModel[];
+  commitRowDrag(sourceIndex: number, targetIndex: number): void;
   /**
-   * Set the filter model.
+   * Whether the entire row is draggable.
    */
-  setFilterModel(model: FilterModel): void;
+  isRowDragEntireRow(): boolean;
+  getColumns(): ColumnDefinition[];
+  getColumnPositions(): number[];
+  getRowCount(): number;
+  getRowHeight(): number;
+  getHeaderHeight(): number;
+  getTotalWidth(): number;
+  getTotalHeight(): number;
+  isScalingActive(): boolean;
+  getNaturalHeight(): number;
+  getScrollRatio(): number;
+  getVisibleRowRange(): {
+    start: number;
+    end: number;
+  };
+  getScrollTopForRow(rowIndex: number): number;
+  getRowIndexAtDisplayY(viewportY: number, virtualScrollTop: number): number;
   /**
-   * Get current filter model.
+   * Get the translateY position for a row inside the rows wrapper.
+   * Accounts for scroll virtualization (compressed coordinates).
    */
-  getFilterModel(): FilterModel;
+  getRowTranslateY(rowIndex: number): number;
+  getRowData(rowIndex: number): TData | undefined;
   /**
-   * Rebuild sorted indices (full re-sort).
+   * Refresh data from the data source.
    */
-  private rebuildSortedIndices;
+  refresh(): Promise<void>;
   /**
-   * Rebuild hash cache for all rows.
+   * Fast-path refresh for transaction-based mutations.
+   * Only re-fetches the visible window instead of all rows.
+   * Use this when data was mutated via MutableDataSource transactions.
    */
-  private rebuildHashCache;
+  refreshFromTransaction(): Promise<void>;
   /**
-   * Compute and cache sort hashes for a row.
+   * Refresh slot display without refetching data.
+   * Useful after in-place data modifications like fill operations.
    */
-  private computeRowHashes;
+  refreshSlotData(): void;
   /**
-   * Compare two rows using cached hashes.
+   * Add rows to the grid at the specified index.
+   * If no index is provided, rows are added at the end.
    */
-  private compareRows;
+  addRows(rows: TData[], index?: number): void;
   /**
-   * Binary search for insertion position in sortedIndices.
+   * Update existing rows with partial data.
    */
-  private binarySearchInsertPosition;
+  updateRows(updates: Array<{
+    index: number;
+    data: Partial<TData>;
+  }>): void;
   /**
-   * Rebuild filtered indices.
+   * Delete rows at the specified indices.
    */
-  private rebuildFilteredIndices;
+  deleteRows(indices: number[]): void;
   /**
-   * Check if a row passes the current filter.
+   * Get a row by index.
    */
-  private rowPassesFilter;
+  getRow(index: number): TData | undefined;
   /**
-   * Get visible indices (filtered + sorted).
+   * Set a complete row at the specified index.
+   * Use this for complete row replacement. For partial updates, use updateRows.
    */
-  private getVisibleIndices;
+  setRow(index: number, data: TData): void;
   /**
-   * Rebuild distinct values cache for all fields.
+   * Update the data source and refresh.
+   * Preserves grid state (sort, filter, scroll position).
+   * Cancels any active edit and clamps selection to valid range.
    */
-  private rebuildDistinctValues;
+  setDataSource(dataSource: DataSource<TData>): Promise<void>;
   /**
-   * Update distinct values when a row is added or removed.
+   * Update columns and recompute layout.
    */
-  private updateDistinctValuesForRow;
+  setColumns(columns: ColumnDefinition[]): void;
   /**
-   * Update distinct value for a specific field when cell value changes.
+   * Destroy the grid core and release all references.
+   * Call this before discarding the GridCore to ensure proper cleanup.
+   * This method is idempotent - safe to call multiple times.
    */
-  private updateDistinctValueForField;
+  destroy(): void;
 }
 //#endregion
-//#region src/indexed-data-store/field-helpers.d.ts
+//#region src/utils/positioning.d.ts
 /**
- * Default field value accessor supporting dot notation.
- * @example
- * getFieldValue({ user: { name: "John" } }, "user.name") // "John"
+ * Calculate cumulative column positions (prefix sums)
+ * Returns an array where positions[i] is the left position of column i
+ * positions[columns.length] is the total width
  */
-declare function getFieldValue<TData extends Row>(row: TData, field: string): CellValue;
+declare const calculateColumnPositions: (columns: ColumnDefinition[]) => number[];
 /**
- * Set field value supporting dot notation.
- * Creates nested objects if they don't exist.
- * @example
- * const obj = { user: {} };
- * setFieldValue(obj, "user.name", "John");
- * // obj is now { user: { name: "John" } }
+ * Get total width from column positions
  */
-declare function setFieldValue<TData extends Row>(row: TData, field: string, value: CellValue): void;
-//#endregion
-//#region src/indexed-data-store/sorting.d.ts
+declare const getTotalWidth: (columnPositions: number[]) => number;
 /**
- * Convert a string to a sortable number using first 10 characters.
- * Uses base-36 encoding (a-z = 0-25, 0-9 = 26-35).
+ * Calculate scaled column positions when container is wider than total column widths.
+ * Columns expand proportionally based on their original width ratios.
+ *
+ * @param columns - Column definitions with original widths
+ * @param containerWidth - Available container width
+ * @returns Object with positions array and widths array
  */
-declare function stringToSortableNumber(str: string): number;
+declare const calculateScaledColumnPositions: (columns: ColumnDefinition[], containerWidth: number) => {
+  positions: number[];
+  widths: number[];
+};
 /**
- * Compare two cell values for sorting.
- * Handles null/undefined, arrays, numbers, dates, and strings.
+ * Find column index at a given X coordinate
  */
-declare function compareValues(a: CellValue, b: CellValue): number;
+declare const findColumnAtX: (x: number, columnPositions: number[]) => number;
+//#endregion
+//#region src/utils/classNames.d.ts
 /**
- * Compute a sortable hash for a cell value.
- * Used for fast comparisons in sorted indices.
+ * Check if a cell is within the selection range
  */
-declare function computeValueHash(value: CellValue): number;
-//#endregion
-//#region src/filtering/index.d.ts
+declare const isCellSelected: (row: number, col: number, selectionRange: CellRange | null) => boolean;
 /**
- * Check if two dates are on the same day.
+ * Check if a cell is the active cell
  */
-declare function isSameDay(date1: Date, date2: Date): boolean;
+declare const isCellActive: (row: number, col: number, activeCell: CellPosition | null) => boolean;
 /**
- * Evaluate a text filter condition against a cell value.
+ * Check if a row is within the visible range (not in overscan)
  */
-declare function evaluateTextCondition(cellValue: CellValue, condition: TextFilterCondition): boolean;
+declare const isRowVisible: (row: number, visibleRowRange: {
+  start: number;
+  end: number;
+} | null) => boolean;
 /**
- * Evaluate a number filter condition against a cell value.
+ * Check if a cell is being edited
  */
-declare function evaluateNumberCondition(cellValue: CellValue, condition: NumberFilterCondition): boolean;
+declare const isCellEditing: (row: number, col: number, editingCell: {
+  row: number;
+  col: number;
+} | null) => boolean;
 /**
- * Evaluate a date filter condition against a cell value.
+ * Check if a cell is in the fill preview range (vertical-only fill)
  */
-declare function evaluateDateCondition(cellValue: CellValue, condition: DateFilterCondition): boolean;
+declare const isCellInFillPreview: (row: number, col: number, isDraggingFill: boolean, fillSourceRange: CellRange | null, fillTarget: {
+  row: number;
+  col: number;
+} | null) => boolean;
 /**
- * Evaluate a column filter model against a cell value.
- * Uses left-to-right evaluation with per-condition operators.
+ * Build cell CSS classes based on state
  */
-declare function evaluateColumnFilter(cellValue: CellValue, filter: ColumnFilterModel): boolean;
+declare const buildCellClasses: (isActive: boolean, isSelected: boolean, isEditing: boolean, inFillPreview: boolean) => string;
 /**
- * Check if a row passes all filters in a filter model.
+ * Check if a row overlaps the selection range
  */
-declare function rowPassesFilter<TData extends Row>(row: TData, filterModel: FilterModel, getFieldValue: (row: TData, field: string) => CellValue): boolean;
+declare const isRowInSelectionRange: (rowIndex: number, range: CellRange | null) => boolean;
+/**
+ * Check if a column overlaps the selection range
+ */
+declare const isColumnInSelectionRange: (colIndex: number, range: CellRange | null) => boolean;
 //#endregion
-//#region src/transaction-manager.d.ts
-interface AddTransaction<TData> {
-  type: "ADD";
-  rows: TData[];
+//#region src/utils/event-emitter.d.ts
+/**
+ * Batch instruction listener for efficient state updates
+ */
+type BatchInstructionListener$1 = (instructions: GridInstruction[]) => void;
+//#endregion
+//#region src/types/ui-state.d.ts
+interface SlotData<TData = Row> {
+  slotId: string;
+  rowIndex: number;
+  rowData: TData;
+  translateY: number;
 }
-interface RemoveTransaction {
-  type: "REMOVE";
-  rowIds: RowId[];
+interface HeaderData {
+  column: ColumnDefinition;
+  sortDirection?: SortDirection;
+  sortIndex?: number;
+  hasFilter: boolean;
 }
-interface UpdateCellTransaction {
-  type: "UPDATE_CELL";
-  rowId: RowId;
-  field: string;
-  value: CellValue;
+interface FilterPopupState {
+  isOpen: boolean;
+  colIndex: number;
+  column: ColumnDefinition | null;
+  anchorRect: {
+    top: number;
+    left: number;
+    width: number;
+    height: number;
+  } | null;
+  distinctValues: CellValue[];
+  currentFilter?: ColumnFilterModel;
 }
-interface UpdateRowTransaction<TData> {
-  type: "UPDATE_ROW";
-  rowId: RowId;
-  data: Partial<TData>;
+interface InitialStateArgs {
+  initialWidth?: number;
+  initialHeight?: number;
 }
-type Transaction<TData> = AddTransaction<TData> | RemoveTransaction | UpdateCellTransaction | UpdateRowTransaction<TData>;
-interface TransactionResult {
-  added: number;
-  removed: number;
-  updated: number;
+declare const createInitialState: <TData = Row>(args?: InitialStateArgs) => GridState<TData>;
+interface GridState<TData = Row> {
+  slots: Map<string, SlotData<TData>>;
+  activeCell: CellPosition | null;
+  selectionRange: CellRange | null;
+  editingCell: {
+    row: number;
+    col: number;
+    initialValue: CellValue;
+  } | null;
+  contentWidth: number;
+  contentHeight: number;
+  /** Viewport width (container's visible width) for column scaling */
+  viewportWidth: number;
+  /** Viewport height (container's visible height) for loader positioning */
+  viewportHeight: number;
+  /** Y offset for rows wrapper when virtualization is active (keeps row translateY values small) */
+  rowsWrapperOffset: number;
+  headers: Map<number, HeaderData>;
+  filterPopup: FilterPopupState | null;
+  isLoading: boolean;
+  error: string | null;
+  totalRows: number;
+  /** Visible row range (start inclusive, end inclusive). Used to prevent selection showing in overscan. */
+  visibleRowRange: {
+    start: number;
+    end: number;
+  } | null;
+  /** Currently hovered cell position (for highlighting) */
+  hoverPosition: CellPosition | null;
+  /** Columns updated by core (after resize/reorder). Null means use props. */
+  columns: ColumnDefinition[] | null;
+}
+//#endregion
+//#region src/utils/scroll-helpers.d.ts
+/**
+ * Find the slot for a given row index
+ */
+declare const findSlotForRow: (slots: Map<string, SlotData>, rowIndex: number) => SlotData | null;
+/**
+ * Scroll a cell into view if needed
+ */
+declare const scrollCellIntoView: (core: {
+  getScrollTopForRow(row: number): number;
+}, container: HTMLDivElement, row: number, rowHeight: number, headerHeight: number, slots: Map<string, SlotData>) => void;
+//#endregion
+//#region src/utils/fill-helpers.d.ts
+interface VisibleColumnInfo {
+  column: ColumnDefinition;
+  originalIndex: number;
+}
+interface FillHandlePosition {
+  top: number;
+  left: number;
+}
+interface CalculateFillHandlePositionParams {
+  activeCell: CellPosition | null;
+  selectionRange: CellRange | null;
+  slots: Map<string, SlotData>;
+  columns: ColumnDefinition[];
+  visibleColumnsWithIndices: VisibleColumnInfo[];
+  columnPositions: number[];
+  columnWidths: number[];
+  rowHeight: number;
+}
+/**
+ * Calculate the fill handle position (bottom-right corner of active cell or selection).
+ * Returns null if no cell is active, columns are not editable, or the target is not visible.
+ */
+declare const calculateFillHandlePosition: (params: CalculateFillHandlePositionParams) => FillHandlePosition | null;
+//#endregion
+//#region src/slot-pool.d.ts
+interface SlotPoolManagerOptions {
+  /** Get current row height */
+  getRowHeight: () => number;
+  /** Get current header height */
+  getHeaderHeight: () => number;
+  /** Get overscan count */
+  getOverscan: () => number;
+  /** Get current scroll top position (natural, not virtual) */
+  getScrollTop: () => number;
+  /** Get viewport height */
+  getViewportHeight: () => number;
+  /** Get total row count */
+  getTotalRows: () => number;
+  /** Get scroll ratio for virtualization (1 = no virtualization) */
+  getScrollRatio: () => number;
+  /** Get virtual content height */
+  getVirtualContentHeight: () => number;
+  /** Get row data by index */
+  getRowData: (rowIndex: number) => Row | undefined;
+}
+/**
+ * Manages the slot pool for virtual scrolling.
+ * Handles slot creation, recycling, positioning, and destruction.
+ */
+declare class SlotPoolManager {
+  private state;
+  private options;
+  private emitter;
+  private isDestroyed;
+  onInstruction: (listener: InstructionListener) => () => void;
+  onBatchInstruction: (listener: BatchInstructionListener$1) => () => void;
+  private emit;
+  private emitBatch;
+  constructor(options: SlotPoolManagerOptions);
+  /**
+   * Get the slot ID for a given row index.
+   */
+  getSlotForRow(rowIndex: number): string | undefined;
+  /**
+   * Get all current slots.
+   */
+  getSlots(): Map<string, SlotState>;
+  /**
+   * Synchronize slots with current viewport position.
+   * This implements the slot recycling strategy.
+   */
+  syncSlots(): void;
+  /**
+   * Destroy all slots.
+   */
+  destroyAllSlots(): void;
+  /**
+   * Clean up resources for garbage collection.
+   * This method is idempotent - safe to call multiple times.
+   */
+  destroy(): void;
+  /**
+   * Refresh all slot data without changing which rows are displayed.
+   * Used after filtering/sorting when data changes.
+   */
+  refreshAllSlots(): void;
+  /**
+   * Update a single slot's data.
+   */
+  updateSlot(rowIndex: number): void;
+  /**
+   * Calculate the translateY position for a row.
+   * Handles scroll virtualization for very large datasets.
+   *
+   * When virtualization is active (scrollRatio < 1), we use viewport-relative
+   * positioning to keep translateY values small. This prevents browser rendering
+   * issues that occur at extreme pixel values (millions of pixels).
+   *
+   * Note: The header is rendered outside the content sizer, so row positions
+   * start at 0 (not headerHeight) within the rows container.
+   */
+  private getRowTranslateY;
+  /**
+   * Get the translateY position for a row inside the rows wrapper.
+   * Public accessor for use by input handler (e.g., drop indicator positioning).
+   */
+  getRowTranslateYForIndex(rowIndex: number): number;
+  /**
+   * Get the Y offset for the rows wrapper container.
+   * When virtualization is active, this positions the wrapper so rows
+   * with small translateY values appear at the correct scroll position.
+   */
+  getRowsWrapperOffset(): number;
+}
+//#endregion
+//#region src/edit-manager.d.ts
+interface EditManagerOptions {
+  /** Get column definition by index */
+  getColumn: (colIndex: number) => ColumnDefinition | undefined;
+  /** Get cell value */
+  getCellValue: (row: number, col: number) => CellValue;
+  /** Set cell value */
+  setCellValue: (row: number, col: number, value: CellValue) => void;
+  /** Callback when edit is committed (to update slot display) */
+  onCommit?: (row: number, col: number, value: CellValue) => void;
+}
+/**
+ * Manages cell editing state and operations.
+ */
+declare class EditManager {
+  private editState;
+  private options;
+  private emitter;
+  onInstruction: (listener: InstructionListener) => () => void;
+  private emit;
+  constructor(options: EditManagerOptions);
+  /**
+   * Get the current edit state.
+   */
+  getState(): EditState | null;
+  /**
+   * Check if currently editing.
+   */
+  isEditing(): boolean;
+  /**
+   * Check if a specific cell is being edited.
+   */
+  isEditingCell(row: number, col: number): boolean;
+  /**
+   * Start editing a cell.
+   * Returns true if edit was started, false if cell is not editable.
+   */
+  startEdit(row: number, col: number): boolean;
+  /**
+   * Update the current edit value.
+   */
+  updateValue(value: CellValue): void;
+  /**
+   * Commit the current edit.
+   * Saves the value and closes the editor.
+   */
+  commit(): void;
+  /**
+   * Cancel the current edit.
+   * Discards changes and closes the editor.
+   */
+  cancel(): void;
+  /**
+   * Clean up resources for garbage collection.
+   */
+  destroy(): void;
+}
+//#endregion
+//#region src/sorting/parallel-sort-manager.d.ts
+interface ParallelSortOptions {
+  /** Maximum number of workers (default: navigator.hardwareConcurrency || 4) */
+  maxWorkers?: number;
+  /** Threshold for parallel sorting (default: 400000) */
+  parallelThreshold?: number;
+  /** Minimum chunk size (default: 50000) */
+  minChunkSize?: number;
+}
+/**
+ * Manages parallel sorting operations using a worker pool.
+ * Automatically decides between single-worker and parallel sorting based on data size.
+ */
+declare class ParallelSortManager {
+  private pool;
+  private parallelThreshold;
+  private minChunkSize;
+  private isTerminated;
+  constructor(options?: ParallelSortOptions);
+  /**
+   * Check if the manager is available for use.
+   */
+  isAvailable(): boolean;
+  /**
+   * Terminate all workers and clean up resources.
+   */
+  terminate(): void;
+  /**
+   * Sort indices using values array.
+   * Automatically uses parallel sorting for large datasets.
+   */
+  sortIndices(values: number[], direction: SortDirection): Promise<Uint32Array>;
+  /**
+   * Sort string hashes with collision detection.
+   * Automatically uses parallel sorting for large datasets.
+   */
+  sortStringHashes(hashChunks: Float64Array[], direction: SortDirection, originalStrings: string[]): Promise<Uint32Array>;
+  /**
+   * Multi-column sort.
+   * Automatically uses parallel sorting for large datasets.
+   */
+  sortMultiColumn(columns: number[][], directions: SortDirection[]): Promise<Uint32Array>;
+  private sortIndicesSingle;
+  private sortStringHashesSingle;
+  private sortMultiColumnSingle;
+  private sortIndicesParallel;
+  private sortStringHashesParallel;
+  private sortMultiColumnParallel;
+  /**
+   * Split data into chunks for parallel processing.
+   */
+  private splitIntoChunks;
+  /**
+   * Calculate chunk boundaries without copying data.
+   */
+  private calculateChunkBoundaries;
+  /**
+   * Detect collisions at chunk boundaries for string sorting.
+   */
+  private detectBoundaryCollisionsForStrings;
+  /**
+   * Resolve hash collisions using localeCompare.
+   */
+  private resolveCollisions;
 }
-interface TransactionManagerOptions<TData extends Row> {
-  /** Debounce time in milliseconds. Default 50. Set to 0 for sync. */
-  debounceMs: number;
-  /** The indexed data store to apply transactions to */
-  store: IndexedDataStore<TData>;
-  /** Callback when transactions are processed */
-  onProcessed?: (result: TransactionResult) => void;
+//#endregion
+//#region src/sorting/worker-pool.d.ts
+interface WorkerPoolOptions {
+  /** Maximum number of workers (default: navigator.hardwareConcurrency ?? 4) */
+  maxWorkers?: number;
+  /** Whether to pre-warm workers on initialization */
+  preWarm?: boolean;
 }
 /**
- * Manages a queue of data mutations with debounced batch processing.
- * Supports ADD, REMOVE, UPDATE_CELL, and UPDATE_ROW operations.
+ * Manages a pool of Web Workers for parallel task execution.
+ * Workers are created lazily and reused across operations.
  */
-declare class TransactionManager<TData extends Row = Row> {
-  private queue;
-  private debounceTimer;
-  private pendingPromise;
-  private options;
-  constructor(options: TransactionManagerOptions<TData>);
+declare class WorkerPool {
+  private workerCode;
+  private maxWorkers;
+  private workers;
+  private workerUrl;
+  private nextRequestId;
+  private isTerminated;
+  constructor(workerCode: string, options?: WorkerPoolOptions);
   /**
-   * Queue rows to be added.
+   * Get the current pool size (number of active workers).
    */
-  add(rows: TData[]): void;
+  getPoolSize(): number;
   /**
-   * Queue rows to be removed by ID.
+   * Get the maximum pool size.
    */
-  remove(rowIds: RowId[]): void;
+  getMaxWorkers(): number;
   /**
-   * Queue a cell update.
+   * Check if the pool is available for use.
    */
-  updateCell(rowId: RowId, field: string, value: CellValue): void;
+  isAvailable(): boolean;
   /**
-   * Queue a row update (multiple fields).
+   * Execute a single task on an available worker.
+   * Returns the worker's response.
    */
-  updateRow(rowId: RowId, data: Partial<TData>): void;
+  execute<TRequest extends {
+    id?: number;
+  }, TResponse>(request: TRequest, transferables?: Transferable[]): Promise<TResponse>;
   /**
-   * Force immediate processing of queued transactions.
-   * Returns a promise that resolves when processing is complete.
+   * Execute multiple tasks in parallel across available workers.
+   * Each task is assigned to a different worker if possible.
+   * Returns results in the same order as the input requests.
    */
-  flush(): Promise<void>;
+  executeParallel<TRequest extends {
+    id?: number;
+  }, TResponse>(tasks: Array<{
+    request: TRequest;
+    transferables?: Transferable[];
+  }>): Promise<TResponse[]>;
   /**
-   * Check if there are pending transactions.
+   * Terminate all workers and clean up resources.
    */
-  hasPending(): boolean;
+  terminate(): void;
   /**
-   * Get count of pending transactions.
+   * Pre-warm workers by creating them ahead of time.
    */
-  getPendingCount(): number;
+  private preWarmWorkers;
   /**
-   * Clear all pending transactions without processing.
+   * Ensure at least `count` workers exist in the pool.
    */
-  clear(): void;
+  private ensureWorkers;
   /**
-   * Schedule processing after throttle delay.
-   * Uses throttle pattern: if a timer is already pending, new transactions
-   * are added to the queue but don't reset the timer. This ensures updates
-   * are processed even when they arrive faster than the throttle interval.
+   * Get an available worker, creating one if needed.
    */
-  private scheduleProcessing;
+  private getAvailableWorker;
   /**
-   * Process all queued transactions.
+   * Create a new worker and add it to the pool.
    */
-  private processQueue;
+  private createWorker;
+  /**
+   * Respawn a failed worker.
+   */
+  private respawnWorker;
+}
+//#endregion
+//#region src/sorting/k-way-merge.d.ts
+/**
+ * Represents a sorted chunk with its values and offset in the original array.
+ */
+interface SortedChunk {
+  /** Sorted indices (local to this chunk) */
+  indices: Uint32Array;
+  /** Values for comparison (in same order as indices) */
+  values: Float64Array;
+  /** Offset of this chunk in the original array */
+  offset: number;
+}
+/**
+ * Represents a sorted chunk for multi-column sorting.
+ */
+interface MultiColumnSortedChunk {
+  /** Sorted indices (local to this chunk) */
+  indices: Uint32Array;
+  /** Values for comparison - array of columns, each in same order as indices */
+  columns: Float64Array[];
+  /** Sort directions for each column (1 = asc, -1 = desc) */
+  directions: Int8Array;
+  /** Offset of this chunk in the original array */
+  offset: number;
+}
+/**
+ * Merge multiple sorted chunks into a single sorted result.
+ * Uses a min-heap for O(n log k) time complexity.
+ *
+ * @param chunks - Array of sorted chunks to merge
+ * @param direction - Sort direction ('asc' or 'desc')
+ * @returns Uint32Array of globally sorted indices
+ */
+declare function kWayMerge(chunks: SortedChunk[], direction: SortDirection): Uint32Array;
+/**
+ * Merge multiple sorted chunks for multi-column sorting.
+ *
+ * @param chunks - Array of multi-column sorted chunks
+ * @returns Uint32Array of globally sorted indices
+ */
+declare function kWayMergeMultiColumn(chunks: MultiColumnSortedChunk[]): Uint32Array;
+/**
+ * Detect collision runs at chunk boundaries after merge.
+ * This is used for string sorting where hashes may collide across chunks.
+ *
+ * @param chunks - Original sorted chunks with their hash values
+ * @param _direction - Sort direction
+ * @returns Array of boundary collision positions [start1, end1, start2, end2, ...]
+ */
+declare function detectBoundaryCollisions(chunks: SortedChunk[], _direction: SortDirection): Uint32Array;
+//#endregion
+//#region src/data-source/client-data-source.d.ts
+interface ClientDataSourceOptions<TData> {
+  /** Custom field accessor for nested properties */
+  getFieldValue?: (row: TData, field: string) => CellValue;
+  /** Use Web Worker for sorting large datasets (default: true) */
+  useWorker?: boolean;
+  /** Options for parallel sorting (only used when useWorker is true) */
+  parallelSort?: ParallelSortOptions | false;
 }
+/**
+ * Creates a client-side data source that holds all data in memory.
+ * Sorting and filtering are performed client-side.
+ * For large datasets, sorting is automatically offloaded to a Web Worker.
+ */
+declare function createClientDataSource<TData extends Row = Row>(data: TData[], options?: ClientDataSourceOptions<TData>): DataSource<TData>;
+/**
+ * Convenience function to create a data source from an array.
+ * This provides backwards compatibility with the old `rowData` prop.
+ */
+declare function createDataSourceFromArray<TData extends Row = Row>(data: TData[]): DataSource<TData>;
+//#endregion
+//#region src/data-source/server-data-source.d.ts
+type ServerFetchFunction<TData> = (request: DataSourceRequest) => Promise<DataSourceResponse<TData>>;
+/**
+ * Creates a server-side data source that delegates all operations to the server.
+ * The fetch function receives sort/filter/pagination params to pass to the API.
+ */
+declare function createServerDataSource<TData extends Row = Row>(fetchFn: ServerFetchFunction<TData>): DataSource<TData>;
 //#endregion
 //#region src/data-source/mutable-data-source.d.ts
 /** Callback for data change notifications */
@@ -2007,6 +2352,8 @@ interface MutableDataSource<TData = Row> extends DataSource<TData> {
   subscribe(listener: DataChangeListener): () => void;
   /** Clear all data from the data source. */
   clear(): void;
+  /** Move a row from one display position to another. */
+  moveRow(fromIndex: number, toIndex: number): void;
 }
 interface MutableClientDataSourceOptions<TData> {
   /** Function to extract unique ID from row. Required. */
@@ -2050,6 +2397,9 @@ declare const scrollbarStyles: string;
 //#region src/styles/filters.d.ts
 declare const filtersStyles: string;
 //#endregion
+//#region src/styles/row-drag.d.ts
+declare const rowDragStyles: string;
+//#endregion
 //#region src/styles/index.d.ts
 /**
  * Combined grid styles from all modules
@@ -2062,63 +2412,13 @@ declare const gridStyles: string;
  */
 declare function injectStyles(): void;
 //#endregion
-//#region src/types/ui-state.d.ts
-interface SlotData<TData = Row> {
-  slotId: string;
-  rowIndex: number;
-  rowData: TData;
-  translateY: number;
-}
-interface HeaderData {
-  column: ColumnDefinition;
-  sortDirection?: SortDirection;
-  sortIndex?: number;
-  sortable: boolean;
-  filterable: boolean;
-  hasFilter: boolean;
-}
-interface FilterPopupState {
-  isOpen: boolean;
-  colIndex: number;
-  column: ColumnDefinition | null;
-  anchorRect: {
-    top: number;
-    left: number;
-    width: number;
-    height: number;
-  } | null;
-  distinctValues: CellValue[];
-  currentFilter?: ColumnFilterModel;
-}
-interface GridState<TData = Row> {
-  slots: Map<string, SlotData<TData>>;
-  activeCell: CellPosition | null;
-  selectionRange: CellRange | null;
-  editingCell: {
-    row: number;
-    col: number;
-    initialValue: CellValue;
-  } | null;
-  contentWidth: number;
-  contentHeight: number;
-  /** Viewport width (container's visible width) for column scaling */
-  viewportWidth: number;
-  /** Viewport height (container's visible height) for loader positioning */
-  viewportHeight: number;
-  /** Y offset for rows wrapper when virtualization is active (keeps row translateY values small) */
-  rowsWrapperOffset: number;
-  headers: Map<number, HeaderData>;
-  filterPopup: FilterPopupState | null;
-  isLoading: boolean;
-  error: string | null;
-  totalRows: number;
-  /** Visible row range (start inclusive, end inclusive). Used to prevent selection showing in overscan. */
-  visibleRowRange: {
-    start: number;
-    end: number;
-  } | null;
-  /** Currently hovered cell position (for highlighting) */
-  hoverPosition: CellPosition | null;
-}
+//#region src/state-reducer.d.ts
+/**
+ * Apply a single instruction to mutable slot/header Maps and return
+ * other state changes as a partial object.
+ *
+ * Returns `null` when only the Maps were mutated (no primitive field changes).
+ */
+declare const applyInstruction: <TData = Row>(instruction: GridInstruction, slots: Map<string, SlotData<TData>>, headers: Map<number, HeaderData>) => Partial<GridState<TData>> | null;
 //#endregion
-export { type AssignSlotInstruction, type BatchInstructionListener, type CancelFillInstruction, type CellDataType, type CellPosition, type CellRange, type CellRendererParams, type CellValue, type CellValueChangedEvent, type CloseFilterPopupInstruction, type ColumnDefinition, type ColumnFilterModel, type CommitEditInstruction, type CommitFillInstruction, type ContainerBounds, type CreateSlotInstruction, type DataChangeListener, type DataErrorInstruction, type DataLoadedInstruction, type DataLoadingInstruction, type DataSource, type DataSourceRequest, type DataSourceResponse, type DateFilterCondition, type DateFilterOperator, type DestroySlotInstruction, type Direction, type DragMoveResult, type DragState, EditManager, type EditManagerOptions, type EditRendererParams, type EditState, type FillHandleState, FillManager, type FilterCombination, type FilterCondition, type FilterModel, type FilterPopupState, GridCore, type GridCoreOptions, type GridInstruction, type GridState, type HeaderData, type HeaderRendererParams, type HighlightContext, HighlightManager, type HighlightingOptions, IndexedDataStore, type IndexedDataStoreOptions, InputHandler, type InputHandlerDeps, type InputResult, type InstructionListener, type KeyEventData, type KeyboardResult, type MoveSlotInstruction, type MultiColumnSortedChunk, type MutableClientDataSourceOptions, type MutableDataSource, type NumberFilterCondition, type NumberFilterOperator, type OpenFilterPopupInstruction, ParallelSortManager, type ParallelSortOptions, type PointerEventData, type Row, type RowId, type RowSortCache, type RowsAddedInstruction, type RowsRemovedInstruction, type RowsUpdatedInstruction, SelectionManager, type SelectionState, type SetActiveCellInstruction, type SetContentSizeInstruction, type SetHoverPositionInstruction, type SetSelectionRangeInstruction, type SlotData, type BatchInstructionListener$1 as SlotPoolBatchListener, SlotPoolManager, type SlotPoolManagerOptions, type SlotState, type SortDirection, type SortModel, type SortedChunk, type StartEditInstruction, type StartFillInstruction, type StopEditInstruction, type TextFilterCondition, type TextFilterOperator, type Transaction, TransactionManager, type TransactionManagerOptions, type TransactionProcessedInstruction, type TransactionResult, type UpdateFillInstruction, type UpdateHeaderInstruction, WorkerPool, type WorkerPoolOptions, buildCellClasses, calculateColumnPositions, calculateScaledColumnPositions, cellStyles, compareValues, computeValueHash, containerStyles, createClientDataSource, createDataSourceFromArray, createMutableClientDataSource, createServerDataSource, detectBoundaryCollisions, evaluateColumnFilter, evaluateDateCondition, evaluateNumberCondition, evaluateTextCondition, filtersStyles, findColumnAtX, getFieldValue, getTotalWidth, gridStyles, headerStyles, injectStyles, isCellActive, isCellEditing, isCellInFillPreview, isCellSelected, isColumnInSelectionRange, isRowInSelectionRange, isRowVisible, isSameDay, kWayMerge, kWayMergeMultiColumn, rowPassesFilter, scrollbarStyles, setFieldValue, statesStyles, stringToSortableNumber, variablesStyles };
+export { type AssignSlotInstruction, type BatchInstructionListener, type CalculateFillHandlePositionParams, type CancelColumnMoveInstruction, type CancelColumnResizeInstruction, type CancelFillInstruction, type CancelRowDragInstruction, type CellDataType, type CellPosition, type CellRange, type CellRendererParams, type CellValue, type CellValueChangedEvent, type CloseFilterPopupInstruction, type ColumnDefinition, type ColumnFilterModel, type ColumnMoveDragState, type ColumnResizeDragState, type ColumnsChangedInstruction, type CommitColumnMoveInstruction, type CommitColumnResizeInstruction, type CommitEditInstruction, type CommitFillInstruction, type CommitRowDragInstruction, type ContainerBounds, type CreateSlotInstruction, type DataChangeListener, type DataErrorInstruction, type DataLoadedInstruction, type DataLoadingInstruction, type DataSource, type DataSourceRequest, type DataSourceResponse, type DateFilterCondition, type DateFilterOperator, type DestroySlotInstruction, type Direction, type DragMoveResult, type DragState, EditManager, type EditManagerOptions, type EditRendererParams, type EditState, type FillHandlePosition, type FillHandleState, FillManager, type FilterCombination, type FilterCondition, type FilterModel, type FilterPopupState, GridCore, type GridCoreOptions, type GridInstruction, type GridState, type HeaderData, type HeaderRendererParams, type HighlightContext, HighlightManager, type HighlightingOptions, IndexedDataStore, type IndexedDataStoreOptions, type InitialStateArgs, InputHandler, type InputHandlerDeps, type InputResult, type InstructionListener, type KeyEventData, type KeyboardResult, type MoveSlotInstruction, type MultiColumnSortedChunk, type MutableClientDataSourceOptions, type MutableDataSource, type NumberFilterCondition, type NumberFilterOperator, type OpenFilterPopupInstruction, ParallelSortManager, type ParallelSortOptions, type PointerEventData, type Row, type RowDragState, type RowId, RowMutationManager, type RowMutationManagerOptions, type RowSortCache, type RowsAddedInstruction, type RowsRemovedInstruction, type RowsUpdatedInstruction, ScrollVirtualizationManager, type ScrollVirtualizationManagerOptions, SelectionManager, type SelectionState, type SetActiveCellInstruction, type SetContentSizeInstruction, type SetHoverPositionInstruction, type SetSelectionRangeInstruction, type SlotData, type BatchInstructionListener$1 as SlotPoolBatchListener, SlotPoolManager, type SlotPoolManagerOptions, type SlotState, type SortDirection, SortFilterManager, type SortFilterManagerOptions, type SortModel, type SortedChunk, type StartColumnMoveInstruction, type StartColumnResizeInstruction, type StartEditInstruction, type StartFillInstruction, type StartRowDragInstruction, type StopEditInstruction, type TextFilterCondition, type TextFilterOperator, type Transaction, TransactionManager, type TransactionManagerOptions, type TransactionProcessedInstruction, type TransactionResult, type UpdateColumnMoveInstruction, type UpdateColumnResizeInstruction, type UpdateFillInstruction, type UpdateHeaderInstruction, type UpdateRowDragInstruction, type VisibleColumnInfo, WorkerPool, type WorkerPoolOptions, applyInstruction, buildCellClasses, calculateColumnPositions, calculateFillHandlePosition, calculateScaledColumnPositions, cellStyles, compareValues, computeValueHash, containerStyles, createClientDataSource, createDataSourceFromArray, createInitialState, createMutableClientDataSource, createServerDataSource, detectBoundaryCollisions, evaluateColumnFilter, evaluateDateCondition, evaluateNumberCondition, evaluateTextCondition, filtersStyles, findColumnAtX, findSlotForRow, getFieldValue, getTotalWidth, gridStyles, headerStyles, injectStyles, isCellActive, isCellEditing, isCellInFillPreview, isCellSelected, isColumnInSelectionRange, isRowInSelectionRange, isRowVisible, isSameDay, kWayMerge, kWayMergeMultiColumn, rowDragStyles, rowPassesFilter, scrollCellIntoView, scrollbarStyles, setFieldValue, statesStyles, stringToSortableNumber, variablesStyles };