@toolbox-web/grid 1.24.2 → 1.25.0

package/lib/core/constants.d.ts

@@ -119,4 +119,3 @@ export declare const GridCSSVars: {
 export type GridClassName = (typeof GridClasses)[keyof typeof GridClasses];
 export type GridDataAttr = (typeof GridDataAttrs)[keyof typeof GridDataAttrs];
 export type GridCSSVar = (typeof GridCSSVars)[keyof typeof GridCSSVars];
-//# sourceMappingURL=constants.d.ts.map

package/lib/core/grid.d.ts

@@ -1,7 +1,8 @@
+import { ShellState } from './internal/shell';
 import { AfterCellRenderContext, AfterRowRenderContext, CellMouseEvent } from './plugin';
 import { BaseGridPlugin, PluginQuery } from './plugin/base-plugin';
 import { PluginManager } from './plugin/plugin-manager';
-import { ColumnConfig, ColumnConfigMap, ColumnInternal, DataGridEventMap, FitMode, FrameworkAdapter, GridColumnState, GridConfig, HeaderContentDefinition, InternalGrid, PluginNameMap, ResizeController, RowAnimationType, ScrollToRowOptions, ToolbarContentDefinition, ToolPanelDefinition, UpdateSource, VirtualState } from './types';
+import { ColumnConfig, ColumnConfigMap, ColumnInternal, DataGridEventMap, FitMode, FrameworkAdapter, GridColumnState, GridConfig, HeaderContentDefinition, IconValue, InternalGrid, PluginNameMap, ResizeController, RowAnimationType, RowElementInternal, ScrollToRowOptions, ToolbarContentDefinition, ToolPanelDefinition, UpdateSource, VirtualState } from './types';
 export declare class DataGridElement<T = any> extends HTMLElement implements InternalGrid<T> {
     #private;
     static readonly tagName = "tbw-grid";
@@ -39,6 +40,7 @@ export declare class DataGridElement<T = any> extends HTMLElement implements Int
      * @category Framework Adapters
      */
     static clearAdapters(): void;
+    /** @internal Web component lifecycle - not part of public API */
     static get observedAttributes(): string[];
     /**
      * Exposes plugin manager for event bus operations (subscribe/unsubscribe/emit).
@@ -52,9 +54,10 @@ export declare class DataGridElement<T = any> extends HTMLElement implements Int
     get _visibleColumns(): ColumnInternal<T>[];
     _headerRowEl: HTMLElement;
     _bodyEl: HTMLElement;
-    _rowPool: HTMLElement[];
+    _rowPool: RowElementInternal[];
     _resizeController: ResizeController;
-    _virtualization: VirtualState;
+    get _virtualization(): VirtualState;
+    set _virtualization(value: VirtualState);
     _focusRow: number;
     _focusCol: number;
     /** Flag to restore focus styling after next render. @internal */
@@ -119,6 +122,8 @@ export declare class DataGridElement<T = any> extends HTMLElement implements Int
      * ```
      */
     get sourceRows(): T[];
+    /** @internal Used by RowManager for insertRow/removeRow mutations. */
+    set sourceRows(rows: T[]);
     /**
      * Get or set the column configurations.
      *
@@ -374,17 +379,30 @@ export declare class DataGridElement<T = any> extends HTMLElement implements Int
      * This override provides type-safe event handling for DataGrid-specific events.
      * The event detail is automatically typed based on the event name.
      *
+     * **Prefer {@link on | grid.on()}** for most use cases — it auto-unwraps the
+     * detail payload and returns an unsubscribe function for easy cleanup.
+     *
+     * Use `addEventListener` when you need standard DOM options like `once`,
+     * `capture`, `passive`, or `signal` (AbortController).
+     *
      * @example
      * ```typescript
-     * // Type-safe: detail is CellClickDetail<Employee>
-     * grid.addEventListener('cell-click', (e) => {
-     *   console.log(e.detail.field, e.detail.value);
+     * // Recommended: use grid.on() instead
+     * const off = grid.on('cell-click', (detail) => {
+     *   console.log(detail.field, detail.value);
      * });
      *
-     * // Works with editing events when EditingPlugin is imported
-     * grid.addEventListener('cell-commit', (e) => {
-     *   console.log(e.detail.oldValue, '→', e.detail.value);
-     * });
+     * // addEventListener is useful when you need DOM listener options
+     * grid.addEventListener('cell-click', (e) => {
+     *   console.log(e.detail.field, e.detail.value);
+     * }, { once: true });
+     *
+     * // Or with AbortController for batch cleanup
+     * const controller = new AbortController();
+     * grid.addEventListener('sort-change', (e) => {
+     *   fetchData({ sortBy: e.detail.field });
+     * }, { signal: controller.signal });
+     * controller.abort(); // removes all listeners tied to this signal
      * ```
      *
      * @category Events
@@ -399,26 +417,123 @@ export declare class DataGridElement<T = any> extends HTMLElement implements Int
     removeEventListener<K extends keyof DataGridEventMap<T>>(type: K, listener: (this: DataGridElement<T>, ev: CustomEvent<DataGridEventMap<T>[K]>) => void, options?: boolean | EventListenerOptions): void;
     removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
     /**
-     * Subscribe to a typed grid event with automatic detail unwrapping.
-     * Returns an unsubscribe function for easy cleanup.
+     * Subscribe to a typed grid event. **Recommended** over `addEventListener`.
+     *
+     * Returns an unsubscribe function — call it to remove the listener.
+     * The listener receives the event **detail** as its first argument
+     * (no need to dig into `e.detail`), and the raw `CustomEvent` as
+     * the second argument when you need `preventDefault()` or `stopPropagation()`.
      *
-     * The listener receives the event detail as the first argument and the
-     * raw `CustomEvent` as the second (useful for `preventDefault()`,
-     * `stopPropagation()`, etc.).
+     * @remarks
+     * Advantages over `addEventListener`:
+     * - Auto-unwraps `event.detail` — your callback receives the payload directly
+     * - Returns an unsubscribe function — no need to keep a reference to the handler
+     * - Fully typed — event name → detail type is inferred automatically
+     *
+     * Use `addEventListener` instead when you need DOM listener options
+     * like `once`, `capture`, `passive`, or `signal` (AbortController).
      *
      * @example
      * ```typescript
-     * const off = grid.on('cell-click', (detail) => {
-     *   console.log(detail.row, detail.field);
+     * // Basic usage — detail is auto-unwrapped
+     * const off = grid.on('cell-click', ({ row, field, value }) => {
+     *   console.log(`Clicked ${field} = ${value}`);
      * });
      *
-     * // Later: clean up
+     * // Clean up when done
      * off();
      * ```
      *
+     * @example
+     * ```typescript
+     * // Access the raw event for preventDefault/stopPropagation
+     * grid.on('cell-activate', (detail, event) => {
+     *   if (detail.field === 'notes') {
+     *     event.preventDefault(); // suppress default editing
+     *     openRichTextEditor(detail.row, detail.cellEl);
+     *   }
+     * });
+     * ```
+     *
+     * @example
+     * ```typescript
+     * // Multiple subscriptions with easy teardown
+     * const unsubs = [
+     *   grid.on('sort-change', ({ field, direction }) => {
+     *     console.log(`Sorted by ${field} ${direction === 1 ? 'ASC' : 'DESC'}`);
+     *   }),
+     *   grid.on('column-resize', ({ field, width }) => {
+     *     saveColumnWidth(field, width);
+     *   }),
+     *   grid.on('data-change', ({ rowCount }) => {
+     *     statusBar.textContent = `${rowCount} rows`;
+     *   }),
+     * ];
+     *
+     * // Teardown all at once
+     * unsubs.forEach((off) => off());
+     * ```
+     *
      * @category Events
      */
     on<K extends keyof DataGridEventMap<T>>(type: K, listener: (detail: DataGridEventMap<T>[K], event: CustomEvent<DataGridEventMap<T>[K]>) => void): () => void;
+    on(type: string, listener: (detail: unknown, event: CustomEvent) => void): () => void;
+    _emitDataChange(): void;
+    /**
+     * Rebuild the row ID map for O(1) lookups.
+     * Called when rows array changes.
+     */
+    _rebuildRowIdMap(): void;
+    _renderVisibleRows(start: number, end: number, epoch?: number): void;
+    /** Updates ARIA row/col counts. Delegates to aria.ts module. */
+    _updateAriaCounts(rowCount: number, colCount: number): void;
+    /** @internal Request a render at the given phase through the scheduler. */
+    _requestSchedulerPhase(phase: number, source: string): void;
+    /** @internal Plugin extra height for spacer calculation. */
+    _getPluginExtraHeight(): number;
+    /** @internal Plugin-specific row height override. */
+    _getPluginRowHeight(row: T, index: number): number | undefined;
+    /** @internal Plugin extra height before a given row index. */
+    _getPluginExtraHeightBefore(start: number): number;
+    /** @internal Let plugins adjust the virtual start index backwards. */
+    _adjustPluginVirtualStart(start: number, scrollTop: number, rowHeight: number): number | undefined;
+    /** @internal Run plugin afterRender hooks. */
+    _afterPluginRender(): void;
+    /** @internal Emit a plugin event through the plugin manager. */
+    _emitPluginEvent(event: string, detail: unknown): void;
+    /** @internal Merge effective config (FULL/COLUMNS phase). */
+    _schedulerMergeConfig(): void;
+    /** @internal Process columns through plugins (COLUMNS phase). */
+    _schedulerProcessColumns(): void;
+    /** @internal Rebuild row model through plugins (ROWS phase). */
+    _schedulerProcessRows(): void;
+    /** @internal Render header DOM (HEADER phase). */
+    _schedulerRenderHeader(): void;
+    /** @internal Update CSS grid template (COLUMNS phase). */
+    _schedulerUpdateTemplate(): void;
+    /** @internal Run afterRender hooks and post-render bookkeeping (STYLE phase). */
+    _schedulerAfterRender(): void;
+    /** @internal Whether the grid is fully connected (scheduler guard). */
+    get _schedulerIsConnected(): boolean;
+    /** @internal The grid's host HTMLElement. Use instead of casting `grid as unknown as HTMLElement`. */
+    get _hostElement(): HTMLElement;
+    /** @internal The grid's render root element for DOM queries. */
+    get _renderRoot(): HTMLElement;
+    /** @internal Emit a custom event from the grid. */
+    _emit(eventName: string, detail: unknown): void;
+    /** @internal Get accordion expand/collapse icons from effective config. */
+    get _accordionIcons(): {
+        expand: IconValue;
+        collapse: IconValue;
+    };
+    /** @internal Shell state for config manager shell merging. */
+    get _shellState(): ShellState;
+    /** @internal Clear the row pool and body element. */
+    _clearRowPool(): void;
+    /** @internal Run grid setup (DOM rebuild). */
+    _setup(): void;
+    /** @internal Apply animation configuration to host element. */
+    _applyAnimationConfig(config: GridConfig<T>): void;
     /**
      * Find the header row element in the shadow DOM.
      * Used by plugins that need to access header cells for styling or measurement.
@@ -458,7 +573,7 @@ export declare class DataGridElement<T = any> extends HTMLElement implements Int
      * Dispatch a header click event to the plugin system.
      * Returns true if any plugin handled the event.
      */
-    _dispatchHeaderClick(event: MouseEvent, col: ColumnConfig, headerEl: HTMLElement): boolean;
+    _dispatchHeaderClick(event: MouseEvent | KeyboardEvent, col: ColumnConfig, headerEl: HTMLElement): boolean;
     /**
      * Dispatch a keyboard event to the plugin system.
      * Returns true if any plugin handled the event.
@@ -485,7 +600,7 @@ export declare class DataGridElement<T = any> extends HTMLElement implements Int
      * const responses = grid.queryPlugins<boolean>({ type: 'canMoveColumn', context: column });
      * const canMove = !responses.includes(false);
      *
-     * @deprecated Use the simplified `query<T>(type, context)` method instead.
+     * @deprecated Use the simplified `query<T>(type, context)` method instead. Will be removed in v2.
      */
     queryPlugins<T>(query: PluginQuery): T[];
     /**
@@ -823,7 +938,7 @@ export declare class DataGridElement<T = any> extends HTMLElement implements Int
      *
      * @deprecated This method is a no-op. Use {@link insertRow} or {@link removeRow}
      * instead, which correctly preserve the current sort/filter view while adding
-     * or removing individual rows.
+     * or removing individual rows. Will be removed in v2.
      *
      * @group Lifecycle
      */
@@ -1503,27 +1618,24 @@ export declare class DataGridElement<T = any> extends HTMLElement implements Int
      */
     refreshColumns(): void;
     /**
-     * Invalidate a row's height in the position cache.
-     * Call this when a plugin changes a row's height (e.g., expanding/collapsing a detail panel).
-     * Updates the position cache incrementally O(1) + offset recalc O(k) without a full rebuild.
-     *
-     * @param rowIndex - Index of the row whose height changed
-     * @param newHeight - Optional new height. If not provided, queries plugins for height.
-     */
-    invalidateRowHeight(rowIndex: number, newHeight?: number): void;
-    /**
-     * Core virtualization routine. Chooses between bypass (small datasets), grouped window rendering,
-     * or standard row window rendering.
+     * Core virtualization routine. Delegates to VirtualizationManager.
      * @param force - Whether to force a full refresh (not just scroll update)
      * @param skipAfterRender - When true, skip calling afterRender (used by scheduler which calls it separately)
      * @returns Whether the visible row window changed (start/end differ from previous)
      * @internal Plugin API
      */
     refreshVirtualWindow(force?: boolean, skipAfterRender?: boolean): boolean;
+    /**
+     * Invalidate a row's height in the position cache.
+     * Call this when a plugin changes a row's height (e.g., expanding/collapsing a detail panel).
+     * @param rowIndex - Index of the row whose height changed
+     * @param newHeight - Optional new height. If not provided, queries plugins for height.
+     */
+    invalidateRowHeight(rowIndex: number, newHeight?: number): void;
 }
 declare global {
+    var DataGridElement: typeof import('./grid').DataGridElement;
     interface HTMLElementTagNameMap {
         'tbw-grid': DataGridElement;
     }
 }
-//# sourceMappingURL=grid.d.ts.map

package/lib/core/internal/aggregators.d.ts

@@ -64,4 +64,3 @@ export declare const unregisterAggregator: (name: string) => void;
 export declare const getAggregator: (ref: AggregatorRef | undefined) => AggregatorFn | undefined;
 export declare const runAggregator: (ref: AggregatorRef | undefined, rows: any[], field: string, column?: any) => any;
 export declare const listAggregators: () => string[];
-//# sourceMappingURL=aggregators.d.ts.map

package/lib/core/internal/aria.d.ts

@@ -49,4 +49,11 @@ export declare function getEffectiveAriaLabel<T>(config: GridConfig<T> | undefin
  * @returns true if anything was updated
  */
 export declare function updateAriaLabels<T>(state: AriaState, rowsBodyEl: HTMLElement | null, config: GridConfig<T> | undefined, shellState: ShellState | undefined): boolean;
-//# sourceMappingURL=aria.d.ts.map
+/**
+ * Announce a message to screen readers via the grid's aria-live region.
+ * Clears then sets text to ensure repeated messages are re-announced.
+ *
+ * @param gridEl - The grid host element (or any ancestor containing `.tbw-sr-only`)
+ * @param message - The message to announce
+ */
+export declare function announce(gridEl: HTMLElement, message: string): void;

package/lib/core/internal/columns.d.ts

@@ -1,4 +1,4 @@
-import { ColumnConfig, ColumnInternal, InternalGrid } from '../types';
+import { ColumnConfig, ColumnInternal, GridHost } from '../types';
 /**
  * Parse `<tbw-grid-column>` elements from the host light DOM into column config objects,
  * capturing template elements for later cloning / compilation.
@@ -21,6 +21,5 @@ export declare function addPart(el: HTMLElement, token: string): void;
  * Measure rendered header + visible cell content to assign initial pixel widths
  * to columns when in `content` fit mode. Runs only once unless fit mode changes.
  */
-export declare function autoSizeColumns(grid: InternalGrid): void;
-export declare function updateTemplate(grid: InternalGrid): void;
-//# sourceMappingURL=columns.d.ts.map
+export declare function autoSizeColumns(grid: GridHost): void;
+export declare function updateTemplate(grid: GridHost): void;

package/lib/core/internal/config-manager.d.ts

@@ -1,56 +1,5 @@
 import { BaseGridPlugin } from '../plugin';
-import { ColumnConfig, ColumnConfigMap, ColumnInternal, FitMode, GridColumnState, GridConfig, HeaderContentDefinition, ToolbarContentDefinition, ToolPanelDefinition } from '../types';
-/**
- * Callbacks for ConfigManager to notify the grid of changes.
- */
-export interface ConfigManagerCallbacks<T> {
-    /** Get current rows for column inference */
-    getRows: () => T[];
-    /** Get current sort state */
-    getSortState: () => {
-        field: string;
-        direction: 1 | -1;
-    } | null;
-    /** Set sort state */
-    setSortState: (state: {
-        field: string;
-        direction: 1 | -1;
-    } | null) => void;
-    /** Notify that config changed and re-render is needed */
-    onConfigChange: () => void;
-    /** Emit a custom event */
-    emit: (eventName: string, detail: unknown) => void;
-    /** Clear row pool for visibility changes */
-    clearRowPool: () => void;
-    /** Run setup after state changes */
-    setup: () => void;
-    /** Render header */
-    renderHeader: () => void;
-    /** Update column template */
-    updateTemplate: () => void;
-    /** Refresh virtual window */
-    refreshVirtualWindow: () => void;
-    /** Get virtualization state for row height application */
-    getVirtualization: () => {
-        rowHeight: number;
-    };
-    /** Set row height on virtualization state */
-    setRowHeight: (height: number) => void;
-    /** Apply animation config to host element */
-    applyAnimationConfig: (config: GridConfig<T>) => void;
-    /** Get light DOM title from shell state (synced from parseLightDomShell) */
-    getShellLightDomTitle: () => string | null;
-    /** Get registered tool panels from shell state */
-    getShellToolPanels: () => Map<string, ToolPanelDefinition>;
-    /** Get registered header contents from shell state */
-    getShellHeaderContents: () => Map<string, HeaderContentDefinition>;
-    /** Get registered toolbar contents from shell state */
-    getShellToolbarContents: () => Map<string, ToolbarContentDefinition>;
-    /** Get light DOM header content elements */
-    getShellLightDomHeaderContent: () => HTMLElement[];
-    /** Get whether a tool buttons container was found in light DOM */
-    getShellHasToolButtonsContainer: () => boolean;
-}
+import { ColumnConfig, ColumnConfigMap, ColumnInternal, FitMode, GridColumnState, GridConfig, GridHost } from '../types';
 /**
  * ConfigManager handles all configuration lifecycle for the grid.
  *
@@ -62,7 +11,7 @@ export interface ConfigManagerCallbacks<T> {
  */
 export declare class ConfigManager<T = unknown> {
     #private;
-    constructor(callbacks: ConfigManagerCallbacks<T>);
+    constructor(grid: GridHost<T>);
     /** Get the frozen original config (compiled from sources, immutable) */
     get original(): GridConfig<T>;
     /** Get the mutable effective config (current runtime state) */
@@ -230,4 +179,3 @@ export declare class ConfigManager<T = unknown> {
      */
     dispose(): void;
 }
-//# sourceMappingURL=config-manager.d.ts.map

package/lib/core/internal/dom-builder.d.ts

@@ -102,4 +102,3 @@ export interface ShellBodyOptions {
  * Build shell body element directly without innerHTML.
  */
 export declare function buildShellBody(options: ShellBodyOptions): HTMLDivElement;
-//# sourceMappingURL=dom-builder.d.ts.map

package/lib/core/internal/event-delegation.d.ts

@@ -1,4 +1,4 @@
-import { InternalGrid } from '../types';
+import { GridHost } from '../types';
 /**
  * Set up delegated event listeners on the grid body.
  * Consolidates all row/cell mouse event handling into a single set of listeners.
@@ -13,7 +13,7 @@ import { InternalGrid } from '../types';
  * @param bodyEl - The .rows element containing all data rows
  * @param signal - AbortSignal for cleanup
  */
-export declare function setupCellEventDelegation(grid: InternalGrid, bodyEl: HTMLElement, signal: AbortSignal): void;
+export declare function setupCellEventDelegation(grid: GridHost, bodyEl: HTMLElement, signal: AbortSignal): void;
 /**
  * Set up root-level and document-level event listeners.
  * These are added once per grid lifetime (not re-attached on DOM recreation).
@@ -28,5 +28,4 @@ export declare function setupCellEventDelegation(grid: InternalGrid, bodyEl: HTM
  * @param renderRoot - The render root element (for mousedown)
  * @param signal - AbortSignal for cleanup
  */
-export declare function setupRootEventDelegation(grid: InternalGrid, gridElement: HTMLElement, renderRoot: HTMLElement, signal: AbortSignal): void;
-//# sourceMappingURL=event-delegation.d.ts.map
+export declare function setupRootEventDelegation(grid: GridHost, gridElement: HTMLElement, renderRoot: HTMLElement, signal: AbortSignal): void;

package/lib/core/internal/feature-hook.d.ts

@@ -5,4 +5,3 @@ export type FeatureResolverFn = (features: Record<string, unknown>) => GridPlugi
 export declare let resolveFeatures: FeatureResolverFn | undefined;
 /** Called by `features/registry.ts` at module evaluation time. @internal */
 export declare function setFeatureResolver(fn: FeatureResolverFn): void;
-//# sourceMappingURL=feature-hook.d.ts.map

package/lib/core/internal/focus-manager.d.ts

@@ -0,0 +1,49 @@
+import { GridHost, ScrollToRowOptions } from '../types';
+export declare class FocusManager<T = any> {
+    #private;
+    constructor(grid: GridHost<T>);
+    /**
+     * Move focus to a specific cell.
+     * Accepts a column index or field name.
+     */
+    focusCell(rowIndex: number, column: number | string): void;
+    /**
+     * The currently focused cell position, or `null` if no rows are loaded.
+     */
+    get focusedCell(): {
+        rowIndex: number;
+        colIndex: number;
+        field: string;
+    } | null;
+    /**
+     * Scroll the viewport so a row is visible.
+     */
+    scrollToRow(rowIndex: number, options?: ScrollToRowOptions): void;
+    /**
+     * Scroll the viewport so a row is visible, identified by its unique ID.
+     */
+    scrollToRowById(rowId: string, options?: ScrollToRowOptions): void;
+    /**
+     * Register an external DOM element as a logical focus container of this grid.
+     * Focus moving into a registered container is treated as if it stayed inside the grid.
+     */
+    registerExternalFocusContainer(el: Element): void;
+    /**
+     * Unregister a previously registered external focus container.
+     */
+    unregisterExternalFocusContainer(el: Element): void;
+    /**
+     * Check whether focus is logically inside this grid.
+     * Returns `true` when the node is inside the grid's DOM or any external container.
+     */
+    containsFocus(node?: Node | null): boolean;
+    /**
+     * Check whether a node is inside any registered external focus container.
+     */
+    isInExternalFocusContainer(node: Node): boolean;
+    /**
+     * Clean up all external focus container listeners.
+     * Called when the grid disconnects.
+     */
+    destroy(): void;
+}

package/lib/core/internal/header.d.ts

@@ -1,4 +1,4 @@
-import { InternalGrid } from '../types';
+import { GridHost } from '../types';
 /**
  * Rebuild the header row DOM based on current column configuration, attaching
  * sorting and resize affordances where enabled.
@@ -10,5 +10,4 @@ import { InternalGrid } from '../types';
  * 4. `header` property - Plain text header
  * 5. `field` - Fallback to field name
  */
-export declare function renderHeader(grid: InternalGrid): void;
-//# sourceMappingURL=header.d.ts.map
+export declare function renderHeader(grid: GridHost): void;

package/lib/core/internal/idle-scheduler.d.ts

@@ -27,4 +27,3 @@ export declare function scheduleIdle(callback: (deadline: IdleDeadlineLike) => v
  */
 export declare function cancelIdle(handle: number): void;
 export {};
-//# sourceMappingURL=idle-scheduler.d.ts.map

package/lib/core/internal/inference.d.ts

@@ -9,4 +9,3 @@ declare function inferType(value: any): PrimitiveColumnType;
  */
 export declare function inferColumns<TRow extends Record<string, unknown>>(rows: TRow[], provided?: ColumnConfigMap<TRow>): InferredColumnResult<TRow>;
 export { inferType };
-//# sourceMappingURL=inference.d.ts.map

package/lib/core/internal/keyboard.d.ts

@@ -1,5 +1,5 @@
-import { InternalGrid } from '../types';
-export declare function handleGridKeyDown(grid: InternalGrid, e: KeyboardEvent): void;
+import { GridHost } from '../types';
+export declare function handleGridKeyDown(grid: GridHost, e: KeyboardEvent): void;
 /**
  * Options for ensureCellVisible to control scroll behavior.
  */
@@ -15,6 +15,5 @@ interface EnsureCellVisibleOptions {
  * Scroll the viewport (virtualized or static) so the focused cell's row is visible
  * and apply visual focus styling / tabindex management.
  */
-export declare function ensureCellVisible(grid: InternalGrid, options?: EnsureCellVisibleOptions): void;
+export declare function ensureCellVisible(grid: GridHost, options?: EnsureCellVisibleOptions): void;
 export {};
-//# sourceMappingURL=keyboard.d.ts.map

package/lib/core/internal/loading.d.ts

@@ -40,4 +40,3 @@ export declare function setRowLoadingState(rowEl: HTMLElement, loading: boolean)
  * @param loading - Whether the cell is loading
  */
 export declare function setCellLoadingState(cellEl: HTMLElement, loading: boolean): void;
-//# sourceMappingURL=loading.d.ts.map

package/lib/core/internal/render-scheduler.d.ts

@@ -1,46 +1,4 @@
-/**
- * Centralized Render Scheduler for the Grid component.
- *
- * This scheduler batches all rendering work into a single requestAnimationFrame,
- * eliminating race conditions between different parts of the grid (ResizeObserver,
- * framework adapters, virtualization, etc.) that previously scheduled independent RAFs.
- *
- * ## Design Principles
- *
- * 1. **Single RAF per frame**: All render requests are batched into one RAF callback
- * 2. **Phase-based execution**: Work is organized into ordered phases that run sequentially
- * 3. **Highest-phase wins**: Multiple requests merge to the highest requested phase
- * 4. **Framework-agnostic timing**: Eliminates need for "double RAF" hacks
- *
- * ## Render Phases (execute in order)
- *
- * - STYLE (1): Lightweight style/class updates, plugin afterRender hooks
- * - VIRTUALIZATION (2): Virtual window recalculation (scroll, resize)
- * - HEADER (3): Header re-render only
- * - ROWS (4): Row model rebuild + header + template + virtual window
- * - COLUMNS (5): Column processing + rows phase work
- * - FULL (6): Complete render including config merge
- *
- * @example
- * ```typescript
- * const scheduler = new RenderScheduler({
- *   mergeConfig: () => this.#mergeEffectiveConfig(),
- *   processColumns: () => this.#processColumns(),
- *   processRows: () => this.#rebuildRowModel(),
- *   renderHeader: () => renderHeader(this),
- *   updateTemplate: () => updateTemplate(this),
- *   renderVirtualWindow: () => this.refreshVirtualWindow(true),
- *   afterRender: () => this.#pluginManager?.afterRender(),
- *   isConnected: () => this.isConnected && this.#connected,
- * });
- *
- * // Request a full render
- * scheduler.requestPhase(RenderPhase.FULL, 'initial-setup');
- *
- * // Wait for render to complete
- * await scheduler.whenReady();
- * ```
- */
+import { InternalGrid } from '../types';
 /**
  * Render phases in order of execution.
  * Higher phases include all lower phase work.
@@ -62,34 +20,14 @@ export declare enum RenderPhase {
     FULL = 6
 }
 /**
-/**
- * Callbacks that the scheduler invokes during flush.
- * Each callback corresponds to work done in a specific phase.
+ * @internal Scheduler now takes InternalGrid directly — no callback interface needed.
  */
-export interface RenderCallbacks {
-    /** Merge effective config (FULL phase) */
-    mergeConfig: () => void;
-    /** Process columns through plugins (COLUMNS phase) */
-    processColumns: () => void;
-    /** Rebuild row model through plugins (ROWS phase) */
-    processRows: () => void;
-    /** Render header DOM (HEADER phase) */
-    renderHeader: () => void;
-    /** Update CSS grid template (ROWS phase) */
-    updateTemplate: () => void;
-    /** Recalculate virtual window (VIRTUALIZATION phase) */
-    renderVirtualWindow: () => void;
-    /** Run plugin afterRender hooks (STYLE phase) */
-    afterRender: () => void;
-    /** Check if grid is still connected to DOM */
-    isConnected: () => boolean;
-}
 /**
  * Centralized render scheduler that batches all grid rendering into single RAF.
  */
 export declare class RenderScheduler {
     #private;
-    constructor(callbacks: RenderCallbacks);
+    constructor(grid: InternalGrid);
     /**
      * Request a render at the specified phase.
      * Multiple requests are batched - the highest phase wins.
@@ -122,4 +60,3 @@ export declare class RenderScheduler {
      */
     get pendingPhase(): RenderPhase | 0;
 }
-//# sourceMappingURL=render-scheduler.d.ts.map

package/lib/core/internal/resize.d.ts

@@ -1,3 +1,2 @@
-import { InternalGrid, ResizeController } from '../types';
-export declare function createResizeController(grid: InternalGrid): ResizeController;
-//# sourceMappingURL=resize.d.ts.map
+import { GridHost, ResizeController } from '../types';
+export declare function createResizeController(grid: GridHost): ResizeController;

package/lib/core/internal/row-animation.d.ts

@@ -34,4 +34,3 @@ export declare function animateRows<T>(grid: InternalGrid<T>, rowIndices: number
  * @returns Promise resolving to `true` if the row was found and animated, `false` otherwise
  */
 export declare function animateRowById<T>(grid: InternalGrid<T>, rowId: string, animationType: RowAnimationType): Promise<boolean>;
-//# sourceMappingURL=row-animation.d.ts.map

package/lib/core/internal/row-manager.d.ts

@@ -0,0 +1,31 @@
+import { GridHost, UpdateSource } from '../types';
+/**
+ * Try to resolve the ID for a row using a configured getRowId or fallback.
+ * Returns undefined if no ID can be determined (non-throwing).
+ *
+ * Exported so grid.ts can use it in `#rebuildRowIdMap` without going
+ * through the RowManager instance.
+ */
+export declare function tryResolveRowId<T>(row: T, getRowId?: (row: T) => string): string | undefined;
+/**
+ * Resolve the ID for a row, throwing if not found.
+ * Exported so grid.ts `getRowId()` can call it without the RowManager.
+ */
+export declare function resolveRowIdOrThrow<T>(row: T, gridId: string, getRowId?: (row: T) => string): string;
+export declare class RowManager<T = any> {
+    #private;
+    constructor(grid: GridHost<T>);
+    resolveRowId(row: T): string;
+    getRow(id: string): T | undefined;
+    getRowEntry(id: string): {
+        row: T;
+        index: number;
+    } | undefined;
+    updateRow(id: string, changes: Partial<T>, source?: UpdateSource): void;
+    updateRows(updates: Array<{
+        id: string;
+        changes: Partial<T>;
+    }>, source?: UpdateSource): void;
+    insertRow(index: number, row: T, animate?: boolean): Promise<void>;
+    removeRow(index: number, animate?: boolean): Promise<T | undefined>;
+}