@yuktishaalaa/yuktai 5.3.10 → 5.3.12

package/dist/grid/YuktaiGridAI.d.ts

@@ -0,0 +1,46 @@
+import React from "react";
+import type { GridInputLanguage } from "./types";
+type UILanguage = "en-US" | "te-IN";
+type InputLanguage = GridInputLanguage;
+export interface YuktaiGridAIProps<T> {
+    data: T[];
+    columns: {
+        key: string;
+        label: string;
+        type?: "number" | "text" | "date";
+    }[];
+    onSearch?: (query: string) => void;
+    onSort?: (key: string, dir: "asc" | "desc") => void;
+    theme?: "light" | "dark";
+    /**
+     * Language of AI UI and AI responses.
+     * Default: English.
+     */
+    language?: UILanguage;
+    /**
+     * Language used by browser voice recognition.
+     * Default: English.
+     */
+    inputLanguage?: InputLanguage;
+    /**
+     * When true, AI is rendered inside the grid.
+     * When false, AI uses the floating assistant UI.
+     */
+    embedded?: boolean;
+    /**
+     * The grid Agent.
+     */
+    agent?: {
+        ask: (text: string) => Promise<{
+            success: boolean;
+            message: string;
+        }>;
+        loading?: boolean;
+    };
+    /**
+     * Called when the person switches the voice input language.
+     */
+    onInputLanguageChange?: (language: InputLanguage) => void;
+}
+export declare function YuktaiGridAI<T extends Record<string, unknown>>({ data, columns, onSearch, onSort, theme, language, inputLanguage, embedded, agent, onInputLanguageChange, }: YuktaiGridAIProps<T>): React.JSX.Element;
+export default YuktaiGridAI;

package/dist/grid/YuktaiGridAgent.d.ts

@@ -0,0 +1,81 @@
+import { type GridToolErrorCode, type GridToolLocale, type GridToolResult } from "./gridTools";
+import type { YuktaiGridRule } from "./types";
+export type GridAgentTool = {
+    name: string;
+    description: string;
+    /** Optional UI label (e.g. Telugu). createGridTools() provides it. */
+    label?: string;
+    /** Optional JSON schema; its `required` list is checked before running. */
+    inputSchema?: Record<string, unknown>;
+    execute: (input: Record<string, unknown>) => Promise<unknown> | unknown;
+};
+export type GridAgentErrorCode = GridToolErrorCode | "NOT_UNDERSTOOD";
+export type GridAgentResult<T = unknown> = Omit<GridToolResult<T>, "error"> & {
+    error?: {
+        code: GridAgentErrorCode;
+    };
+    /** Full name of the tool that produced this result */
+    tool?: string;
+};
+export type GridAgentStep = {
+    id: number;
+    tool: string;
+    input: Record<string, unknown>;
+    result: GridAgentResult;
+    source: "tool" | "ask";
+    at: number;
+};
+export type GridIntent = {
+    kind: "tool";
+    tool: string;
+    input: Record<string, unknown>;
+}
+/**
+ * "open <something>": search for it, then open the first match
+ */
+ | {
+    kind: "open";
+    text: string;
+};
+export type GridIntentContext = {
+    columns: {
+        key: string;
+        label: string;
+    }[];
+    locale: GridToolLocale;
+};
+export type YuktaiGridAgentProps<T = Record<string, unknown>> = {
+    tools: GridAgentTool[];
+    /** Current grid data available to application-defined rules. */
+    data?: T[];
+    onResult?: (result: GridAgentResult) => void;
+    onError?: (error: Error) => void;
+    /** Language of the agent's own messages (default "en"). */
+    locale?: GridToolLocale;
+    /** Columns, so ask() can understand "sort by <column>". */
+    columns?: {
+        key: string;
+        label: string;
+    }[];
+    /** Row ID field — must match the grid's rowKey (default "id"). */
+    rowKey?: string;
+    /** Replace the built-in regex intent parser. */
+    parseIntent?: (text: string, context: GridIntentContext) => GridIntent | null;
+    /** Application-defined content rules executed before the generic intent parser. */
+    customRules?: YuktaiGridRule<T>[];
+    /** How many steps to keep in history (default 20). */
+    historyLimit?: number;
+};
+/** Built-in parser: exported so it can be tested and reused. */
+export declare function parseGridIntent(text: string, context: GridIntentContext): GridIntent | null;
+export declare function useYuktaiGridAgent<T = Record<string, unknown>>({ tools, data, onResult, onError, locale, columns, rowKey, parseIntent: customParseIntent, customRules, historyLimit, }: YuktaiGridAgentProps<T>): {
+    loading: boolean;
+    tools: GridAgentTool[];
+    executeTool: (name: string, input?: Record<string, unknown>) => Promise<GridAgentResult<unknown>>;
+    ask: (text: string) => Promise<GridAgentResult>;
+    lastResult: GridAgentResult<unknown> | null;
+    lastError: Error | null;
+    history: GridAgentStep[];
+    clearHistory: () => void;
+};
+export default useYuktaiGridAgent;

package/dist/grid/YuktaiGridWebMCP.d.ts

@@ -0,0 +1,54 @@
+import { type CreateGridToolsOptions, type GridTool, type GridToolLocale } from "./gridTools";
+type ModelContextTool = {
+    name: string;
+    title: string;
+    description: string;
+    inputSchema: Record<string, unknown>;
+    execute: (input: any) => Promise<unknown> | unknown;
+};
+declare global {
+    interface Document {
+        modelContext?: {
+            registerTool: (tool: ModelContextTool, options?: {
+                signal?: AbortSignal;
+            }) => Promise<void>;
+        };
+    }
+}
+export type WebMCPState = "unsupported" | "registering" | "ready" | "partial" | "error";
+export type WebMCPStatus = {
+    state: WebMCPState;
+    /** Tools that the browser actually accepted */
+    registered: string[];
+    errors: {
+        tool: string;
+        message: string;
+    }[];
+};
+type WebMCPColumn = {
+    key: string;
+    label: string;
+    type?: "text" | "number" | "date";
+};
+export type YuktaiGridWebMCPProps<T> = {
+    /**
+     * Ready-made tools (YuktaiGrid passes its own list here). When given,
+     * data/columns/callbacks below are not needed.
+     */
+    tools?: GridTool[];
+    data?: T[];
+    columns?: WebMCPColumn[];
+    rowKey?: string;
+    locale?: GridToolLocale;
+    onSelectRow?: (id: string) => void;
+    onHighlightRows?: (ids: string[]) => void;
+    onOpenRow?: (id: string) => void;
+    /** Tool name prefix (default "yuktai_grid") */
+    name?: string;
+    /** Agent-facing descriptions per tool, e.g. { search: "Search Telugu poems…" } */
+    descriptions?: CreateGridToolsOptions["descriptions"];
+    /** Called whenever the registration status changes */
+    onStatusChange?: (status: WebMCPStatus) => void;
+};
+export declare function YuktaiGridWebMCP<T extends Record<string, unknown>>({ tools: toolsProp, data, columns, rowKey, locale, onSelectRow, onHighlightRows, onOpenRow, name, descriptions, onStatusChange, }: YuktaiGridWebMCPProps<T>): null;
+export default YuktaiGridWebMCP;

package/dist/grid/gridTools.d.ts

@@ -0,0 +1,111 @@
+/**
+ * gridTools — the ONE place where YuktaiGrid tools are defined.
+ *
+ * Both the in-page Agent (useYuktaiGridAgent) and WebMCP (YuktaiGridWebMCP)
+ * should get their tools from `createGridTools()`, so the list an agent sees
+ * can never drift from the list the UI shows.
+ *
+ * Rules every tool follows:
+ *  1. One row-ID strategy: `getRowId(row, context.rowKey)` everywhere.
+ *     `rowKey` must match YuktaiGrid's `rowKey` prop (default "id").
+ *  2. One result shape: { success, message, data?, error?: { code } }.
+ *  3. Never claim success for something that didn't happen:
+ *     missing callback → NOT_SUPPORTED, unknown row → NOT_FOUND.
+ *  4. Never throw: tool execution is wrapped, errors become INTERNAL results.
+ *
+ * Backward compatible with 4.6.x: the existing exports keep their names and
+ * parameters; results only gain an optional `error` field.
+ */
+export type GridToolColumn = {
+    key: string;
+    label: string;
+    type?: "text" | "number" | "date";
+};
+export type GridToolErrorCode = "NOT_FOUND" | "NOT_SUPPORTED" | "INVALID_INPUT" | "INTERNAL";
+export type GridToolFilterOperator = "contains" | "equals" | "startsWith" | "endsWith" | "greaterThan" | "lessThan" | "between";
+export type GridToolFilter = {
+    key: string;
+    operator: GridToolFilterOperator;
+    value: string | number | [number, number];
+};
+export type GridToolSort = {
+    key: string;
+    direction: "asc" | "desc";
+};
+/** Language of `message` (shown to people). Agent descriptions stay English. */
+export type GridToolLocale = "en" | "te";
+export type GridToolContext<T> = {
+    data: T[];
+    columns: GridToolColumn[];
+    /** Field used as the row ID by every tool (default "id"). Match YuktaiGrid's rowKey. */
+    rowKey?: string;
+    /** Language for result messages (default "en"). */
+    locale?: GridToolLocale;
+    /** Filters currently applied, so a new filter can be merged in. */
+    filters?: GridToolFilter[];
+    onSelectRow?: (id: string) => void;
+    onHighlightRows?: (ids: string[]) => void;
+    onOpenRow?: (id: string) => void;
+    onFiltersChange?: (filters: GridToolFilter[]) => void;
+    onSortChange?: (sort: GridToolSort | null) => void;
+};
+export type GridToolResult<T = unknown> = {
+    success: boolean;
+    message: string;
+    data?: T;
+    error?: {
+        code: GridToolErrorCode;
+    };
+};
+/** A tool ready for the Agent and for WebMCP `registerTool`. */
+export type GridTool = {
+    name: string;
+    title: string;
+    /** For AI agents (English works best for tool selection). Never shown in the UI. */
+    description: string;
+    /** Short label for the UI, in the grid's locale. */
+    label: string;
+    inputSchema: Record<string, unknown>;
+    execute: (input: Record<string, unknown>) => Promise<GridToolResult>;
+};
+export type CreateGridToolsOptions = {
+    /** Tool name prefix, e.g. "ratnalabala_poems" → "ratnalabala_poems_search". */
+    name?: string;
+    /** Override agent descriptions per tool, keyed by the short tool id ("search", "open", …). */
+    descriptions?: Partial<Record<GridToolId, string>>;
+};
+export type GridToolId = "search" | "count" | "columns" | "get_row" | "highlight" | "select" | "open" | "filter" | "clear_filters" | "sort" | "clear_sort";
+/** The single row-ID rule used by every tool. */
+export declare function getRowId(row: unknown, rowKey?: string): string;
+/**
+ * Applies filters to rows — exported so YuktaiGrid filters its rows with
+ * exactly the same rules the filter tool uses to count matches.
+ */
+export declare function applyGridFilters<T>(data: T[], columns: GridToolColumn[], filters: GridToolFilter[]): T[];
+/** Maps grid columns (any type) to tool columns (text / number / date). */
+export declare function toGridToolColumns(columns: {
+    key: string;
+    label: string;
+    type?: string;
+}[]): GridToolColumn[];
+export declare function searchGrid<T extends Record<string, unknown>>(context: GridToolContext<T>, query: string): GridToolResult<T[]>;
+export declare function countGrid<T>(context: GridToolContext<T>): GridToolResult<number>;
+export declare function getColumns<T>(context: GridToolContext<T>): GridToolResult<GridToolColumn[]>;
+export declare function getRow<T extends Record<string, unknown>>(context: GridToolContext<T>, id: string): GridToolResult<T>;
+export declare function highlightRows<T extends Record<string, unknown>>(context: GridToolContext<T>, ids: string[]): GridToolResult<string[]>;
+export declare function selectRow<T extends Record<string, unknown>>(context: GridToolContext<T>, id: string): GridToolResult<string>;
+export declare function openRow<T extends Record<string, unknown>>(context: GridToolContext<T>, id: string): GridToolResult<string>;
+export declare function filterGrid<T extends Record<string, unknown>>(context: GridToolContext<T>, filter: GridToolFilter): GridToolResult<{
+    filters: GridToolFilter[];
+    count: number;
+}>;
+export declare function clearFilters<T>(context: GridToolContext<T>): GridToolResult<GridToolFilter[]>;
+export declare function sortGrid<T>(context: GridToolContext<T>, key: string, direction?: "asc" | "desc"): GridToolResult<GridToolSort>;
+export declare function clearSort<T>(context: GridToolContext<T>): GridToolResult<null>;
+/**
+ * Builds the tool list used by BOTH the Agent and WebMCP.
+ * Only tools the grid can actually perform are included — e.g. "open" is
+ * left out when no onOpenRow callback is given — so agents never see a tool
+ * that would just return NOT_SUPPORTED.
+ */
+export declare function createGridTools<T extends Record<string, unknown>>(context: GridToolContext<T>, options?: CreateGridToolsOptions): GridTool[];

package/dist/grid/rust/engine.d.ts

@@ -0,0 +1,55 @@
+/** Which engine sorts and searches the grid. */
+export type GridEngine = "ts" | "rust" | "auto";
+/** `engine: "auto"` switches to Rust from this many rows. */
+export declare const RUST_AUTO_MIN_ROWS = 10000;
+/** Joins a row's column values for search. Queries containing it fall back to TypeScript. */
+export declare const SEARCH_SEPARATOR = "\0";
+export declare function wantsRustEngine(engine: GridEngine | undefined, rowCount: number): boolean;
+/** Decodes an embedded WebAssembly module (browser atob, or Node Buffer). */
+export declare function decodeBase64(b64: string): Uint8Array;
+/**
+ * Compiles the Rust engine once per page. Resolves `null` when WebAssembly is
+ * not available; the grid then simply keeps using TypeScript.
+ */
+export declare function loadGridCore(): Promise<WebAssembly.Module | null>;
+/** The compiled engine if `loadGridCore()` has already finished, else null. */
+export declare function getLoadedGridCore(): WebAssembly.Module | null;
+/**
+ * One engine per grid. Holds that grid's search text inside the WebAssembly
+ * memory, so each keystroke only sends the query.
+ */
+export declare class GridCore {
+    private readonly x;
+    private readonly base;
+    private readonly encoder;
+    private offsetsPtr;
+    private textPtr;
+    private textLen;
+    private rows;
+    private hasIndex;
+    private freePtr;
+    private constructor();
+    /** Creates an engine from a compiled module (default: the one already loaded). */
+    static create(mod?: WebAssembly.Module | null): GridCore | null;
+    private ensure;
+    /**
+     * Stores one search text per row (the grid joins its columns with
+     * SEARCH_SEPARATOR). Returns false when Rust can't match TypeScript
+     * exactly for this data; the grid then searches in TypeScript.
+     */
+    setSearchTexts(texts: string[]): boolean;
+    /**
+     * Positions (in the array given to setSearchTexts) of the rows whose text
+     * contains `query`, in original order. Null means "use TypeScript".
+     */
+    search(query: string): Uint32Array | null;
+    /**
+     * Row positions sorted by `keys` (NaN = empty, always last; equal keys keep
+     * their order). Null means "use TypeScript".
+     */
+    sortByKeys(keys: Float64Array, desc: boolean): Uint32Array | null;
+}
+/** "0.9 ms", "12 ms", "<0.1 ms" — for search time labels. */
+export declare function formatSearchTime(ms: number): string;
+/** Picks `rows[i]` for each position, keeping the given order. */
+export declare function pickRows<T>(rows: readonly T[], positions: Uint32Array): T[];

package/dist/grid/rust/gridCoreWasm.d.ts

@@ -0,0 +1,3 @@
+/** yuktai grid-core WebAssembly (12810 bytes), base64. */
+export declare const GRID_CORE_WASM_BASE64: string;
+export declare const GRID_CORE_WASM_SIZE = 12810;

package/dist/grid/rust/useGridCore.d.ts

@@ -0,0 +1,2 @@
+import { GridCore, type GridEngine } from "./engine";
+export declare function useGridCore(engine: GridEngine | undefined, rowCount: number): GridCore | null;

package/dist/grid/types.d.ts

@@ -0,0 +1,245 @@
+import type { ReactNode } from "react";
+import type { GridEngine } from "./rust/engine";
+/** One search/sort run: what was searched, how long it took, which engine answered. */
+export interface GridSearchTime {
+    /** The search text ("" when only sorting) */
+    query: string;
+    /** Milliseconds for search + filters + sort */
+    ms: number;
+    /** Rows after search and filters */
+    rows: number;
+    engine: "rust" | "ts";
+}
+export interface GridColumn<T = Record<string, unknown>> {
+    key: keyof T & string;
+    label: string;
+    sortable?: boolean;
+    filterable?: boolean;
+    hiddenOnMobile?: boolean;
+    pinned?: boolean;
+    width?: number | string;
+    render?: (value: T[keyof T], row: T, index: number) => ReactNode;
+    align?: "left" | "center" | "right";
+    type?: "text" | "number" | "date" | "boolean" | "badge";
+}
+export type SortDirection = "asc" | "desc" | null;
+export interface SortConfig {
+    key: string;
+    direction: SortDirection;
+}
+export type FilterOperator = "contains" | "equals" | "startsWith" | "endsWith" | "greaterThan" | "lessThan" | "between";
+export interface FilterConfig {
+    key: string;
+    operator: FilterOperator;
+    value: string | number | [number, number];
+}
+export type ViewMode = "table" | "card" | "auto";
+export type GridTheme = "default" | "high-contrast" | "dark" | "color-blind" | "dyslexia";
+export type IndicLanguageLocale = "as-IN" | "bn-IN" | "brx-IN" | "doi-IN" | "gu-IN" | "hi-IN" | "kn-IN" | "ks-IN" | "kok-IN" | "mai-IN" | "ml-IN" | "mni-IN" | "mr-IN" | "ne-IN" | "or-IN" | "pa-IN" | "sa-IN" | "sat-IN" | "sd-IN" | "ta-IN" | "te-IN" | "ur-IN";
+export type GridLocale = "en-IN" | "en-US" | IndicLanguageLocale;
+export type GridInputLanguage = GridLocale;
+export interface AIFeatures {
+    search?: boolean;
+    summary?: boolean;
+    anomaly?: boolean;
+    suggest?: boolean;
+}
+export interface VoiceFeatures {
+    control?: boolean;
+    speakOnFocus?: boolean;
+    speakSummary?: boolean;
+    language?: string;
+}
+export interface PaginationConfig {
+    pageSize?: number;
+    showSizeChanger?: boolean;
+    sizeOptions?: number[];
+}
+export interface GridTranslations {
+    search: string;
+    noData: string;
+    loading: string;
+    rowsSelected: string;
+    page: string;
+    of: string;
+    showing: string;
+    to: string;
+    results: string;
+    sort: string;
+    filter: string;
+    export: string;
+    voice: string;
+    ask: string;
+}
+export interface YuktaiGridRuleContext<T = Record<string, unknown>> {
+    /**
+     * Original user input.
+     */
+    input: string;
+    /**
+     * Current grid data.
+     */
+    data: T[];
+    /**
+     * Available grid columns.
+     */
+    columns: {
+        key: string;
+        label: string;
+    }[];
+    /**
+     * Execute one of the generic Grid tools.
+     *
+     * Example:
+     *
+     * executeTool("count")
+     *
+     * executeTool("filter", {
+     *   key: "lines",
+     *   operator: "greaterThan",
+     *   value: 6
+     * })
+     */
+    executeTool: (name: string, input?: Record<string, unknown>) => Promise<{
+        success: boolean;
+        message: string;
+        data?: unknown;
+        error?: {
+            code: string;
+        };
+        tool?: string;
+    }>;
+}
+export interface YuktaiGridRule<T = Record<string, unknown>> {
+    /**
+     * Application-defined rule name.
+     */
+    name: string;
+    /**
+     * User phrases that activate this rule.
+     */
+    phrases: string[];
+    /**
+     * Optional description for documentation/debugging.
+     */
+    description?: string;
+    /**
+     * Application-specific execution logic.
+     *
+     * The package does NOT contain application-specific rules.
+     */
+    execute: (context: YuktaiGridRuleContext<T>) => Promise<string> | string;
+}
+export interface YuktaiGridProps<T = Record<string, unknown>> {
+    data: T[];
+    columns: GridColumn<T>[];
+    view?: ViewMode;
+    mobileBreakpoint?: number;
+    theme?: GridTheme;
+    locale?: GridLocale;
+    ai?: boolean | AIFeatures;
+    voice?: boolean | VoiceFeatures;
+    pagination?: boolean | PaginationConfig;
+    search?: boolean;
+    selectable?: boolean;
+    selectedKeys?: string[];
+    rowKey?: keyof T & string;
+    loading?: boolean;
+    empty?: ReactNode;
+    highlightIds?: (string | number)[];
+    highlightColor?: string;
+    autoScrollToHighlight?: boolean;
+    onSelectionChange?: (keys: string[]) => void;
+    onRowClick?: (row: T, index: number) => void;
+    onSortChange?: (sort: SortConfig | null) => void;
+    className?: string;
+    /**
+     * Voice/input language of the embedded assistant.
+     *
+     * Supports English and the 22 Indian Scheduled Languages.
+     */
+    inputLanguage?: "en-IN" | "en-US" | IndicLanguageLocale;
+    /**
+     * Prefix for WebMCP / Agent tool names.
+     *
+     * Example:
+     *
+     * "ratnalabala_poems"
+     *
+     * produces:
+     *
+     * ratnalabala_poems_search
+     * ratnalabala_poems_filter
+     * ratnalabala_poems_sort
+     */
+    toolName?: string;
+    /**
+     * Agent-facing tool descriptions.
+     */
+    toolDescriptions?: Partial<Record<"search" | "count" | "columns" | "get_row" | "highlight" | "select" | "open" | "filter" | "clear_filters" | "sort" | "clear_sort", string>>;
+    /**
+     * Expose Grid tools to AI agents through WebMCP.
+     */
+    webmcp?: boolean;
+    /**
+     * Real WebMCP registration status.
+     */
+    onWebMCPStatusChange?: (status: {
+        state: "unsupported" | "registering" | "ready" | "partial" | "error";
+        registered: string[];
+        errors: {
+            tool: string;
+            message: string;
+        }[];
+    }) => void;
+    /**
+     * Application-specific Agent rules.
+     *
+     * Example:
+     *
+     * customRules={[
+     *   {
+     *     name: "show-long-poems",
+     *     phrases: ["పెద్ద పద్యాలు"],
+     *     execute: async ({ executeTool }) => {
+     *       const result = await executeTool("filter", {
+     *         key: "lines",
+     *         operator: "greaterThan",
+     *         value: 6,
+     *       })
+     *
+     *       return result.message
+     *     },
+     *   },
+     * ]}
+     */
+    customRules?: YuktaiGridRule<T>[];
+    /**
+     * Search and sort engine.
+     *
+     * - "rust" (default since v5.3.11): the Rust (WebAssembly) engine, about
+     *   13 KB, embedded. Falls back to TypeScript when WebAssembly is missing
+     *   or blocked by a Content Security Policy.
+     * - "auto": Rust from 10,000 rows, TypeScript below
+     * - "ts": TypeScript only, as before v5.3.11
+     *
+     * Results are identical. Rust handles search and number/date sorting;
+     * text sorting always uses TypeScript (browser locale rules for Telugu).
+     */
+    engine?: GridEngine;
+    /**
+     * Show how long the last search/sort took and which engine answered,
+     * next to the row count, e.g. "12 rows · 0.9 ms · Rust". Default: false.
+     */
+    showSearchTime?: boolean;
+    /** Called after every search or sort with its time and engine. */
+    onSearchTime?: (info: GridSearchTime) => void;
+    /**
+     * Every result from the Agent.
+     */
+    onAgentResult?: (result: {
+        success: boolean;
+        message: string;
+        tool?: string;
+    }) => void;
+}

package/dist/grid/useGrid.d.ts

@@ -0,0 +1,57 @@
+import type { GridColumn, GridSearchTime, SortConfig, PaginationConfig } from "./types";
+import { type GridToolFilter } from "./gridTools";
+import { type GridEngine } from "./rust/engine";
+export interface UseGridOptions<T> {
+    data: T[];
+    columns: GridColumn<T>[];
+    pagination?: boolean | PaginationConfig;
+    mobileBreakpoint?: number;
+    /** Locale for text sorting, e.g. "te-IN" (default: browser locale) */
+    locale?: string;
+    /** Starting filters (optional) */
+    initialFilters?: GridToolFilter[];
+    /**
+     * Search and sort engine: "ts" (default), "rust" (always) or "auto" (Rust
+     * from 10,000 rows). Same results either way; Rust is faster on big data.
+     */
+    engine?: GridEngine;
+}
+export interface UseGridReturn<T> {
+    displayedData: T[];
+    /** All matching rows (search + filters + sort), before pagination */
+    rows: T[];
+    totalCount: number;
+    filteredCount: number;
+    sort: SortConfig | null;
+    toggleSort: (key: string) => void;
+    /** Set sort directly (null clears it) */
+    setSort: (sort: SortConfig | null) => void;
+    clearSort: () => void;
+    searchQuery: string;
+    setSearchQuery: (q: string) => void;
+    filters: GridToolFilter[];
+    setFilters: (filters: GridToolFilter[]) => void;
+    /** Add or replace the filter for one column */
+    setFilter: (filter: GridToolFilter) => void;
+    /** Remove the filter for one column */
+    removeFilter: (key: string) => void;
+    clearFilters: () => void;
+    page: number;
+    pageSize: number;
+    totalPages: number;
+    setPage: (p: number) => void;
+    setPageSize: (s: number) => void;
+    isMobile: boolean;
+    reset: () => void;
+    /** Last search/sort: time in ms and which engine answered (null when neither ran) */
+    searchTime: GridSearchTime | null;
+}
+/** One search text per row: each column's normalised text, joined by SEARCH_SEPARATOR. */
+export declare function gridSearchTexts<T extends Record<string, unknown>>(data: readonly T[], columns: readonly GridColumn<T>[]): string[];
+/**
+ * Sort keys that give exactly the order of compareValues(), or null when the
+ * column needs TypeScript (text, booleans, mixed values …). Empty = NaN.
+ */
+export declare function gridSortKeys<T extends Record<string, unknown>>(rows: readonly T[], key: string, type: GridColumn["type"]): Float64Array | null;
+export declare function useGrid<T extends Record<string, unknown>>(options: UseGridOptions<T>): UseGridReturn<T>;
+export default useGrid;