@svgrid/grid 2.4.0 → 2.5.1

package/src/ai.ts

@@ -1,1391 +1,1391 @@
-/**
- * Pro AI feature pack
- * -------------------
- *
- * Three jobs every analyst wishes a data grid could do:
- *
- *   1. Natural-language filter / sort  (`aiFilter`)
- *      "show me deals closing this quarter over $50k owned by Sasha"
- *      ->  { filters: [...], sort: [...] }
- *
- *   2. Smart fill  (`aiSmartFill`)
- *      User edits two cells in a column with example values; the
- *      Grid proposes the rest. Excel "Flash Fill" pattern.
- *
- *   3. Summarise rows  (`aiSummarize`)
- *      Single row, the current selection, a group key, or the whole
- *      filtered view -> a one-paragraph summary.
- *
- * The grid stays headless / model-agnostic. The consumer supplies an
- * `AIProvider` that knows how to call OpenAI / Anthropic / a local
- * model / a server-side proxy. We never bundle a model client.
- *
- * Built-in + free: the AI helpers live in `@svgrid/grid`. They ship no model
- * client and do nothing until you register a provider with `setAIProvider(...)`,
- * so they add nothing to the base bundle unless you actually use them.
- */
-
-import type { RowData, SvGridApi, TableFeatures } from './index'
-import { getExportProvider } from './export-provider'
-
-// Export formats an AI export can plan. WRITING the enterprise formats (xlsx /
-// pdf / html / xml / md) needs the export engine from `@svgrid/enterprise`
-// (registered via the export-provider seam); csv / tsv / json are also handled
-// by that engine when present. The union is declared locally so the free grid
-// carries no dependency on the enterprise export module.
-type ExportFormat = 'xlsx' | 'xls' | 'pdf' | 'csv' | 'tsv' | 'html' | 'json' | 'xml' | 'md'
-
-// ---------------------------------------------------------------------------
-// Provider contract
-// ---------------------------------------------------------------------------
-
-/**
- * Shape every consumer-provided model adapter must implement. Keeping this
- * tiny (one async call, two response formats) lets the same adapter drive
- * OpenAI's `chat.completions`, Anthropic's `messages`, a self-hosted
- * llama.cpp endpoint, or a server-side proxy. The grid only cares that the
- * provider eventually returns a string we can parse.
- */
-export type AIProvider = (request: AIRequest) => Promise<string>
-
-export type AIRequest = {
-  /** Full prompt the grid built for the model. Already includes column
-   *  schema and any sampled rows where applicable. */
-  prompt: string
-  /** When 'json', the provider should ask the model to return strict
-   *  JSON only - no prose. We parse the response with JSON.parse and
-   *  throw a typed error on failure. */
-  responseFormat?: 'text' | 'json'
-  /** Honored if the underlying transport supports cancellation. */
-  signal?: AbortSignal
-  /** Free-form tag for telemetry / logging. One of: 'filter',
-   *  'smart-fill', 'summarize', 'classify'. */
-  task: AITask
-  /** Soft hint to the provider about how many tokens we expect back.
-   *  Useful for routing small jobs to a cheaper model. */
-  maxOutputTokens?: number
-}
-
-export type AITask = 'filter' | 'smart-fill' | 'summarize' | 'classify' | 'export' | 'anomaly' | 'chart'
-
-let provider: AIProvider | null = null
-
-/**
- * Register the model adapter every AI call will route through. Call once
- * at app boot. Passing `null` clears the provider and AI calls revert to
- * throwing "no provider" errors.
- */
-export function setAIProvider(p: AIProvider | null): void {
-  provider = p
-}
-
-export function getAIProvider(): AIProvider | null {
-  return provider
-}
-
-export function hasAIProvider(): boolean {
-  return provider != null
-}
-
-class NoProviderError extends Error {
-  constructor() {
-    super(
-      '@svgrid/grid ai: no AI provider registered. Call setAIProvider(fn) ' +
-        'with an adapter that talks to OpenAI / Anthropic / your proxy.',
-    )
-    this.name = 'NoProviderError'
-  }
-}
-
-class BadJsonError extends Error {
-  constructor(raw: string) {
-    super(
-      '@svgrid/grid ai: provider returned non-JSON for a json-format request. ' +
-        `First 200 chars: ${raw.slice(0, 200)}`,
-    )
-    this.name = 'BadJsonError'
-  }
-}
-
-async function callProvider(req: AIRequest): Promise<string> {
-  if (!provider) throw new NoProviderError()
-  return provider(req)
-}
-
-async function callJSON<T>(req: AIRequest): Promise<T> {
-  const raw = await callProvider({ ...req, responseFormat: 'json' })
-  // Models occasionally wrap JSON in markdown code fences even when asked
-  // for raw JSON. Strip a single fenced block if present, then parse.
-  const stripped = raw.trim().replace(/^```(?:json)?\s*|\s*```$/g, '')
-  try {
-    return JSON.parse(stripped) as T
-  } catch {
-    throw new BadJsonError(raw)
-  }
-}
-
-// ---------------------------------------------------------------------------
-// Helpers - build column schema + row sample from the grid API
-// ---------------------------------------------------------------------------
-
-type ColumnSchemaEntry = {
-  field: string
-  type: 'string' | 'number' | 'boolean' | 'date' | 'unknown'
-  sampleValues: unknown[]
-}
-
-/**
- * Inspect the first N rows the grid is holding to infer a typed schema +
- * a handful of sample values per column. This is the context every AI
- * task needs and the most expensive thing to build, so the helpers cache
- * the result inside one task call rather than calling api.getData()
- * repeatedly.
- */
-function buildColumnSchema<
-  TFeatures extends TableFeatures,
-  TData extends RowData,
->(api: SvGridApi<TFeatures, TData>, sampleSize = 50): ColumnSchemaEntry[] {
-  const data = api.getData()
-  if (data.length === 0) return []
-  const slice = data.slice(0, Math.min(data.length, sampleSize))
-  const fields = new Set<string>()
-  for (const row of slice) {
-    for (const k of Object.keys(row as object)) fields.add(k)
-  }
-  const out: ColumnSchemaEntry[] = []
-  for (const field of fields) {
-    const values: unknown[] = []
-    for (const row of slice) {
-      const v = (row as Record<string, unknown>)[field]
-      if (v != null) values.push(v)
-      if (values.length >= 5) break
-    }
-    out.push({
-      field,
-      type: inferType(values),
-      sampleValues: values,
-    })
-  }
-  return out
-}
-
-function inferType(samples: unknown[]): ColumnSchemaEntry['type'] {
-  if (samples.length === 0) return 'unknown'
-  const v = samples[0]
-  if (typeof v === 'number') return 'number'
-  if (typeof v === 'boolean') return 'boolean'
-  if (typeof v === 'string') {
-    // Cheap ISO-date sniff so we route date-style filters correctly.
-    if (/^\d{4}-\d{2}-\d{2}/.test(v)) return 'date'
-    return 'string'
-  }
-  return 'unknown'
-}
-
-function schemaToPromptBlock(schema: ColumnSchemaEntry[]): string {
-  return schema
-    .map(
-      (c) =>
-        `- ${c.field} (${c.type}): e.g. ${c.sampleValues
-          .slice(0, 3)
-          .map((v) => JSON.stringify(v))
-          .join(', ')}`,
-    )
-    .join('\n')
-}
-
-// ---------------------------------------------------------------------------
-// 1. Natural-language filter / sort
-// ---------------------------------------------------------------------------
-
-export type AIFilterClause = {
-  field: string
-  operator: 'contains' | 'equals' | 'startsWith' | 'greaterThan' | 'lessThan' | 'isBlank'
-  value?: string
-}
-export type AISortClause = { field: string; desc: boolean }
-
-export type AIFilterResult = {
-  filters: AIFilterClause[]
-  sort: AISortClause[]
-  /** Plain-English explanation of how the model interpreted the query.
-   *  Surface this in the UI so the user can confirm or undo. */
-  rationale: string
-}
-
-export type AIFilterOptions = {
-  /**
-   * When true, the helper not only RETURNS the plan but also applies it
-   * to the grid via `api.setFilter` / `api.setSort`. Defaults to false
-   * so callers can show a preview before committing.
-   */
-  apply?: boolean
-  signal?: AbortSignal
-}
-
-/**
- * Translate a natural-language query into a filter+sort plan against
- * the current grid's columns. The grid passes the column schema (names,
- * types, sample values) to the model so it can pick the right field
- * names without hallucinating.
- */
-export async function aiFilter<
-  TFeatures extends TableFeatures,
-  TData extends RowData,
->(
-  api: SvGridApi<TFeatures, TData>,
-  query: string,
-  opts: AIFilterOptions = {},
-): Promise<AIFilterResult> {
-  const schema = buildColumnSchema(api)
-  const prompt =
-    `You are a data-grid filter planner. Translate the user's natural-language ` +
-    `query into a strict-JSON plan that the grid can apply.\n\n` +
-    `Columns:\n${schemaToPromptBlock(schema)}\n\n` +
-    `Output JSON schema:\n` +
-    `{ "filters": [{"field": "<one of the columns above>", ` +
-    `"operator": "contains"|"equals"|"startsWith"|"greaterThan"|"lessThan"|"isBlank", ` +
-    `"value": "<string>"}], ` +
-    `"sort": [{"field": "<column>", "desc": true|false}], ` +
-    `"rationale": "<one-sentence explanation>" }\n\n` +
-    `User query: ${query}\n\n` +
-    `Return JSON only, no prose.`
-
-  const result = await callJSON<AIFilterResult>({
-    prompt,
-    task: 'filter',
-    signal: opts.signal,
-    maxOutputTokens: 400,
-  })
-
-  // Defensive: drop anything that doesn't match a real column. Models love
-  // to invent plausible-sounding field names; we'd rather skip a clause
-  // than throw at runtime.
-  const valid = new Set(schema.map((c) => c.field))
-  result.filters = (result.filters ?? []).filter((f) => valid.has(f.field))
-  result.sort = (result.sort ?? []).filter((s) => valid.has(s.field))
-
-  if (opts.apply) {
-    api.clearAllFilters()
-    api.clearSort()
-    for (const f of result.filters) {
-      api.setFilter(f.field, { operator: f.operator, value: f.value ?? '' })
-    }
-    // Multiple sort clauses get applied last-wins because the public
-    // `setSort` is single-key. Multi-sort is on the roadmap.
-    const last = result.sort[result.sort.length - 1]
-    if (last) api.setSort(last.field, last.desc ? 'desc' : 'asc')
-  }
-
-  return result
-}
-
-// ---------------------------------------------------------------------------
-// 2. Smart fill
-// ---------------------------------------------------------------------------
-
-export type AISmartFillExample = { input: Record<string, unknown>; output: unknown }
-
-export type AISmartFillResult<TValue = unknown> = {
-  field: string
-  predictions: Array<{ rowIndex: number; value: TValue; confidence: number }>
-  rationale: string
-}
-
-export type AISmartFillOptions = {
-  /** Target column - the one whose values we want filled. */
-  field: string
-  /** Index of rows the model should propose values for. If omitted, every
-   *  row whose current `field` value is `null`, `undefined` or `''` is
-   *  selected automatically. */
-  targetRowIndices?: number[]
-  /**
-   * Worked examples the user has already filled in. Required - the
-   * model needs at least one to know the pattern, two or more to lock
-   * the schema. We don't pull these from the grid automatically because
-   * "edited" vs "untouched" isn't a state SvGrid exposes today.
-   */
-  examples: AISmartFillExample[]
-  signal?: AbortSignal
-}
-
-/**
- * Given a column and a few user-provided examples, propose values for the
- * untouched rows. Returns predictions only - the caller chooses whether to
- * commit them via `api.setCellValue`. This is the right shape for an
- * accept-per-cell UX with confidence-coloured highlights.
- */
-export async function aiSmartFill<
-  TFeatures extends TableFeatures,
-  TData extends RowData,
-  TValue = unknown,
->(
-  api: SvGridApi<TFeatures, TData>,
-  opts: AISmartFillOptions,
-): Promise<AISmartFillResult<TValue>> {
-  if (opts.examples.length === 0) {
-    throw new Error('@svgrid/grid ai: aiSmartFill requires at least one example.')
-  }
-  const data = api.getData()
-  const targets =
-    opts.targetRowIndices ??
-    data
-      .map((row, i) => {
-        const v = (row as Record<string, unknown>)[opts.field]
-        return v == null || v === '' ? i : -1
-      })
-      .filter((i) => i >= 0)
-
-  if (targets.length === 0) {
-    return { field: opts.field, predictions: [], rationale: 'No empty cells to fill.' }
-  }
-
-  const examplesBlock = opts.examples
-    .map((ex, i) => `Example ${i + 1}: input=${JSON.stringify(ex.input)} -> output=${JSON.stringify(ex.output)}`)
-    .join('\n')
-
-  const targetRowsBlock = targets
-    .map((i) => `Row ${i}: ${JSON.stringify(data[i])}`)
-    .join('\n')
-
-  const prompt =
-    `You are filling in a single column of a data grid based on user-provided ` +
-    `examples. Match the pattern in the examples exactly.\n\n` +
-    `Target column: ${opts.field}\n\n` +
-    `Examples:\n${examplesBlock}\n\n` +
-    `Rows to fill:\n${targetRowsBlock}\n\n` +
-    `Return strict JSON only:\n` +
-    `{ "predictions": [{"rowIndex": <number>, "value": <inferred value>, ` +
-    `"confidence": <0..1>}], "rationale": "<one-sentence pattern description>" }`
-
-  const result = await callJSON<{
-    predictions: Array<{ rowIndex: number; value: TValue; confidence: number }>
-    rationale: string
-  }>({
-    prompt,
-    task: 'smart-fill',
-    signal: opts.signal,
-    maxOutputTokens: 600,
-  })
-
-  return {
-    field: opts.field,
-    predictions: result.predictions ?? [],
-    rationale: result.rationale ?? '',
-  }
-}
-
-// ---------------------------------------------------------------------------
-// 3. Summarise
-// ---------------------------------------------------------------------------
-
-export type AISummarizeTarget =
-  | { kind: 'row'; rowIndex: number }
-  | { kind: 'all' }
-  | { kind: 'selection'; rowIndices: number[] }
-  | { kind: 'group'; field: string; value: unknown }
-
-export type AISummary = {
-  text: string
-  bullets: string[]
-  /** Field names the model thinks are the most load-bearing for the
-   *  story it just told. UI can highlight those columns. */
-  highlightedFields: string[]
-}
-
-export type AISummarizeOptions = {
-  target: AISummarizeTarget
-  /** Optional question the user is trying to answer. Helps the model
-   *  bias the summary toward the relevant columns. */
-  question?: string
-  signal?: AbortSignal
-}
-
-/**
- * Ask the model to summarise a slice of the grid. Caps the row sample at
- * a model-friendly size; for huge selections it samples uniformly so the
- * summary stays representative without blowing the context window.
- */
-export async function aiSummarize<
-  TFeatures extends TableFeatures,
-  TData extends RowData,
->(
-  api: SvGridApi<TFeatures, TData>,
-  opts: AISummarizeOptions,
-): Promise<AISummary> {
-  const all = api.getData()
-  const rows: TData[] = (() => {
-    const t = opts.target
-    if (t.kind === 'row') {
-      const r = all[t.rowIndex]
-      return r ? [r] : []
-    }
-    if (t.kind === 'selection') {
-      return t.rowIndices.map((i) => all[i]).filter((r): r is TData => r != null)
-    }
-    if (t.kind === 'group') {
-      return all.filter((r) => (r as Record<string, unknown>)[t.field] === t.value)
-    }
-    return all.slice()
-  })()
-
-  if (rows.length === 0) {
-    return { text: 'No rows in scope.', bullets: [], highlightedFields: [] }
-  }
-
-  // Uniform sample to stay inside a sensible context budget.
-  const MAX_SAMPLE = 25
-  const sample = rows.length <= MAX_SAMPLE
-    ? rows
-    : Array.from({ length: MAX_SAMPLE }, (_, i) => rows[Math.floor((i / MAX_SAMPLE) * rows.length)]!)
-
-  const schema = buildColumnSchema(api, 30)
-  const prompt =
-    `You are summarising a slice of a business data grid for a busy analyst.\n\n` +
-    `Columns:\n${schemaToPromptBlock(schema)}\n\n` +
-    `Slice size: ${rows.length} row(s). Sampled rows shown below.\n` +
-    `${sample.map((r) => JSON.stringify(r)).join('\n')}\n\n` +
-    (opts.question ? `User's question: ${opts.question}\n\n` : '') +
-    `Return strict JSON only:\n` +
-    `{ "text": "<one short paragraph>", ` +
-    `"bullets": ["<3-5 punchy bullets>"], ` +
-    `"highlightedFields": ["<column names the summary leans on>"] }`
-
-  const result = await callJSON<AISummary>({
-    prompt,
-    task: 'summarize',
-    signal: opts.signal,
-    maxOutputTokens: 600,
-  })
-  return {
-    text: result.text ?? '',
-    bullets: result.bullets ?? [],
-    highlightedFields: result.highlightedFields ?? [],
-  }
-}
-
-// ---------------------------------------------------------------------------
-// 4. Classify (free-text -> bucketed value)
-// ---------------------------------------------------------------------------
-
-export type AIClassifyOptions = {
-  /** Column whose free-text we're classifying. */
-  inputField: string
-  /** Target column the model should write to. */
-  outputField: string
-  /** Allowed values. The model is constrained to pick one. */
-  classes: string[]
-  /** Optional one-line description of each class (acts as a labeling rubric). */
-  classDescriptions?: Record<string, string>
-  /** Rows to classify. Defaults to all. */
-  targetRowIndices?: number[]
-  signal?: AbortSignal
-}
-
-export type AIClassifyResult = {
-  inputField: string
-  outputField: string
-  predictions: Array<{ rowIndex: number; value: string; confidence: number }>
-}
-
-/**
- * Bucket free-text cells into one of a known set of classes. The model
- * is constrained to pick from `opts.classes`; predictions outside the set
- * are dropped so the caller can rely on the output being clean enum
- * values it can write straight back into the grid.
- */
-export async function aiClassify<
-  TFeatures extends TableFeatures,
-  TData extends RowData,
->(
-  api: SvGridApi<TFeatures, TData>,
-  opts: AIClassifyOptions,
-): Promise<AIClassifyResult> {
-  const data = api.getData()
-  const targets = opts.targetRowIndices ?? data.map((_, i) => i)
-  const rubric = opts.classDescriptions
-    ? Object.entries(opts.classDescriptions)
-        .map(([k, v]) => `- ${k}: ${v}`)
-        .join('\n')
-    : opts.classes.map((c) => `- ${c}`).join('\n')
-
-  const rowsBlock = targets
-    .map((i) => `Row ${i}: ${JSON.stringify((data[i] as Record<string, unknown>)?.[opts.inputField] ?? '')}`)
-    .join('\n')
-
-  const prompt =
-    `You are a strict text classifier. For each row, pick exactly one ` +
-    `label from the list. If unsure, pick the closest match and lower the ` +
-    `confidence.\n\n` +
-    `Allowed labels (with optional rubric):\n${rubric}\n\n` +
-    `Rows to classify (text from column "${opts.inputField}"):\n${rowsBlock}\n\n` +
-    `Return strict JSON only:\n` +
-    `{ "predictions": [{"rowIndex": <number>, "value": "<label>", "confidence": <0..1>}] }`
-
-  const result = await callJSON<{
-    predictions: Array<{ rowIndex: number; value: string; confidence: number }>
-  }>({
-    prompt,
-    task: 'classify',
-    signal: opts.signal,
-    maxOutputTokens: Math.min(2000, 30 + targets.length * 30),
-  })
-
-  const allowed = new Set(opts.classes)
-  return {
-    inputField: opts.inputField,
-    outputField: opts.outputField,
-    predictions: (result.predictions ?? []).filter((p) => allowed.has(p.value)),
-  }
-}
-
-// ---------------------------------------------------------------------------
-// 5. Natural-language export
-// ---------------------------------------------------------------------------
-
-const EXPORT_FORMATS: ExportFormat[] = ['xlsx', 'xls', 'pdf', 'csv', 'tsv', 'html', 'json', 'xml', 'md']
-
-export type AIExportPlan = {
-  format: ExportFormat
-  filters: AIFilterClause[]
-  sort: AISortClause[]
-  groupBy: string[]
-  /** Plain-English explanation of how the model read the request. */
-  rationale: string
-}
-
-export type AIExportOptions = {
-  /**
-   * Also apply the filter / sort / grouping to the grid (mutating the view) so
-   * it mirrors the export. Default FALSE - the export is self-contained (it
-   * computes its own rows), so the grid is left untouched unless you opt in.
-   */
-  apply?: boolean
-  /** Actually download the file. Default true; set false to preview the plan. */
-  run?: boolean
-  /** Base filename (no extension). Default 'export'. */
-  filename?: string
-  signal?: AbortSignal
-}
-
-/**
- * Turn a natural-language request ("export EU orders from Q2 as a grouped PDF")
- * into an export: the model returns a `{ format, filters, sort, groupBy }` plan
- * against the grid's columns; we apply the filter/sort to the grid and hand the
- * result to the registered export engine (@svgrid/enterprise). Returns the plan
- * so the UI can show what it did (or preview it first with `run: false`).
- */
-export async function aiExport<
-  TFeatures extends TableFeatures,
-  TData extends RowData,
->(
-  api: SvGridApi<TFeatures, TData>,
-  query: string,
-  opts: AIExportOptions = {},
-): Promise<AIExportPlan> {
-  const schema = buildColumnSchema(api)
-  const prompt =
-    `You are an export assistant for a data grid. Translate the user's request ` +
-    `into a strict-JSON export plan.\n\n` +
-    `Columns:\n${schemaToPromptBlock(schema)}\n\n` +
-    `Output JSON schema:\n` +
-    `{ "format": "xlsx"|"xls"|"pdf"|"csv"|"tsv"|"html"|"json"|"xml"|"md", ` +
-    `"filters": [{"field":"<column>","operator":"contains"|"equals"|"startsWith"|"greaterThan"|"lessThan"|"isBlank","value":"<string>"}], ` +
-    `"sort": [{"field":"<column>","desc":true|false}], ` +
-    `"groupBy": ["<column>"], ` +
-    `"rationale": "<one sentence>" }\n\n` +
-    `Rules: use the format the user names (default "xlsx"); only use column ` +
-    `names from the list above; "grouped" / "group by X" -> groupBy. ` +
-    `Return JSON only, no prose.\n\n` +
-    `User request: ${query}`
-
-  const plan = await callJSON<AIExportPlan>({
-    prompt,
-    task: 'export',
-    signal: opts.signal,
-    maxOutputTokens: 500,
-  })
-
-  // Defensive validation - drop invented fields, clamp the format.
-  const valid = new Set(schema.map((c) => c.field))
-  plan.format = EXPORT_FORMATS.includes(plan.format) ? plan.format : 'xlsx'
-  plan.filters = (plan.filters ?? []).filter((f) => valid.has(f.field))
-  plan.sort = (plan.sort ?? []).filter((s) => valid.has(s.field))
-  plan.groupBy = (plan.groupBy ?? []).filter((g) => valid.has(g))
-  plan.rationale = plan.rationale ?? ''
-
-  // Optionally mirror the plan onto the grid (opt-in). Off by default so the
-  // export never disturbs the user's current view.
-  if (opts.apply === true) {
-    api.clearAllFilters()
-    api.clearSort()
-    for (const f of plan.filters) {
-      api.setFilter(f.field, { operator: f.operator, value: f.value ?? '' })
-    }
-    const last = plan.sort[plan.sort.length - 1]
-    if (last) api.setSort(last.field, last.desc ? 'desc' : 'asc')
-    if (plan.groupBy.length > 0) {
-      try {
-        api.setGroupBy(plan.groupBy)
-      } catch {
-        // grouping feature not enabled - the export still groups on its own
-      }
-    }
-  }
-
-  // Planning is always free; WRITING the file uses the export engine registered
-  // by @svgrid/enterprise (export-provider seam). Without it, we return the plan
-  // so the UI can still show what the AI decided - the download just no-ops.
-  const runExport = getExportProvider()
-  if (opts.run !== false && runExport) {
-    // Compute the export rows from the plan directly (filter + sort + make
-    // contiguous by group) rather than reading the grid's reactive displayed
-    // rows - so the download always has exactly the intended data.
-    const exportRows = applyPlanToRows(api.getData(), plan)
-    await runExport(api, {
-      format: plan.format,
-      filename: opts.filename ?? 'export',
-      rows: exportRows,
-      ...(plan.groupBy.length > 0 ? { groupBy: plan.groupBy } : {}),
-    })
-  }
-  return plan
-}
-
-/** Evaluate one AI filter clause against a raw row value. */
-function matchesClause(row: Record<string, unknown>, clause: AIFilterClause): boolean {
-  const v = row[clause.field]
-  const val = clause.value ?? ''
-  switch (clause.operator) {
-    case 'contains':
-      return String(v ?? '').toLowerCase().includes(val.toLowerCase())
-    case 'equals':
-      return String(v ?? '').toLowerCase() === val.toLowerCase()
-    case 'startsWith':
-      return String(v ?? '').toLowerCase().startsWith(val.toLowerCase())
-    case 'greaterThan':
-      return Number(v) > Number(val)
-    case 'lessThan':
-      return Number(v) < Number(val)
-    case 'isBlank':
-      return v == null || v === ''
-    default:
-      return true
-  }
-}
-
-/** Filter + sort + (stable) group the raw rows per an export plan. */
-function applyPlanToRows<TData extends RowData>(
-  data: ReadonlyArray<TData>,
-  plan: AIExportPlan,
-): TData[] {
-  let rows: TData[] = data.slice()
-  if (plan.filters.length > 0) {
-    rows = rows.filter((r) =>
-      plan.filters.every((f) => matchesClause(r as Record<string, unknown>, f)),
-    )
-  }
-  const last = plan.sort[plan.sort.length - 1]
-  if (last) {
-    rows = [...rows].sort((a, b) => {
-      const av = (a as Record<string, unknown>)[last.field]
-      const bv = (b as Record<string, unknown>)[last.field]
-      const na = Number(av)
-      const nb = Number(bv)
-      let cmp: number
-      if (Number.isFinite(na) && Number.isFinite(nb)) cmp = na - nb
-      else cmp = String(av ?? '').localeCompare(String(bv ?? ''))
-      return last.desc ? -cmp : cmp
-    })
-  }
-  // Contiguous grouping (first-seen order) so PDF group rows + Excel outline
-  // line up.
-  if (plan.groupBy.length > 0) {
-    const buckets = new Map<string, TData[]>()
-    for (const r of rows) {
-      const key = plan.groupBy
-        .map((k) => String((r as Record<string, unknown>)[k] ?? ''))
-        .join('
')
-      const bucket = buckets.get(key)
-      if (bucket) bucket.push(r)
-      else buckets.set(key, [r])
-    }
-    rows = [...buckets.values()].flat()
-  }
-  return rows
-}
-
-// ---------------------------------------------------------------------------
-// 6. Find anomalies
-// ---------------------------------------------------------------------------
-
-export type AIAnomaly = {
-  /** Index into the SCANNED rows (target order), when the model pins one row. */
-  rowIndex?: number
-  field?: string
-  value?: unknown
-  reason: string
-  severity: 'low' | 'medium' | 'high'
-}
-
-export type AIAnomalyResult = {
-  anomalies: AIAnomaly[]
-  summary: string
-}
-
-export type AIAnomalyOptions = {
-  /** Which rows to scan. Defaults to the whole dataset. */
-  target?: AISummarizeTarget
-  /** Optional focus, e.g. "look at pricing and margins". */
-  question?: string
-  signal?: AbortSignal
-}
-
-function sliceForTarget<TFeatures extends TableFeatures, TData extends RowData>(
-  api: SvGridApi<TFeatures, TData>,
-  target: AISummarizeTarget,
-): TData[] {
-  const all = api.getData()
-  if (target.kind === 'row') {
-    const r = all[target.rowIndex]
-    return r ? [r] : []
-  }
-  if (target.kind === 'selection') {
-    return target.rowIndices.map((i) => all[i]).filter((r): r is TData => r != null)
-  }
-  if (target.kind === 'group') {
-    return all.filter((r) => (r as Record<string, unknown>)[target.field] === target.value)
-  }
-  return all.slice()
-}
-
-/**
- * Scan a slice of the grid (all / selection / group) for anomalies - outliers,
- * suspicious values, inconsistencies - and return a structured list plus a
- * one-line summary. Pairs naturally with an export: "find the odd ones, then
- * export just those".
- */
-export async function aiFindAnomalies<
-  TFeatures extends TableFeatures,
-  TData extends RowData,
->(
-  api: SvGridApi<TFeatures, TData>,
-  opts: AIAnomalyOptions = {},
-): Promise<AIAnomalyResult> {
-  const rows = sliceForTarget(api, opts.target ?? { kind: 'all' })
-  if (rows.length === 0) return { anomalies: [], summary: 'No rows in scope.' }
-
-  const MAX_SAMPLE = 40
-  const sample =
-    rows.length <= MAX_SAMPLE
-      ? rows
-      : Array.from(
-          { length: MAX_SAMPLE },
-          (_, i) => rows[Math.floor((i / MAX_SAMPLE) * rows.length)]!,
-        )
-
-  const schema = buildColumnSchema(api, 30)
-  const prompt =
-    `You are a data-quality analyst. Scan the rows below for anomalies: ` +
-    `numeric outliers, impossible / inconsistent values, unexpected blanks, ` +
-    `and values that break the pattern of the column.\n\n` +
-    `Columns:\n${schemaToPromptBlock(schema)}\n\n` +
-    `Rows (index is 0-based into this list):\n` +
-    `${sample.map((r, i) => `${i}: ${JSON.stringify(r)}`).join('\n')}\n\n` +
-    (opts.question ? `Focus: ${opts.question}\n\n` : '') +
-    `Return strict JSON only:\n` +
-    `{ "anomalies": [{"rowIndex": <number|null>, "field": "<column|null>", ` +
-    `"reason": "<why it's odd>", "severity": "low"|"medium"|"high"}], ` +
-    `"summary": "<one sentence>" }`
-
-  const result = await callJSON<AIAnomalyResult>({
-    prompt,
-    task: 'anomaly',
-    signal: opts.signal,
-    maxOutputTokens: 800,
-  })
-  return {
-    anomalies: result.anomalies ?? [],
-    summary: result.summary ?? '',
-  }
-}
-
-// ---------------------------------------------------------------------------
-// 7. Natural-language chart ("chart this")
-// ---------------------------------------------------------------------------
-
-export type AIChartType = 'bar' | 'line' | 'area' | 'pie'
-
-export type AIChartPlan = {
-  type: AIChartType
-  /** Group-by (category-axis) column field, or null. */
-  dimension: string | null
-  /** Split-by column field: one series per distinct value, or null. */
-  series: string | null
-  /** Measure (value-axis) column field, or null. */
-  measure: string | null
-  reduce: 'sum' | 'avg' | 'count'
-  stacked: boolean
-  logScale: boolean
-  timeAxis: boolean
-  valueFormat: 'number' | 'currency' | 'percent'
-  rationale: string
-}
-
-export type AIChartOptions = {
-  /** Apply the plan to the grid's chart panel (open + configure). Default false. */
-  apply?: boolean
-  signal?: AbortSignal
-}
-
-/**
- * Translate a natural-language request into a chart plan for the grid's built-in
- * `charting` panel. Validates every field against the real schema, then (with
- * `apply: true`) pushes it into the panel through `api.configureChart`.
- */
-export async function aiChart<
-  TFeatures extends TableFeatures,
-  TData extends RowData,
->(
-  api: SvGridApi<TFeatures, TData>,
-  query: string,
-  opts: AIChartOptions = {},
-): Promise<AIChartPlan> {
-  const schema = buildColumnSchema(api)
-  const prompt =
-    `You are a charting assistant for a data grid. Translate the user's request ` +
-    `into a strict-JSON chart plan the grid can render.\n\n` +
-    `Columns:\n${schemaToPromptBlock(schema)}\n\n` +
-    `Output JSON schema:\n` +
-    `{ "type": "bar"|"line"|"area"|"pie", ` +
-    `"dimension": "<a categorical column to group by>", ` +
-    `"series": "<a second categorical column to split into series, or null>", ` +
-    `"measure": "<a numeric column to aggregate>", ` +
-    `"reduce": "sum"|"avg"|"count", ` +
-    `"stacked": true|false, ` +
-    `"logScale": true|false, ` +
-    `"timeAxis": true|false, ` +
-    `"valueFormat": "number"|"currency"|"percent", ` +
-    `"rationale": "<one-sentence explanation>" }\n\n` +
-    `Rules: pick "dimension" and "series" from text/date columns and "measure" ` +
-    `from a numeric column; use only column names from the list above; ` +
-    `"stacked"/"stack" -> stacked:true; "log"/"logarithmic" -> logScale:true; ` +
-    `"over time"/"by date"/a date dimension -> timeAxis:true; ` +
-    `money/revenue/price/$ -> valueFormat:"currency"; rate/%/share -> valueFormat:"percent"; ` +
-    `else valueFormat:"number". default reduce is "sum". ` +
-    `Return JSON only, no prose.\n\n` +
-    `User request: ${query}`
-
-  const plan = await callJSON<AIChartPlan>({
-    prompt,
-    task: 'chart',
-    signal: opts.signal,
-    maxOutputTokens: 300,
-  })
-
-  const valid = new Set(schema.map((c) => c.field))
-  const numericFields = new Set(schema.filter((c) => c.type === 'number').map((c) => c.field))
-  const CHART_TYPES: AIChartType[] = ['bar', 'line', 'area', 'pie']
-  plan.type = CHART_TYPES.includes(plan.type) ? plan.type : 'bar'
-  plan.dimension = plan.dimension && valid.has(plan.dimension) ? plan.dimension : null
-  plan.series = plan.series && valid.has(plan.series) && plan.series !== plan.dimension ? plan.series : null
-  plan.measure =
-    plan.measure && numericFields.has(plan.measure)
-      ? plan.measure
-      : (schema.find((c) => c.type === 'number')?.field ?? null)
-  plan.reduce = ['sum', 'avg', 'count'].includes(plan.reduce) ? plan.reduce : 'sum'
-  plan.stacked = plan.stacked === true
-  plan.logScale = plan.logScale === true
-  plan.timeAxis = plan.timeAxis === true
-  plan.valueFormat = ['number', 'currency', 'percent'].includes(plan.valueFormat) ? plan.valueFormat : 'number'
-  plan.rationale = plan.rationale ?? ''
-
-  if (opts.apply === true) {
-    const cfg = api as unknown as { configureChart?: (c: Record<string, unknown>) => void }
-    cfg.configureChart?.({
-      open: true,
-      type: plan.type,
-      dimension: plan.dimension,
-      series: plan.series,
-      measure: plan.measure,
-      reduce: plan.reduce,
-      stacked: plan.stacked,
-      logScale: plan.logScale,
-      timeAxis: plan.timeAxis,
-      valueFormat: plan.valueFormat,
-    })
-  }
-
-  return plan
-}
-
-/**
- * Wire the grid's chart-panel AI button to the model: registers a handler (via
- * `api.setChartAiHandler`) that runs `aiChart` and returns the plan for the
- * panel to apply + explain. Call once after `onApiReady`. `installEnterprise`
- * calls this for you.
- */
-export function enableAiCharting<
-  TFeatures extends TableFeatures,
-  TData extends RowData,
->(api: SvGridApi<TFeatures, TData>): void {
-  const hook = api as unknown as {
-    setChartAiHandler?: (
-      fn: ((prompt: string) => Promise<Record<string, unknown> | null>) | null,
-    ) => void
-  }
-  hook.setChartAiHandler?.(async (prompt: string) => {
-    const plan = await aiChart(api, prompt)
-    return {
-      type: plan.type,
-      dimension: plan.dimension,
-      series: plan.series,
-      measure: plan.measure,
-      reduce: plan.reduce,
-      stacked: plan.stacked,
-      logScale: plan.logScale,
-      timeAxis: plan.timeAxis,
-      valueFormat: plan.valueFormat,
-      rationale: plan.rationale,
-    }
-  })
-}
-
-export function disableAiCharting<
-  TFeatures extends TableFeatures,
-  TData extends RowData,
->(api: SvGridApi<TFeatures, TData>): void {
-  const hook = api as unknown as { setChartAiHandler?: (fn: null) => void }
-  hook.setChartAiHandler?.(null)
-}
-
-// ---------------------------------------------------------------------------
-// 8. Mock provider for examples + tests
-// ---------------------------------------------------------------------------
-
-/**
- * A deterministic provider that returns canned, schema-shaped responses
- * for each task. Wire it in via `setAIProvider(mockAIProvider)` to make
- * the AI demo work end-to-end without a real model key. Not for production.
- */
-export const mockAIProvider: AIProvider = async (req) => {
-  // Tiny artificial delay so the UI's "thinking" state is visible.
-  await new Promise((r) => setTimeout(r, 350 + Math.random() * 400))
-
-  if (req.task === 'filter') {
-    const q = extractUserQuery(req.prompt)
-    return JSON.stringify(buildMockFilter(req.prompt, q))
-  }
-  if (req.task === 'smart-fill') {
-    return JSON.stringify(buildMockSmartFill(req.prompt))
-  }
-  if (req.task === 'summarize') {
-    return JSON.stringify(buildMockSummary(req.prompt))
-  }
-  if (req.task === 'classify') {
-    return JSON.stringify(buildMockClassify(req.prompt))
-  }
-  if (req.task === 'export') {
-    return JSON.stringify(buildMockExport(req.prompt))
-  }
-  if (req.task === 'anomaly') {
-    return JSON.stringify(buildMockAnomaly(req.prompt))
-  }
-  if (req.task === 'chart') {
-    return JSON.stringify(buildMockChart(req.prompt))
-  }
-  return '{}'
-}
-
-function buildMockChart(prompt: string): AIChartPlan {
-  const q = extractUserRequest(prompt)
-  const typed = extractFieldTypes(prompt)
-  const textFields = typed.filter((f) => f.type === 'string' || f.type === 'date').map((f) => f.name)
-  const numberFields = typed.filter((f) => f.type === 'number').map((f) => f.name)
-
-  const type: AIChartType =
-    /\bline\b|\btrend\b|over time/.test(q) ? 'line'
-    : /\barea\b/.test(q) ? 'area'
-    : /\bpie\b|share|proportion|breakdown/.test(q) ? 'pie'
-    : 'bar'
-
-  const byMatch = q.match(/\bby\s+([a-z0-9_ ]+?)(?:\s+(?:split|stacked|grouped|by|as|,|$))/)
-  const pickText = (hint?: string): string | null => {
-    if (hint) {
-      const f = textFields.find((t) => t.toLowerCase() === hint.trim() || (hint.trim().length >= 4 && t.toLowerCase().includes(hint.trim())))
-      if (f) return f
-    }
-    return null
-  }
-  const dimension = pickText(byMatch?.[1]) ?? textFields[0] ?? null
-  const series =
-    /\b(split|stack(?:ed)?|by product|by category|per)\b/.test(q)
-      ? (textFields.find((t) => t !== dimension) ?? null)
-      : null
-  const measure = numberFields.find((n) => q.includes(n.toLowerCase())) ?? numberFields[0] ?? null
-  const reduce: 'sum' | 'avg' | 'count' =
-    /\b(average|avg|mean)\b/.test(q) ? 'avg' : /\b(count|number of|how many)\b/.test(q) ? 'count' : 'sum'
-  const stacked = /\bstack(ed)?\b/.test(q)
-  const logScale = /\b(log|logarithmic)\b/.test(q)
-  const timeAxis = /\b(over time|by date|by day|by month|by week|time series|timeline|trend)\b/.test(q)
-  const valueFormat: 'number' | 'currency' | 'percent' =
-    /\b(currency|money|revenue|sales|price|cost|\$|dollar)\b/.test(q) || /(price|revenue|amount|cost|sales)/i.test(measure ?? '')
-      ? 'currency'
-      : /\b(percent|percentage|%|rate|share)\b/.test(q)
-        ? 'percent'
-        : 'number'
-
-  return {
-    type, dimension, series, measure, reduce, stacked, logScale, timeAxis, valueFormat,
-    rationale:
-      `${type} chart of ${reduce}(${measure ?? 'value'}) by ${dimension ?? 'category'}` +
-      `${series ? `, split by ${series}` : ''}${stacked ? ', stacked' : ''}` +
-      `${logScale ? ', log scale' : ''}${timeAxis ? ', date axis' : ''} (mock - wire a real model for genuine parsing).`,
-  }
-}
-
-function extractUserRequest(prompt: string): string {
-  const m = prompt.match(/User request:\s*([\s\S]+)$/)
-  return (m?.[1] ?? '').trim().toLowerCase()
-}
-
-function buildMockExport(prompt: string): AIExportPlan {
-  const q = extractUserRequest(prompt)
-  const fields = extractFields(prompt)
-  // Reuse the filter mock (it reads "User query:"; feed it a compatible line).
-  const filterPlan = buildMockFilter(prompt + `\nUser query: ${q}\n`, q)
-
-  // Format keyword routing.
-  const format: ExportFormat =
-    /\bpdf\b/.test(q) ? 'pdf'
-    : /\bxls\b(?!x)/.test(q) || /97-2003|legacy excel/.test(q) ? 'xls'
-    : /\b(xlsx|excel|spreadsheet|workbook)\b/.test(q) ? 'xlsx'
-    : /\b(markdown|md)\b/.test(q) ? 'md'
-    : /\bjson\b/.test(q) ? 'json'
-    : /\bxml\b/.test(q) ? 'xml'
-    : /\btsv\b/.test(q) ? 'tsv'
-    : /\bhtml\b/.test(q) ? 'html'
-    : /\bcsv\b/.test(q) ? 'csv'
-    : 'xlsx'
-
-  // Grouping: "group by X" / "grouped by X", else "grouped" -> a categorical field.
-  const groupBy: string[] = []
-  const byMatch = q.match(/group(?:ed)?\s+by\s+([a-z0-9_ ,]+)/)
-  if (byMatch) {
-    for (const token of byMatch[1]!.split(/[, ]+/).filter(Boolean)) {
-      // Exact field match, or a substring match only for tokens long enough to
-      // be meaningful (so "a"/"as" don't match "amount").
-      const f = fields.find(
-        (ff) => ff.toLowerCase() === token || (token.length >= 4 && ff.toLowerCase().includes(token)),
-      )
-      if (f && !groupBy.includes(f)) groupBy.push(f)
-    }
-  } else if (/\bgroup(ed)?\b/.test(q)) {
-    const cat = fields.find((f) => /region|country|category|status|stage|type|group|dept|team/i.test(f))
-    if (cat) groupBy.push(cat)
-  }
-
-  return {
-    format,
-    filters: filterPlan.filters,
-    sort: filterPlan.sort,
-    groupBy,
-    rationale: `Export as ${format}${groupBy.length ? `, grouped by ${groupBy.join(' / ')}` : ''}${filterPlan.filters.length ? `; ${filterPlan.rationale}` : ''}`,
-  }
-}
-
-function buildMockAnomaly(prompt: string): AIAnomalyResult {
-  // Parse the sampled rows, flag the numeric outliers per numeric field.
-  const rowsBlock = prompt.match(/Rows \(index is 0-based into this list\):\n([\s\S]*?)\n\n/)?.[1] ?? ''
-  const parsed = rowsBlock
-    .split('\n')
-    .map((line) => {
-      const m = line.match(/^(\d+):\s*(\{[\s\S]*\})$/)
-      if (!m) return null
-      const row = safeParse(m[2]!) as Record<string, unknown> | null
-      return row ? { idx: parseInt(m[1]!, 10), row } : null
-    })
-    .filter((r): r is { idx: number; row: Record<string, unknown> } => !!r)
-
-  if (parsed.length === 0) {
-    return { anomalies: [], summary: 'No rows to scan (mock).' }
-  }
-
-  // Genuinely numeric fields only: every value is null or a real number (so
-  // booleans like `inStock` and id-ish strings are excluded). Also skip
-  // identifier / row-index columns - a max "id" isn't an anomaly.
-  const isIdLike = (f: string) => /(^id$|_id$|index|idx|^#|guid|uuid|serial|rownum)/i.test(f)
-  const numericFields = Object.keys(parsed[0]!.row).filter(
-    (f) =>
-      !isIdLike(f) &&
-      parsed.some((p) => typeof p.row[f] === 'number') &&
-      parsed.every((p) => p.row[f] == null || typeof p.row[f] === 'number'),
-  )
-
-  const anomalies: AIAnomaly[] = []
-  for (const f of numericFields.slice(0, 2)) {
-    let maxIdx = -1
-    let maxVal = -Infinity
-    for (const p of parsed) {
-      const n = Number(p.row[f])
-      if (Number.isFinite(n) && n > maxVal) {
-        maxVal = n
-        maxIdx = p.idx
-      }
-    }
-    if (maxIdx >= 0) {
-      anomalies.push({
-        rowIndex: maxIdx,
-        field: f,
-        value: maxVal,
-        reason: `${f} = ${maxVal} is the highest in the sample and may be an outlier`,
-        severity: 'medium',
-      })
-    }
-  }
-
-  return {
-    anomalies,
-    summary:
-      anomalies.length > 0
-        ? `Flagged ${anomalies.length} potential outlier${anomalies.length === 1 ? '' : 's'} (mock heuristic - wire a real model for genuine analysis).`
-        : 'No obvious anomalies in the sample (mock).',
-  }
-}
-
-function extractUserQuery(prompt: string): string {
-  const m = prompt.match(/User query:\s*(.+?)\n/)
-  return (m?.[1] ?? '').toLowerCase()
-}
-
-function extractFields(prompt: string): string[] {
-  const m = prompt.match(/Columns:\n([\s\S]*?)\n\n/)
-  if (!m) return []
-  return (m[1] ?? '')
-    .split('\n')
-    .map((l) => l.match(/^- (\w+)/)?.[1])
-    .filter((s): s is string => !!s)
-}
-
-/** Parse the "- name (type): ..." schema block into {name, type} pairs. */
-function extractFieldTypes(prompt: string): Array<{ name: string; type: string }> {
-  const m = prompt.match(/Columns:\n([\s\S]*?)\n\n/)
-  if (!m) return []
-  return (m[1] ?? '')
-    .split('\n')
-    .map((l) => {
-      const mm = l.match(/^- (\w+)\s*\((\w+)\)/)
-      return mm ? { name: mm[1]!, type: mm[2]! } : null
-    })
-    .filter((x): x is { name: string; type: string } => !!x)
-}
-
-function buildMockFilter(prompt: string, q: string): AIFilterResult {
-  const fields = extractFields(prompt)
-  const filters: AIFilterClause[] = []
-  const sort: AISortClause[] = []
-  const rationale: string[] = []
-
-  // Greedy keyword routing. Real model would be smarter; this only needs
-  // to convince the demo viewer the pipeline works.
-  const numberWord = q.match(/(?:over|above|>|greater than)\s+\$?([\d.,]+)([kmb])?/)
-  const lessWord   = q.match(/(?:under|below|<|less than)\s+\$?([\d.,]+)([kmb])?/)
-  // Pick a NUMBER-typed field (never a boolean like `inStock`), money-named
-  // ones first so "$300" targets price/amount rather than a count/index.
-  const numberTyped = extractFieldTypes(prompt).filter((f) => f.type === 'number').map((f) => f.name)
-  const moneyRe = /(price|amount|cost|revenue|total|value|salary|arr|fee|spend|budget|sales)/i
-  const numberPool = numberTyped.length > 0 ? numberTyped : fields
-  const numberFields = [
-    ...numberPool.filter((f) => moneyRe.test(f)),
-    ...numberPool.filter((f) => !moneyRe.test(f)),
-  ]
-
-  if (numberWord && numberFields[0]) {
-    const raw = parseFloat(numberWord[1]!.replace(/,/g, ''))
-    const mul = numberWord[2] === 'k' ? 1_000 : numberWord[2] === 'm' ? 1_000_000 : numberWord[2] === 'b' ? 1_000_000_000 : 1
-    filters.push({ field: numberFields[0], operator: 'greaterThan', value: String(raw * mul) })
-    rationale.push(`amount > ${raw}${numberWord[2] ?? ''}`)
-  } else if (lessWord && numberFields[0]) {
-    const raw = parseFloat(lessWord[1]!.replace(/,/g, ''))
-    const mul = lessWord[2] === 'k' ? 1_000 : lessWord[2] === 'm' ? 1_000_000 : 1
-    filters.push({ field: numberFields[0], operator: 'lessThan', value: String(raw * mul) })
-    rationale.push(`amount < ${raw}${lessWord[2] ?? ''}`)
-  }
-
-  // Quoted phrases -> contains on a likely text field.
-  const quote = q.match(/"([^"]+)"|'([^']+)'/)
-  const textFields = fields.filter((f) => /(name|company|customer|title|owner|status|region|category|industry)/i.test(f))
-  if (quote) {
-    const term = quote[1] ?? quote[2] ?? ''
-    if (textFields[0]) {
-      filters.push({ field: textFields[0], operator: 'contains', value: term })
-      rationale.push(`text contains "${term}"`)
-    }
-  }
-
-  // Person-name routing -> match owner/contact fields.
-  const personOwners = ['sasha', 'jamie', 'casey', 'drew', 'robin', 'morgan', 'riley', 'quinn']
-  for (const n of personOwners) {
-    if (q.includes(n)) {
-      const ownerField = fields.find((f) => /owner|rep|assigned/i.test(f)) ?? fields.find((f) => /name/i.test(f))
-      if (ownerField) {
-        filters.push({ field: ownerField, operator: 'contains', value: n })
-        rationale.push(`owner ~ "${n}"`)
-        break
-      }
-    }
-  }
-
-  // Region routing.
-  for (const r of ['NA', 'EMEA', 'APAC', 'LATAM']) {
-    if (q.toUpperCase().includes(r)) {
-      const regionField = fields.find((f) => /region/i.test(f))
-      if (regionField) {
-        filters.push({ field: regionField, operator: 'equals', value: r })
-        rationale.push(`region = ${r}`)
-        break
-      }
-    }
-  }
-
-  // Status routing - any token in the query that matches a known status.
-  for (const s of ['active', 'pending', 'won', 'lost', 'live', 'paused', 'shipped', 'delivered']) {
-    if (q.includes(s)) {
-      const f = fields.find((f) => /status|stage/i.test(f))
-      if (f) {
-        filters.push({ field: f, operator: 'equals', value: s })
-        rationale.push(`status = ${s}`)
-        break
-      }
-    }
-  }
-
-  // Sort detection.
-  if (/(highest|largest|biggest|top|most)/.test(q)) {
-    const f = numberFields[0]
-    if (f) { sort.push({ field: f, desc: true }); rationale.push(`sort by ${f} desc`) }
-  } else if (/(lowest|smallest|least|cheapest)/.test(q)) {
-    const f = numberFields[0]
-    if (f) { sort.push({ field: f, desc: false }); rationale.push(`sort by ${f} asc`) }
-  } else if (/(newest|recent|latest)/.test(q)) {
-    const dateField = fields.find((f) => /date|at|time/i.test(f))
-    if (dateField) { sort.push({ field: dateField, desc: true }); rationale.push(`sort by ${dateField} desc`) }
-  } else if (/(oldest)/.test(q)) {
-    const dateField = fields.find((f) => /date|at|time/i.test(f))
-    if (dateField) { sort.push({ field: dateField, desc: false }); rationale.push(`sort by ${dateField} asc`) }
-  }
-
-  return {
-    filters,
-    sort,
-    rationale: rationale.length
-      ? `Interpreted: ${rationale.join(' AND ')}.`
-      : `Couldn't identify a clear filter for "${q}". Showing all rows.`,
-  }
-}
-
-function buildMockSmartFill(prompt: string): { predictions: Array<{ rowIndex: number; value: unknown; confidence: number }>; rationale: string } {
-  // Extract the target column and the rows-to-fill block; copy the first
-  // example's "output" pattern verbatim so the demo always returns
-  // something believable. Real models do much better - that's the point.
-  const fieldMatch = prompt.match(/Target column:\s*(\w+)/)
-  const rowsMatch = prompt.match(/Rows to fill:\n([\s\S]*?)\n\n/)
-  const exMatch = prompt.match(/Example 1: input=.* -> output=(.+)/)
-  const targetField = fieldMatch?.[1] ?? ''
-  const rowLines = (rowsMatch?.[1] ?? '').split('\n').filter(Boolean)
-  const exampleOutput = exMatch?.[1] ? safeParse(exMatch[1]) : ''
-  const predictions = rowLines
-    .map((line) => {
-      const m = line.match(/^Row (\d+): (\{.+\})/)
-      if (!m) return null
-      const rowIndex = parseInt(m[1]!, 10)
-      const row = safeParse(m[2]!) as Record<string, unknown> | null
-      if (!row) return null
-      const value = inferFromRow(targetField, row, exampleOutput)
-      return { rowIndex, value, confidence: 0.78 + Math.random() * 0.18 }
-    })
-    .filter((p): p is { rowIndex: number; value: unknown; confidence: number } => !!p)
-  return {
-    predictions,
-    rationale: `Inferred from ${exMatch ? 'the supplied' : 'no'} examples; mocked deterministically for the demo.`,
-  }
-}
-
-function safeParse(s: string): unknown {
-  try { return JSON.parse(s) } catch { return null }
-}
-
-function inferFromRow(field: string, row: Record<string, unknown>, exampleOutput: unknown): unknown {
-  // Mock heuristics that produce a value that "looks right" in common
-  // demo scenarios. The real provider would route through a real model.
-  if (field === 'priority') {
-    const arr = Number(row.arr ?? row.amount ?? row.price ?? 0)
-    return arr > 100_000 ? 'high' : arr > 30_000 ? 'medium' : 'low'
-  }
-  if (field === 'tier') {
-    const arr = Number(row.arr ?? row.amount ?? 0)
-    return arr > 500_000 ? 'enterprise' : arr > 100_000 ? 'growth' : 'starter'
-  }
-  if (field === 'tags' || field === 'category') {
-    return typeof exampleOutput === 'string' ? exampleOutput : 'auto-tag'
-  }
-  if (typeof exampleOutput === 'string') return exampleOutput
-  if (typeof exampleOutput === 'number') return exampleOutput
-  return exampleOutput ?? 'auto'
-}
-
-function buildMockSummary(prompt: string): AISummary {
-  const sliceMatch = prompt.match(/Slice size: (\d+) row/)
-  const n = sliceMatch ? parseInt(sliceMatch[1]!, 10) : 0
-  const fields = extractSummaryFields(prompt)
-  return {
-    text:
-      n === 1
-        ? `Single record. Notable signals come from ${fields.slice(0, 2).join(' and ') || 'the available fields'}.`
-        : `${n} rows in scope. The distribution skews toward live / active records, with a long tail in ${fields[0] ?? 'amount'}.`,
-    bullets: [
-      `${n} row${n === 1 ? '' : 's'} sampled`,
-      fields[0] ? `Largest variance in ${fields[0]}` : 'Tight clustering across visible fields',
-      fields[1] ? `${fields[1]} concentrates around the median` : 'Few outliers',
-      'Mock summary - wire setAIProvider() to a real model for actual analysis',
-    ],
-    highlightedFields: fields.slice(0, 3),
-  }
-}
-
-function extractSummaryFields(prompt: string): string[] {
-  const m = prompt.match(/Columns:\n([\s\S]*?)\n\n/)
-  if (!m) return []
-  return (m[1] ?? '')
-    .split('\n')
-    .map((l) => l.match(/^- (\w+)/)?.[1])
-    .filter((s): s is string => !!s)
-}
-
-function buildMockClassify(prompt: string): { predictions: Array<{ rowIndex: number; value: string; confidence: number }> } {
-  const labelsMatch = prompt.match(/Allowed labels[\s\S]*?:\n([\s\S]*?)\n\n/)
-  // Capture the label up to the first colon, whitespace or end-of-line so
-  // we don't pick up the rubric ("- at-risk: churn signals..." -> "at-risk").
-  const labels = (labelsMatch?.[1] ?? '')
-    .split('\n')
-    .map((l) => l.match(/^-\s*([^\s:]+)/)?.[1])
-    .filter((s): s is string => !!s)
-  const rowLines = (prompt.match(/Rows to classify[\s\S]*?:\n([\s\S]*?)\n\n/)?.[1] ?? '').split('\n').filter(Boolean)
-  const predictions = rowLines.map((line) => {
-    const m = line.match(/^Row (\d+): "(.*)"/)
-    if (!m || labels.length === 0) return null
-    const rowIndex = parseInt(m[1]!, 10)
-    const text = (m[2] ?? '').toLowerCase()
-    // Pick the label whose token appears in the text; otherwise hash.
-    const hit = labels.find((l) => text.includes(l.toLowerCase()))
-    const value = hit ?? labels[Math.abs(hashStr(text)) % labels.length]!
-    return { rowIndex, value, confidence: hit ? 0.92 : 0.6 + Math.random() * 0.2 }
-  }).filter((p): p is { rowIndex: number; value: string; confidence: number } => !!p)
-  return { predictions }
-}
-
-function hashStr(s: string): number {
-  let h = 0
-  for (let i = 0; i < s.length; i += 1) h = (h * 31 + s.charCodeAt(i)) | 0
-  return h
-}
+/**
+ * Pro AI feature pack
+ * -------------------
+ *
+ * Three jobs every analyst wishes a data grid could do:
+ *
+ *   1. Natural-language filter / sort  (`aiFilter`)
+ *      "show me deals closing this quarter over $50k owned by Sasha"
+ *      ->  { filters: [...], sort: [...] }
+ *
+ *   2. Smart fill  (`aiSmartFill`)
+ *      User edits two cells in a column with example values; the
+ *      Grid proposes the rest. Excel "Flash Fill" pattern.
+ *
+ *   3. Summarise rows  (`aiSummarize`)
+ *      Single row, the current selection, a group key, or the whole
+ *      filtered view -> a one-paragraph summary.
+ *
+ * The grid stays headless / model-agnostic. The consumer supplies an
+ * `AIProvider` that knows how to call OpenAI / Anthropic / a local
+ * model / a server-side proxy. We never bundle a model client.
+ *
+ * Built-in + free: the AI helpers live in `@svgrid/grid`. They ship no model
+ * client and do nothing until you register a provider with `setAIProvider(...)`,
+ * so they add nothing to the base bundle unless you actually use them.
+ */
+
+import type { RowData, SvGridApi, TableFeatures } from './index'
+import { getExportProvider } from './export-provider'
+
+// Export formats an AI export can plan. WRITING the enterprise formats (xlsx /
+// pdf / html / xml / md) needs the export engine from `@svgrid/enterprise`
+// (registered via the export-provider seam); csv / tsv / json are also handled
+// by that engine when present. The union is declared locally so the free grid
+// carries no dependency on the enterprise export module.
+type ExportFormat = 'xlsx' | 'xls' | 'pdf' | 'csv' | 'tsv' | 'html' | 'json' | 'xml' | 'md'
+
+// ---------------------------------------------------------------------------
+// Provider contract
+// ---------------------------------------------------------------------------
+
+/**
+ * Shape every consumer-provided model adapter must implement. Keeping this
+ * tiny (one async call, two response formats) lets the same adapter drive
+ * OpenAI's `chat.completions`, Anthropic's `messages`, a self-hosted
+ * llama.cpp endpoint, or a server-side proxy. The grid only cares that the
+ * provider eventually returns a string we can parse.
+ */
+export type AIProvider = (request: AIRequest) => Promise<string>
+
+export type AIRequest = {
+  /** Full prompt the grid built for the model. Already includes column
+   *  schema and any sampled rows where applicable. */
+  prompt: string
+  /** When 'json', the provider should ask the model to return strict
+   *  JSON only - no prose. We parse the response with JSON.parse and
+   *  throw a typed error on failure. */
+  responseFormat?: 'text' | 'json'
+  /** Honored if the underlying transport supports cancellation. */
+  signal?: AbortSignal
+  /** Free-form tag for telemetry / logging. One of: 'filter',
+   *  'smart-fill', 'summarize', 'classify'. */
+  task: AITask
+  /** Soft hint to the provider about how many tokens we expect back.
+   *  Useful for routing small jobs to a cheaper model. */
+  maxOutputTokens?: number
+}
+
+export type AITask = 'filter' | 'smart-fill' | 'summarize' | 'classify' | 'export' | 'anomaly' | 'chart'
+
+let provider: AIProvider | null = null
+
+/**
+ * Register the model adapter every AI call will route through. Call once
+ * at app boot. Passing `null` clears the provider and AI calls revert to
+ * throwing "no provider" errors.
+ */
+export function setAIProvider(p: AIProvider | null): void {
+  provider = p
+}
+
+export function getAIProvider(): AIProvider | null {
+  return provider
+}
+
+export function hasAIProvider(): boolean {
+  return provider != null
+}
+
+class NoProviderError extends Error {
+  constructor() {
+    super(
+      '@svgrid/grid ai: no AI provider registered. Call setAIProvider(fn) ' +
+        'with an adapter that talks to OpenAI / Anthropic / your proxy.',
+    )
+    this.name = 'NoProviderError'
+  }
+}
+
+class BadJsonError extends Error {
+  constructor(raw: string) {
+    super(
+      '@svgrid/grid ai: provider returned non-JSON for a json-format request. ' +
+        `First 200 chars: ${raw.slice(0, 200)}`,
+    )
+    this.name = 'BadJsonError'
+  }
+}
+
+async function callProvider(req: AIRequest): Promise<string> {
+  if (!provider) throw new NoProviderError()
+  return provider(req)
+}
+
+async function callJSON<T>(req: AIRequest): Promise<T> {
+  const raw = await callProvider({ ...req, responseFormat: 'json' })
+  // Models occasionally wrap JSON in markdown code fences even when asked
+  // for raw JSON. Strip a single fenced block if present, then parse.
+  const stripped = raw.trim().replace(/^```(?:json)?\s*|\s*```$/g, '')
+  try {
+    return JSON.parse(stripped) as T
+  } catch {
+    throw new BadJsonError(raw)
+  }
+}
+
+// ---------------------------------------------------------------------------
+// Helpers - build column schema + row sample from the grid API
+// ---------------------------------------------------------------------------
+
+type ColumnSchemaEntry = {
+  field: string
+  type: 'string' | 'number' | 'boolean' | 'date' | 'unknown'
+  sampleValues: unknown[]
+}
+
+/**
+ * Inspect the first N rows the grid is holding to infer a typed schema +
+ * a handful of sample values per column. This is the context every AI
+ * task needs and the most expensive thing to build, so the helpers cache
+ * the result inside one task call rather than calling api.getData()
+ * repeatedly.
+ */
+function buildColumnSchema<
+  TFeatures extends TableFeatures,
+  TData extends RowData,
+>(api: SvGridApi<TFeatures, TData>, sampleSize = 50): ColumnSchemaEntry[] {
+  const data = api.getData()
+  if (data.length === 0) return []
+  const slice = data.slice(0, Math.min(data.length, sampleSize))
+  const fields = new Set<string>()
+  for (const row of slice) {
+    for (const k of Object.keys(row as object)) fields.add(k)
+  }
+  const out: ColumnSchemaEntry[] = []
+  for (const field of fields) {
+    const values: unknown[] = []
+    for (const row of slice) {
+      const v = (row as Record<string, unknown>)[field]
+      if (v != null) values.push(v)
+      if (values.length >= 5) break
+    }
+    out.push({
+      field,
+      type: inferType(values),
+      sampleValues: values,
+    })
+  }
+  return out
+}
+
+function inferType(samples: unknown[]): ColumnSchemaEntry['type'] {
+  if (samples.length === 0) return 'unknown'
+  const v = samples[0]
+  if (typeof v === 'number') return 'number'
+  if (typeof v === 'boolean') return 'boolean'
+  if (typeof v === 'string') {
+    // Cheap ISO-date sniff so we route date-style filters correctly.
+    if (/^\d{4}-\d{2}-\d{2}/.test(v)) return 'date'
+    return 'string'
+  }
+  return 'unknown'
+}
+
+function schemaToPromptBlock(schema: ColumnSchemaEntry[]): string {
+  return schema
+    .map(
+      (c) =>
+        `- ${c.field} (${c.type}): e.g. ${c.sampleValues
+          .slice(0, 3)
+          .map((v) => JSON.stringify(v))
+          .join(', ')}`,
+    )
+    .join('\n')
+}
+
+// ---------------------------------------------------------------------------
+// 1. Natural-language filter / sort
+// ---------------------------------------------------------------------------
+
+export type AIFilterClause = {
+  field: string
+  operator: 'contains' | 'equals' | 'startsWith' | 'greaterThan' | 'lessThan' | 'isBlank'
+  value?: string
+}
+export type AISortClause = { field: string; desc: boolean }
+
+export type AIFilterResult = {
+  filters: AIFilterClause[]
+  sort: AISortClause[]
+  /** Plain-English explanation of how the model interpreted the query.
+   *  Surface this in the UI so the user can confirm or undo. */
+  rationale: string
+}
+
+export type AIFilterOptions = {
+  /**
+   * When true, the helper not only RETURNS the plan but also applies it
+   * to the grid via `api.setFilter` / `api.setSort`. Defaults to false
+   * so callers can show a preview before committing.
+   */
+  apply?: boolean
+  signal?: AbortSignal
+}
+
+/**
+ * Translate a natural-language query into a filter+sort plan against
+ * the current grid's columns. The grid passes the column schema (names,
+ * types, sample values) to the model so it can pick the right field
+ * names without hallucinating.
+ */
+export async function aiFilter<
+  TFeatures extends TableFeatures,
+  TData extends RowData,
+>(
+  api: SvGridApi<TFeatures, TData>,
+  query: string,
+  opts: AIFilterOptions = {},
+): Promise<AIFilterResult> {
+  const schema = buildColumnSchema(api)
+  const prompt =
+    `You are a data-grid filter planner. Translate the user's natural-language ` +
+    `query into a strict-JSON plan that the grid can apply.\n\n` +
+    `Columns:\n${schemaToPromptBlock(schema)}\n\n` +
+    `Output JSON schema:\n` +
+    `{ "filters": [{"field": "<one of the columns above>", ` +
+    `"operator": "contains"|"equals"|"startsWith"|"greaterThan"|"lessThan"|"isBlank", ` +
+    `"value": "<string>"}], ` +
+    `"sort": [{"field": "<column>", "desc": true|false}], ` +
+    `"rationale": "<one-sentence explanation>" }\n\n` +
+    `User query: ${query}\n\n` +
+    `Return JSON only, no prose.`
+
+  const result = await callJSON<AIFilterResult>({
+    prompt,
+    task: 'filter',
+    signal: opts.signal,
+    maxOutputTokens: 400,
+  })
+
+  // Defensive: drop anything that doesn't match a real column. Models love
+  // to invent plausible-sounding field names; we'd rather skip a clause
+  // than throw at runtime.
+  const valid = new Set(schema.map((c) => c.field))
+  result.filters = (result.filters ?? []).filter((f) => valid.has(f.field))
+  result.sort = (result.sort ?? []).filter((s) => valid.has(s.field))
+
+  if (opts.apply) {
+    api.clearAllFilters()
+    api.clearSort()
+    for (const f of result.filters) {
+      api.setFilter(f.field, { operator: f.operator, value: f.value ?? '' })
+    }
+    // Multiple sort clauses get applied last-wins because the public
+    // `setSort` is single-key. Multi-sort is on the roadmap.
+    const last = result.sort[result.sort.length - 1]
+    if (last) api.setSort(last.field, last.desc ? 'desc' : 'asc')
+  }
+
+  return result
+}
+
+// ---------------------------------------------------------------------------
+// 2. Smart fill
+// ---------------------------------------------------------------------------
+
+export type AISmartFillExample = { input: Record<string, unknown>; output: unknown }
+
+export type AISmartFillResult<TValue = unknown> = {
+  field: string
+  predictions: Array<{ rowIndex: number; value: TValue; confidence: number }>
+  rationale: string
+}
+
+export type AISmartFillOptions = {
+  /** Target column - the one whose values we want filled. */
+  field: string
+  /** Index of rows the model should propose values for. If omitted, every
+   *  row whose current `field` value is `null`, `undefined` or `''` is
+   *  selected automatically. */
+  targetRowIndices?: number[]
+  /**
+   * Worked examples the user has already filled in. Required - the
+   * model needs at least one to know the pattern, two or more to lock
+   * the schema. We don't pull these from the grid automatically because
+   * "edited" vs "untouched" isn't a state SvGrid exposes today.
+   */
+  examples: AISmartFillExample[]
+  signal?: AbortSignal
+}
+
+/**
+ * Given a column and a few user-provided examples, propose values for the
+ * untouched rows. Returns predictions only - the caller chooses whether to
+ * commit them via `api.setCellValue`. This is the right shape for an
+ * accept-per-cell UX with confidence-coloured highlights.
+ */
+export async function aiSmartFill<
+  TFeatures extends TableFeatures,
+  TData extends RowData,
+  TValue = unknown,
+>(
+  api: SvGridApi<TFeatures, TData>,
+  opts: AISmartFillOptions,
+): Promise<AISmartFillResult<TValue>> {
+  if (opts.examples.length === 0) {
+    throw new Error('@svgrid/grid ai: aiSmartFill requires at least one example.')
+  }
+  const data = api.getData()
+  const targets =
+    opts.targetRowIndices ??
+    data
+      .map((row, i) => {
+        const v = (row as Record<string, unknown>)[opts.field]
+        return v == null || v === '' ? i : -1
+      })
+      .filter((i) => i >= 0)
+
+  if (targets.length === 0) {
+    return { field: opts.field, predictions: [], rationale: 'No empty cells to fill.' }
+  }
+
+  const examplesBlock = opts.examples
+    .map((ex, i) => `Example ${i + 1}: input=${JSON.stringify(ex.input)} -> output=${JSON.stringify(ex.output)}`)
+    .join('\n')
+
+  const targetRowsBlock = targets
+    .map((i) => `Row ${i}: ${JSON.stringify(data[i])}`)
+    .join('\n')
+
+  const prompt =
+    `You are filling in a single column of a data grid based on user-provided ` +
+    `examples. Match the pattern in the examples exactly.\n\n` +
+    `Target column: ${opts.field}\n\n` +
+    `Examples:\n${examplesBlock}\n\n` +
+    `Rows to fill:\n${targetRowsBlock}\n\n` +
+    `Return strict JSON only:\n` +
+    `{ "predictions": [{"rowIndex": <number>, "value": <inferred value>, ` +
+    `"confidence": <0..1>}], "rationale": "<one-sentence pattern description>" }`
+
+  const result = await callJSON<{
+    predictions: Array<{ rowIndex: number; value: TValue; confidence: number }>
+    rationale: string
+  }>({
+    prompt,
+    task: 'smart-fill',
+    signal: opts.signal,
+    maxOutputTokens: 600,
+  })
+
+  return {
+    field: opts.field,
+    predictions: result.predictions ?? [],
+    rationale: result.rationale ?? '',
+  }
+}
+
+// ---------------------------------------------------------------------------
+// 3. Summarise
+// ---------------------------------------------------------------------------
+
+export type AISummarizeTarget =
+  | { kind: 'row'; rowIndex: number }
+  | { kind: 'all' }
+  | { kind: 'selection'; rowIndices: number[] }
+  | { kind: 'group'; field: string; value: unknown }
+
+export type AISummary = {
+  text: string
+  bullets: string[]
+  /** Field names the model thinks are the most load-bearing for the
+   *  story it just told. UI can highlight those columns. */
+  highlightedFields: string[]
+}
+
+export type AISummarizeOptions = {
+  target: AISummarizeTarget
+  /** Optional question the user is trying to answer. Helps the model
+   *  bias the summary toward the relevant columns. */
+  question?: string
+  signal?: AbortSignal
+}
+
+/**
+ * Ask the model to summarise a slice of the grid. Caps the row sample at
+ * a model-friendly size; for huge selections it samples uniformly so the
+ * summary stays representative without blowing the context window.
+ */
+export async function aiSummarize<
+  TFeatures extends TableFeatures,
+  TData extends RowData,
+>(
+  api: SvGridApi<TFeatures, TData>,
+  opts: AISummarizeOptions,
+): Promise<AISummary> {
+  const all = api.getData()
+  const rows: TData[] = (() => {
+    const t = opts.target
+    if (t.kind === 'row') {
+      const r = all[t.rowIndex]
+      return r ? [r] : []
+    }
+    if (t.kind === 'selection') {
+      return t.rowIndices.map((i) => all[i]).filter((r): r is TData => r != null)
+    }
+    if (t.kind === 'group') {
+      return all.filter((r) => (r as Record<string, unknown>)[t.field] === t.value)
+    }
+    return all.slice()
+  })()
+
+  if (rows.length === 0) {
+    return { text: 'No rows in scope.', bullets: [], highlightedFields: [] }
+  }
+
+  // Uniform sample to stay inside a sensible context budget.
+  const MAX_SAMPLE = 25
+  const sample = rows.length <= MAX_SAMPLE
+    ? rows
+    : Array.from({ length: MAX_SAMPLE }, (_, i) => rows[Math.floor((i / MAX_SAMPLE) * rows.length)]!)
+
+  const schema = buildColumnSchema(api, 30)
+  const prompt =
+    `You are summarising a slice of a business data grid for a busy analyst.\n\n` +
+    `Columns:\n${schemaToPromptBlock(schema)}\n\n` +
+    `Slice size: ${rows.length} row(s). Sampled rows shown below.\n` +
+    `${sample.map((r) => JSON.stringify(r)).join('\n')}\n\n` +
+    (opts.question ? `User's question: ${opts.question}\n\n` : '') +
+    `Return strict JSON only:\n` +
+    `{ "text": "<one short paragraph>", ` +
+    `"bullets": ["<3-5 punchy bullets>"], ` +
+    `"highlightedFields": ["<column names the summary leans on>"] }`
+
+  const result = await callJSON<AISummary>({
+    prompt,
+    task: 'summarize',
+    signal: opts.signal,
+    maxOutputTokens: 600,
+  })
+  return {
+    text: result.text ?? '',
+    bullets: result.bullets ?? [],
+    highlightedFields: result.highlightedFields ?? [],
+  }
+}
+
+// ---------------------------------------------------------------------------
+// 4. Classify (free-text -> bucketed value)
+// ---------------------------------------------------------------------------
+
+export type AIClassifyOptions = {
+  /** Column whose free-text we're classifying. */
+  inputField: string
+  /** Target column the model should write to. */
+  outputField: string
+  /** Allowed values. The model is constrained to pick one. */
+  classes: string[]
+  /** Optional one-line description of each class (acts as a labeling rubric). */
+  classDescriptions?: Record<string, string>
+  /** Rows to classify. Defaults to all. */
+  targetRowIndices?: number[]
+  signal?: AbortSignal
+}
+
+export type AIClassifyResult = {
+  inputField: string
+  outputField: string
+  predictions: Array<{ rowIndex: number; value: string; confidence: number }>
+}
+
+/**
+ * Bucket free-text cells into one of a known set of classes. The model
+ * is constrained to pick from `opts.classes`; predictions outside the set
+ * are dropped so the caller can rely on the output being clean enum
+ * values it can write straight back into the grid.
+ */
+export async function aiClassify<
+  TFeatures extends TableFeatures,
+  TData extends RowData,
+>(
+  api: SvGridApi<TFeatures, TData>,
+  opts: AIClassifyOptions,
+): Promise<AIClassifyResult> {
+  const data = api.getData()
+  const targets = opts.targetRowIndices ?? data.map((_, i) => i)
+  const rubric = opts.classDescriptions
+    ? Object.entries(opts.classDescriptions)
+        .map(([k, v]) => `- ${k}: ${v}`)
+        .join('\n')
+    : opts.classes.map((c) => `- ${c}`).join('\n')
+
+  const rowsBlock = targets
+    .map((i) => `Row ${i}: ${JSON.stringify((data[i] as Record<string, unknown>)?.[opts.inputField] ?? '')}`)
+    .join('\n')
+
+  const prompt =
+    `You are a strict text classifier. For each row, pick exactly one ` +
+    `label from the list. If unsure, pick the closest match and lower the ` +
+    `confidence.\n\n` +
+    `Allowed labels (with optional rubric):\n${rubric}\n\n` +
+    `Rows to classify (text from column "${opts.inputField}"):\n${rowsBlock}\n\n` +
+    `Return strict JSON only:\n` +
+    `{ "predictions": [{"rowIndex": <number>, "value": "<label>", "confidence": <0..1>}] }`
+
+  const result = await callJSON<{
+    predictions: Array<{ rowIndex: number; value: string; confidence: number }>
+  }>({
+    prompt,
+    task: 'classify',
+    signal: opts.signal,
+    maxOutputTokens: Math.min(2000, 30 + targets.length * 30),
+  })
+
+  const allowed = new Set(opts.classes)
+  return {
+    inputField: opts.inputField,
+    outputField: opts.outputField,
+    predictions: (result.predictions ?? []).filter((p) => allowed.has(p.value)),
+  }
+}
+
+// ---------------------------------------------------------------------------
+// 5. Natural-language export
+// ---------------------------------------------------------------------------
+
+const EXPORT_FORMATS: ExportFormat[] = ['xlsx', 'xls', 'pdf', 'csv', 'tsv', 'html', 'json', 'xml', 'md']
+
+export type AIExportPlan = {
+  format: ExportFormat
+  filters: AIFilterClause[]
+  sort: AISortClause[]
+  groupBy: string[]
+  /** Plain-English explanation of how the model read the request. */
+  rationale: string
+}
+
+export type AIExportOptions = {
+  /**
+   * Also apply the filter / sort / grouping to the grid (mutating the view) so
+   * it mirrors the export. Default FALSE - the export is self-contained (it
+   * computes its own rows), so the grid is left untouched unless you opt in.
+   */
+  apply?: boolean
+  /** Actually download the file. Default true; set false to preview the plan. */
+  run?: boolean
+  /** Base filename (no extension). Default 'export'. */
+  filename?: string
+  signal?: AbortSignal
+}
+
+/**
+ * Turn a natural-language request ("export EU orders from Q2 as a grouped PDF")
+ * into an export: the model returns a `{ format, filters, sort, groupBy }` plan
+ * against the grid's columns; we apply the filter/sort to the grid and hand the
+ * result to the registered export engine (@svgrid/enterprise). Returns the plan
+ * so the UI can show what it did (or preview it first with `run: false`).
+ */
+export async function aiExport<
+  TFeatures extends TableFeatures,
+  TData extends RowData,
+>(
+  api: SvGridApi<TFeatures, TData>,
+  query: string,
+  opts: AIExportOptions = {},
+): Promise<AIExportPlan> {
+  const schema = buildColumnSchema(api)
+  const prompt =
+    `You are an export assistant for a data grid. Translate the user's request ` +
+    `into a strict-JSON export plan.\n\n` +
+    `Columns:\n${schemaToPromptBlock(schema)}\n\n` +
+    `Output JSON schema:\n` +
+    `{ "format": "xlsx"|"xls"|"pdf"|"csv"|"tsv"|"html"|"json"|"xml"|"md", ` +
+    `"filters": [{"field":"<column>","operator":"contains"|"equals"|"startsWith"|"greaterThan"|"lessThan"|"isBlank","value":"<string>"}], ` +
+    `"sort": [{"field":"<column>","desc":true|false}], ` +
+    `"groupBy": ["<column>"], ` +
+    `"rationale": "<one sentence>" }\n\n` +
+    `Rules: use the format the user names (default "xlsx"); only use column ` +
+    `names from the list above; "grouped" / "group by X" -> groupBy. ` +
+    `Return JSON only, no prose.\n\n` +
+    `User request: ${query}`
+
+  const plan = await callJSON<AIExportPlan>({
+    prompt,
+    task: 'export',
+    signal: opts.signal,
+    maxOutputTokens: 500,
+  })
+
+  // Defensive validation - drop invented fields, clamp the format.
+  const valid = new Set(schema.map((c) => c.field))
+  plan.format = EXPORT_FORMATS.includes(plan.format) ? plan.format : 'xlsx'
+  plan.filters = (plan.filters ?? []).filter((f) => valid.has(f.field))
+  plan.sort = (plan.sort ?? []).filter((s) => valid.has(s.field))
+  plan.groupBy = (plan.groupBy ?? []).filter((g) => valid.has(g))
+  plan.rationale = plan.rationale ?? ''
+
+  // Optionally mirror the plan onto the grid (opt-in). Off by default so the
+  // export never disturbs the user's current view.
+  if (opts.apply === true) {
+    api.clearAllFilters()
+    api.clearSort()
+    for (const f of plan.filters) {
+      api.setFilter(f.field, { operator: f.operator, value: f.value ?? '' })
+    }
+    const last = plan.sort[plan.sort.length - 1]
+    if (last) api.setSort(last.field, last.desc ? 'desc' : 'asc')
+    if (plan.groupBy.length > 0) {
+      try {
+        api.setGroupBy(plan.groupBy)
+      } catch {
+        // grouping feature not enabled - the export still groups on its own
+      }
+    }
+  }
+
+  // Planning is always free; WRITING the file uses the export engine registered
+  // by @svgrid/enterprise (export-provider seam). Without it, we return the plan
+  // so the UI can still show what the AI decided - the download just no-ops.
+  const runExport = getExportProvider()
+  if (opts.run !== false && runExport) {
+    // Compute the export rows from the plan directly (filter + sort + make
+    // contiguous by group) rather than reading the grid's reactive displayed
+    // rows - so the download always has exactly the intended data.
+    const exportRows = applyPlanToRows(api.getData(), plan)
+    await runExport(api, {
+      format: plan.format,
+      filename: opts.filename ?? 'export',
+      rows: exportRows,
+      ...(plan.groupBy.length > 0 ? { groupBy: plan.groupBy } : {}),
+    })
+  }
+  return plan
+}
+
+/** Evaluate one AI filter clause against a raw row value. */
+function matchesClause(row: Record<string, unknown>, clause: AIFilterClause): boolean {
+  const v = row[clause.field]
+  const val = clause.value ?? ''
+  switch (clause.operator) {
+    case 'contains':
+      return String(v ?? '').toLowerCase().includes(val.toLowerCase())
+    case 'equals':
+      return String(v ?? '').toLowerCase() === val.toLowerCase()
+    case 'startsWith':
+      return String(v ?? '').toLowerCase().startsWith(val.toLowerCase())
+    case 'greaterThan':
+      return Number(v) > Number(val)
+    case 'lessThan':
+      return Number(v) < Number(val)
+    case 'isBlank':
+      return v == null || v === ''
+    default:
+      return true
+  }
+}
+
+/** Filter + sort + (stable) group the raw rows per an export plan. */
+function applyPlanToRows<TData extends RowData>(
+  data: ReadonlyArray<TData>,
+  plan: AIExportPlan,
+): TData[] {
+  let rows: TData[] = data.slice()
+  if (plan.filters.length > 0) {
+    rows = rows.filter((r) =>
+      plan.filters.every((f) => matchesClause(r as Record<string, unknown>, f)),
+    )
+  }
+  const last = plan.sort[plan.sort.length - 1]
+  if (last) {
+    rows = [...rows].sort((a, b) => {
+      const av = (a as Record<string, unknown>)[last.field]
+      const bv = (b as Record<string, unknown>)[last.field]
+      const na = Number(av)
+      const nb = Number(bv)
+      let cmp: number
+      if (Number.isFinite(na) && Number.isFinite(nb)) cmp = na - nb
+      else cmp = String(av ?? '').localeCompare(String(bv ?? ''))
+      return last.desc ? -cmp : cmp
+    })
+  }
+  // Contiguous grouping (first-seen order) so PDF group rows + Excel outline
+  // line up.
+  if (plan.groupBy.length > 0) {
+    const buckets = new Map<string, TData[]>()
+    for (const r of rows) {
+      const key = plan.groupBy
+        .map((k) => String((r as Record<string, unknown>)[k] ?? ''))
+        .join('
')
+      const bucket = buckets.get(key)
+      if (bucket) bucket.push(r)
+      else buckets.set(key, [r])
+    }
+    rows = [...buckets.values()].flat()
+  }
+  return rows
+}
+
+// ---------------------------------------------------------------------------
+// 6. Find anomalies
+// ---------------------------------------------------------------------------
+
+export type AIAnomaly = {
+  /** Index into the SCANNED rows (target order), when the model pins one row. */
+  rowIndex?: number
+  field?: string
+  value?: unknown
+  reason: string
+  severity: 'low' | 'medium' | 'high'
+}
+
+export type AIAnomalyResult = {
+  anomalies: AIAnomaly[]
+  summary: string
+}
+
+export type AIAnomalyOptions = {
+  /** Which rows to scan. Defaults to the whole dataset. */
+  target?: AISummarizeTarget
+  /** Optional focus, e.g. "look at pricing and margins". */
+  question?: string
+  signal?: AbortSignal
+}
+
+function sliceForTarget<TFeatures extends TableFeatures, TData extends RowData>(
+  api: SvGridApi<TFeatures, TData>,
+  target: AISummarizeTarget,
+): TData[] {
+  const all = api.getData()
+  if (target.kind === 'row') {
+    const r = all[target.rowIndex]
+    return r ? [r] : []
+  }
+  if (target.kind === 'selection') {
+    return target.rowIndices.map((i) => all[i]).filter((r): r is TData => r != null)
+  }
+  if (target.kind === 'group') {
+    return all.filter((r) => (r as Record<string, unknown>)[target.field] === target.value)
+  }
+  return all.slice()
+}
+
+/**
+ * Scan a slice of the grid (all / selection / group) for anomalies - outliers,
+ * suspicious values, inconsistencies - and return a structured list plus a
+ * one-line summary. Pairs naturally with an export: "find the odd ones, then
+ * export just those".
+ */
+export async function aiFindAnomalies<
+  TFeatures extends TableFeatures,
+  TData extends RowData,
+>(
+  api: SvGridApi<TFeatures, TData>,
+  opts: AIAnomalyOptions = {},
+): Promise<AIAnomalyResult> {
+  const rows = sliceForTarget(api, opts.target ?? { kind: 'all' })
+  if (rows.length === 0) return { anomalies: [], summary: 'No rows in scope.' }
+
+  const MAX_SAMPLE = 40
+  const sample =
+    rows.length <= MAX_SAMPLE
+      ? rows
+      : Array.from(
+          { length: MAX_SAMPLE },
+          (_, i) => rows[Math.floor((i / MAX_SAMPLE) * rows.length)]!,
+        )
+
+  const schema = buildColumnSchema(api, 30)
+  const prompt =
+    `You are a data-quality analyst. Scan the rows below for anomalies: ` +
+    `numeric outliers, impossible / inconsistent values, unexpected blanks, ` +
+    `and values that break the pattern of the column.\n\n` +
+    `Columns:\n${schemaToPromptBlock(schema)}\n\n` +
+    `Rows (index is 0-based into this list):\n` +
+    `${sample.map((r, i) => `${i}: ${JSON.stringify(r)}`).join('\n')}\n\n` +
+    (opts.question ? `Focus: ${opts.question}\n\n` : '') +
+    `Return strict JSON only:\n` +
+    `{ "anomalies": [{"rowIndex": <number|null>, "field": "<column|null>", ` +
+    `"reason": "<why it's odd>", "severity": "low"|"medium"|"high"}], ` +
+    `"summary": "<one sentence>" }`
+
+  const result = await callJSON<AIAnomalyResult>({
+    prompt,
+    task: 'anomaly',
+    signal: opts.signal,
+    maxOutputTokens: 800,
+  })
+  return {
+    anomalies: result.anomalies ?? [],
+    summary: result.summary ?? '',
+  }
+}
+
+// ---------------------------------------------------------------------------
+// 7. Natural-language chart ("chart this")
+// ---------------------------------------------------------------------------
+
+export type AIChartType = 'bar' | 'line' | 'area' | 'pie'
+
+export type AIChartPlan = {
+  type: AIChartType
+  /** Group-by (category-axis) column field, or null. */
+  dimension: string | null
+  /** Split-by column field: one series per distinct value, or null. */
+  series: string | null
+  /** Measure (value-axis) column field, or null. */
+  measure: string | null
+  reduce: 'sum' | 'avg' | 'count'
+  stacked: boolean
+  logScale: boolean
+  timeAxis: boolean
+  valueFormat: 'number' | 'currency' | 'percent'
+  rationale: string
+}
+
+export type AIChartOptions = {
+  /** Apply the plan to the grid's chart panel (open + configure). Default false. */
+  apply?: boolean
+  signal?: AbortSignal
+}
+
+/**
+ * Translate a natural-language request into a chart plan for the grid's built-in
+ * `charting` panel. Validates every field against the real schema, then (with
+ * `apply: true`) pushes it into the panel through `api.configureChart`.
+ */
+export async function aiChart<
+  TFeatures extends TableFeatures,
+  TData extends RowData,
+>(
+  api: SvGridApi<TFeatures, TData>,
+  query: string,
+  opts: AIChartOptions = {},
+): Promise<AIChartPlan> {
+  const schema = buildColumnSchema(api)
+  const prompt =
+    `You are a charting assistant for a data grid. Translate the user's request ` +
+    `into a strict-JSON chart plan the grid can render.\n\n` +
+    `Columns:\n${schemaToPromptBlock(schema)}\n\n` +
+    `Output JSON schema:\n` +
+    `{ "type": "bar"|"line"|"area"|"pie", ` +
+    `"dimension": "<a categorical column to group by>", ` +
+    `"series": "<a second categorical column to split into series, or null>", ` +
+    `"measure": "<a numeric column to aggregate>", ` +
+    `"reduce": "sum"|"avg"|"count", ` +
+    `"stacked": true|false, ` +
+    `"logScale": true|false, ` +
+    `"timeAxis": true|false, ` +
+    `"valueFormat": "number"|"currency"|"percent", ` +
+    `"rationale": "<one-sentence explanation>" }\n\n` +
+    `Rules: pick "dimension" and "series" from text/date columns and "measure" ` +
+    `from a numeric column; use only column names from the list above; ` +
+    `"stacked"/"stack" -> stacked:true; "log"/"logarithmic" -> logScale:true; ` +
+    `"over time"/"by date"/a date dimension -> timeAxis:true; ` +
+    `money/revenue/price/$ -> valueFormat:"currency"; rate/%/share -> valueFormat:"percent"; ` +
+    `else valueFormat:"number". default reduce is "sum". ` +
+    `Return JSON only, no prose.\n\n` +
+    `User request: ${query}`
+
+  const plan = await callJSON<AIChartPlan>({
+    prompt,
+    task: 'chart',
+    signal: opts.signal,
+    maxOutputTokens: 300,
+  })
+
+  const valid = new Set(schema.map((c) => c.field))
+  const numericFields = new Set(schema.filter((c) => c.type === 'number').map((c) => c.field))
+  const CHART_TYPES: AIChartType[] = ['bar', 'line', 'area', 'pie']
+  plan.type = CHART_TYPES.includes(plan.type) ? plan.type : 'bar'
+  plan.dimension = plan.dimension && valid.has(plan.dimension) ? plan.dimension : null
+  plan.series = plan.series && valid.has(plan.series) && plan.series !== plan.dimension ? plan.series : null
+  plan.measure =
+    plan.measure && numericFields.has(plan.measure)
+      ? plan.measure
+      : (schema.find((c) => c.type === 'number')?.field ?? null)
+  plan.reduce = ['sum', 'avg', 'count'].includes(plan.reduce) ? plan.reduce : 'sum'
+  plan.stacked = plan.stacked === true
+  plan.logScale = plan.logScale === true
+  plan.timeAxis = plan.timeAxis === true
+  plan.valueFormat = ['number', 'currency', 'percent'].includes(plan.valueFormat) ? plan.valueFormat : 'number'
+  plan.rationale = plan.rationale ?? ''
+
+  if (opts.apply === true) {
+    const cfg = api as unknown as { configureChart?: (c: Record<string, unknown>) => void }
+    cfg.configureChart?.({
+      open: true,
+      type: plan.type,
+      dimension: plan.dimension,
+      series: plan.series,
+      measure: plan.measure,
+      reduce: plan.reduce,
+      stacked: plan.stacked,
+      logScale: plan.logScale,
+      timeAxis: plan.timeAxis,
+      valueFormat: plan.valueFormat,
+    })
+  }
+
+  return plan
+}
+
+/**
+ * Wire the grid's chart-panel AI button to the model: registers a handler (via
+ * `api.setChartAiHandler`) that runs `aiChart` and returns the plan for the
+ * panel to apply + explain. Call once after `onApiReady`. `installEnterprise`
+ * calls this for you.
+ */
+export function enableAiCharting<
+  TFeatures extends TableFeatures,
+  TData extends RowData,
+>(api: SvGridApi<TFeatures, TData>): void {
+  const hook = api as unknown as {
+    setChartAiHandler?: (
+      fn: ((prompt: string) => Promise<Record<string, unknown> | null>) | null,
+    ) => void
+  }
+  hook.setChartAiHandler?.(async (prompt: string) => {
+    const plan = await aiChart(api, prompt)
+    return {
+      type: plan.type,
+      dimension: plan.dimension,
+      series: plan.series,
+      measure: plan.measure,
+      reduce: plan.reduce,
+      stacked: plan.stacked,
+      logScale: plan.logScale,
+      timeAxis: plan.timeAxis,
+      valueFormat: plan.valueFormat,
+      rationale: plan.rationale,
+    }
+  })
+}
+
+export function disableAiCharting<
+  TFeatures extends TableFeatures,
+  TData extends RowData,
+>(api: SvGridApi<TFeatures, TData>): void {
+  const hook = api as unknown as { setChartAiHandler?: (fn: null) => void }
+  hook.setChartAiHandler?.(null)
+}
+
+// ---------------------------------------------------------------------------
+// 8. Mock provider for examples + tests
+// ---------------------------------------------------------------------------
+
+/**
+ * A deterministic provider that returns canned, schema-shaped responses
+ * for each task. Wire it in via `setAIProvider(mockAIProvider)` to make
+ * the AI demo work end-to-end without a real model key. Not for production.
+ */
+export const mockAIProvider: AIProvider = async (req) => {
+  // Tiny artificial delay so the UI's "thinking" state is visible.
+  await new Promise((r) => setTimeout(r, 350 + Math.random() * 400))
+
+  if (req.task === 'filter') {
+    const q = extractUserQuery(req.prompt)
+    return JSON.stringify(buildMockFilter(req.prompt, q))
+  }
+  if (req.task === 'smart-fill') {
+    return JSON.stringify(buildMockSmartFill(req.prompt))
+  }
+  if (req.task === 'summarize') {
+    return JSON.stringify(buildMockSummary(req.prompt))
+  }
+  if (req.task === 'classify') {
+    return JSON.stringify(buildMockClassify(req.prompt))
+  }
+  if (req.task === 'export') {
+    return JSON.stringify(buildMockExport(req.prompt))
+  }
+  if (req.task === 'anomaly') {
+    return JSON.stringify(buildMockAnomaly(req.prompt))
+  }
+  if (req.task === 'chart') {
+    return JSON.stringify(buildMockChart(req.prompt))
+  }
+  return '{}'
+}
+
+function buildMockChart(prompt: string): AIChartPlan {
+  const q = extractUserRequest(prompt)
+  const typed = extractFieldTypes(prompt)
+  const textFields = typed.filter((f) => f.type === 'string' || f.type === 'date').map((f) => f.name)
+  const numberFields = typed.filter((f) => f.type === 'number').map((f) => f.name)
+
+  const type: AIChartType =
+    /\bline\b|\btrend\b|over time/.test(q) ? 'line'
+    : /\barea\b/.test(q) ? 'area'
+    : /\bpie\b|share|proportion|breakdown/.test(q) ? 'pie'
+    : 'bar'
+
+  const byMatch = q.match(/\bby\s+([a-z0-9_ ]+?)(?:\s+(?:split|stacked|grouped|by|as|,|$))/)
+  const pickText = (hint?: string): string | null => {
+    if (hint) {
+      const f = textFields.find((t) => t.toLowerCase() === hint.trim() || (hint.trim().length >= 4 && t.toLowerCase().includes(hint.trim())))
+      if (f) return f
+    }
+    return null
+  }
+  const dimension = pickText(byMatch?.[1]) ?? textFields[0] ?? null
+  const series =
+    /\b(split|stack(?:ed)?|by product|by category|per)\b/.test(q)
+      ? (textFields.find((t) => t !== dimension) ?? null)
+      : null
+  const measure = numberFields.find((n) => q.includes(n.toLowerCase())) ?? numberFields[0] ?? null
+  const reduce: 'sum' | 'avg' | 'count' =
+    /\b(average|avg|mean)\b/.test(q) ? 'avg' : /\b(count|number of|how many)\b/.test(q) ? 'count' : 'sum'
+  const stacked = /\bstack(ed)?\b/.test(q)
+  const logScale = /\b(log|logarithmic)\b/.test(q)
+  const timeAxis = /\b(over time|by date|by day|by month|by week|time series|timeline|trend)\b/.test(q)
+  const valueFormat: 'number' | 'currency' | 'percent' =
+    /\b(currency|money|revenue|sales|price|cost|\$|dollar)\b/.test(q) || /(price|revenue|amount|cost|sales)/i.test(measure ?? '')
+      ? 'currency'
+      : /\b(percent|percentage|%|rate|share)\b/.test(q)
+        ? 'percent'
+        : 'number'
+
+  return {
+    type, dimension, series, measure, reduce, stacked, logScale, timeAxis, valueFormat,
+    rationale:
+      `${type} chart of ${reduce}(${measure ?? 'value'}) by ${dimension ?? 'category'}` +
+      `${series ? `, split by ${series}` : ''}${stacked ? ', stacked' : ''}` +
+      `${logScale ? ', log scale' : ''}${timeAxis ? ', date axis' : ''} (mock - wire a real model for genuine parsing).`,
+  }
+}
+
+function extractUserRequest(prompt: string): string {
+  const m = prompt.match(/User request:\s*([\s\S]+)$/)
+  return (m?.[1] ?? '').trim().toLowerCase()
+}
+
+function buildMockExport(prompt: string): AIExportPlan {
+  const q = extractUserRequest(prompt)
+  const fields = extractFields(prompt)
+  // Reuse the filter mock (it reads "User query:"; feed it a compatible line).
+  const filterPlan = buildMockFilter(prompt + `\nUser query: ${q}\n`, q)
+
+  // Format keyword routing.
+  const format: ExportFormat =
+    /\bpdf\b/.test(q) ? 'pdf'
+    : /\bxls\b(?!x)/.test(q) || /97-2003|legacy excel/.test(q) ? 'xls'
+    : /\b(xlsx|excel|spreadsheet|workbook)\b/.test(q) ? 'xlsx'
+    : /\b(markdown|md)\b/.test(q) ? 'md'
+    : /\bjson\b/.test(q) ? 'json'
+    : /\bxml\b/.test(q) ? 'xml'
+    : /\btsv\b/.test(q) ? 'tsv'
+    : /\bhtml\b/.test(q) ? 'html'
+    : /\bcsv\b/.test(q) ? 'csv'
+    : 'xlsx'
+
+  // Grouping: "group by X" / "grouped by X", else "grouped" -> a categorical field.
+  const groupBy: string[] = []
+  const byMatch = q.match(/group(?:ed)?\s+by\s+([a-z0-9_ ,]+)/)
+  if (byMatch) {
+    for (const token of byMatch[1]!.split(/[, ]+/).filter(Boolean)) {
+      // Exact field match, or a substring match only for tokens long enough to
+      // be meaningful (so "a"/"as" don't match "amount").
+      const f = fields.find(
+        (ff) => ff.toLowerCase() === token || (token.length >= 4 && ff.toLowerCase().includes(token)),
+      )
+      if (f && !groupBy.includes(f)) groupBy.push(f)
+    }
+  } else if (/\bgroup(ed)?\b/.test(q)) {
+    const cat = fields.find((f) => /region|country|category|status|stage|type|group|dept|team/i.test(f))
+    if (cat) groupBy.push(cat)
+  }
+
+  return {
+    format,
+    filters: filterPlan.filters,
+    sort: filterPlan.sort,
+    groupBy,
+    rationale: `Export as ${format}${groupBy.length ? `, grouped by ${groupBy.join(' / ')}` : ''}${filterPlan.filters.length ? `; ${filterPlan.rationale}` : ''}`,
+  }
+}
+
+function buildMockAnomaly(prompt: string): AIAnomalyResult {
+  // Parse the sampled rows, flag the numeric outliers per numeric field.
+  const rowsBlock = prompt.match(/Rows \(index is 0-based into this list\):\n([\s\S]*?)\n\n/)?.[1] ?? ''
+  const parsed = rowsBlock
+    .split('\n')
+    .map((line) => {
+      const m = line.match(/^(\d+):\s*(\{[\s\S]*\})$/)
+      if (!m) return null
+      const row = safeParse(m[2]!) as Record<string, unknown> | null
+      return row ? { idx: parseInt(m[1]!, 10), row } : null
+    })
+    .filter((r): r is { idx: number; row: Record<string, unknown> } => !!r)
+
+  if (parsed.length === 0) {
+    return { anomalies: [], summary: 'No rows to scan (mock).' }
+  }
+
+  // Genuinely numeric fields only: every value is null or a real number (so
+  // booleans like `inStock` and id-ish strings are excluded). Also skip
+  // identifier / row-index columns - a max "id" isn't an anomaly.
+  const isIdLike = (f: string) => /(^id$|_id$|index|idx|^#|guid|uuid|serial|rownum)/i.test(f)
+  const numericFields = Object.keys(parsed[0]!.row).filter(
+    (f) =>
+      !isIdLike(f) &&
+      parsed.some((p) => typeof p.row[f] === 'number') &&
+      parsed.every((p) => p.row[f] == null || typeof p.row[f] === 'number'),
+  )
+
+  const anomalies: AIAnomaly[] = []
+  for (const f of numericFields.slice(0, 2)) {
+    let maxIdx = -1
+    let maxVal = -Infinity
+    for (const p of parsed) {
+      const n = Number(p.row[f])
+      if (Number.isFinite(n) && n > maxVal) {
+        maxVal = n
+        maxIdx = p.idx
+      }
+    }
+    if (maxIdx >= 0) {
+      anomalies.push({
+        rowIndex: maxIdx,
+        field: f,
+        value: maxVal,
+        reason: `${f} = ${maxVal} is the highest in the sample and may be an outlier`,
+        severity: 'medium',
+      })
+    }
+  }
+
+  return {
+    anomalies,
+    summary:
+      anomalies.length > 0
+        ? `Flagged ${anomalies.length} potential outlier${anomalies.length === 1 ? '' : 's'} (mock heuristic - wire a real model for genuine analysis).`
+        : 'No obvious anomalies in the sample (mock).',
+  }
+}
+
+function extractUserQuery(prompt: string): string {
+  const m = prompt.match(/User query:\s*(.+?)\n/)
+  return (m?.[1] ?? '').toLowerCase()
+}
+
+function extractFields(prompt: string): string[] {
+  const m = prompt.match(/Columns:\n([\s\S]*?)\n\n/)
+  if (!m) return []
+  return (m[1] ?? '')
+    .split('\n')
+    .map((l) => l.match(/^- (\w+)/)?.[1])
+    .filter((s): s is string => !!s)
+}
+
+/** Parse the "- name (type): ..." schema block into {name, type} pairs. */
+function extractFieldTypes(prompt: string): Array<{ name: string; type: string }> {
+  const m = prompt.match(/Columns:\n([\s\S]*?)\n\n/)
+  if (!m) return []
+  return (m[1] ?? '')
+    .split('\n')
+    .map((l) => {
+      const mm = l.match(/^- (\w+)\s*\((\w+)\)/)
+      return mm ? { name: mm[1]!, type: mm[2]! } : null
+    })
+    .filter((x): x is { name: string; type: string } => !!x)
+}
+
+function buildMockFilter(prompt: string, q: string): AIFilterResult {
+  const fields = extractFields(prompt)
+  const filters: AIFilterClause[] = []
+  const sort: AISortClause[] = []
+  const rationale: string[] = []
+
+  // Greedy keyword routing. Real model would be smarter; this only needs
+  // to convince the demo viewer the pipeline works.
+  const numberWord = q.match(/(?:over|above|>|greater than)\s+\$?([\d.,]+)([kmb])?/)
+  const lessWord   = q.match(/(?:under|below|<|less than)\s+\$?([\d.,]+)([kmb])?/)
+  // Pick a NUMBER-typed field (never a boolean like `inStock`), money-named
+  // ones first so "$300" targets price/amount rather than a count/index.
+  const numberTyped = extractFieldTypes(prompt).filter((f) => f.type === 'number').map((f) => f.name)
+  const moneyRe = /(price|amount|cost|revenue|total|value|salary|arr|fee|spend|budget|sales)/i
+  const numberPool = numberTyped.length > 0 ? numberTyped : fields
+  const numberFields = [
+    ...numberPool.filter((f) => moneyRe.test(f)),
+    ...numberPool.filter((f) => !moneyRe.test(f)),
+  ]
+
+  if (numberWord && numberFields[0]) {
+    const raw = parseFloat(numberWord[1]!.replace(/,/g, ''))
+    const mul = numberWord[2] === 'k' ? 1_000 : numberWord[2] === 'm' ? 1_000_000 : numberWord[2] === 'b' ? 1_000_000_000 : 1
+    filters.push({ field: numberFields[0], operator: 'greaterThan', value: String(raw * mul) })
+    rationale.push(`amount > ${raw}${numberWord[2] ?? ''}`)
+  } else if (lessWord && numberFields[0]) {
+    const raw = parseFloat(lessWord[1]!.replace(/,/g, ''))
+    const mul = lessWord[2] === 'k' ? 1_000 : lessWord[2] === 'm' ? 1_000_000 : 1
+    filters.push({ field: numberFields[0], operator: 'lessThan', value: String(raw * mul) })
+    rationale.push(`amount < ${raw}${lessWord[2] ?? ''}`)
+  }
+
+  // Quoted phrases -> contains on a likely text field.
+  const quote = q.match(/"([^"]+)"|'([^']+)'/)
+  const textFields = fields.filter((f) => /(name|company|customer|title|owner|status|region|category|industry)/i.test(f))
+  if (quote) {
+    const term = quote[1] ?? quote[2] ?? ''
+    if (textFields[0]) {
+      filters.push({ field: textFields[0], operator: 'contains', value: term })
+      rationale.push(`text contains "${term}"`)
+    }
+  }
+
+  // Person-name routing -> match owner/contact fields.
+  const personOwners = ['sasha', 'jamie', 'casey', 'drew', 'robin', 'morgan', 'riley', 'quinn']
+  for (const n of personOwners) {
+    if (q.includes(n)) {
+      const ownerField = fields.find((f) => /owner|rep|assigned/i.test(f)) ?? fields.find((f) => /name/i.test(f))
+      if (ownerField) {
+        filters.push({ field: ownerField, operator: 'contains', value: n })
+        rationale.push(`owner ~ "${n}"`)
+        break
+      }
+    }
+  }
+
+  // Region routing.
+  for (const r of ['NA', 'EMEA', 'APAC', 'LATAM']) {
+    if (q.toUpperCase().includes(r)) {
+      const regionField = fields.find((f) => /region/i.test(f))
+      if (regionField) {
+        filters.push({ field: regionField, operator: 'equals', value: r })
+        rationale.push(`region = ${r}`)
+        break
+      }
+    }
+  }
+
+  // Status routing - any token in the query that matches a known status.
+  for (const s of ['active', 'pending', 'won', 'lost', 'live', 'paused', 'shipped', 'delivered']) {
+    if (q.includes(s)) {
+      const f = fields.find((f) => /status|stage/i.test(f))
+      if (f) {
+        filters.push({ field: f, operator: 'equals', value: s })
+        rationale.push(`status = ${s}`)
+        break
+      }
+    }
+  }
+
+  // Sort detection.
+  if (/(highest|largest|biggest|top|most)/.test(q)) {
+    const f = numberFields[0]
+    if (f) { sort.push({ field: f, desc: true }); rationale.push(`sort by ${f} desc`) }
+  } else if (/(lowest|smallest|least|cheapest)/.test(q)) {
+    const f = numberFields[0]
+    if (f) { sort.push({ field: f, desc: false }); rationale.push(`sort by ${f} asc`) }
+  } else if (/(newest|recent|latest)/.test(q)) {
+    const dateField = fields.find((f) => /date|at|time/i.test(f))
+    if (dateField) { sort.push({ field: dateField, desc: true }); rationale.push(`sort by ${dateField} desc`) }
+  } else if (/(oldest)/.test(q)) {
+    const dateField = fields.find((f) => /date|at|time/i.test(f))
+    if (dateField) { sort.push({ field: dateField, desc: false }); rationale.push(`sort by ${dateField} asc`) }
+  }
+
+  return {
+    filters,
+    sort,
+    rationale: rationale.length
+      ? `Interpreted: ${rationale.join(' AND ')}.`
+      : `Couldn't identify a clear filter for "${q}". Showing all rows.`,
+  }
+}
+
+function buildMockSmartFill(prompt: string): { predictions: Array<{ rowIndex: number; value: unknown; confidence: number }>; rationale: string } {
+  // Extract the target column and the rows-to-fill block; copy the first
+  // example's "output" pattern verbatim so the demo always returns
+  // something believable. Real models do much better - that's the point.
+  const fieldMatch = prompt.match(/Target column:\s*(\w+)/)
+  const rowsMatch = prompt.match(/Rows to fill:\n([\s\S]*?)\n\n/)
+  const exMatch = prompt.match(/Example 1: input=.* -> output=(.+)/)
+  const targetField = fieldMatch?.[1] ?? ''
+  const rowLines = (rowsMatch?.[1] ?? '').split('\n').filter(Boolean)
+  const exampleOutput = exMatch?.[1] ? safeParse(exMatch[1]) : ''
+  const predictions = rowLines
+    .map((line) => {
+      const m = line.match(/^Row (\d+): (\{.+\})/)
+      if (!m) return null
+      const rowIndex = parseInt(m[1]!, 10)
+      const row = safeParse(m[2]!) as Record<string, unknown> | null
+      if (!row) return null
+      const value = inferFromRow(targetField, row, exampleOutput)
+      return { rowIndex, value, confidence: 0.78 + Math.random() * 0.18 }
+    })
+    .filter((p): p is { rowIndex: number; value: unknown; confidence: number } => !!p)
+  return {
+    predictions,
+    rationale: `Inferred from ${exMatch ? 'the supplied' : 'no'} examples; mocked deterministically for the demo.`,
+  }
+}
+
+function safeParse(s: string): unknown {
+  try { return JSON.parse(s) } catch { return null }
+}
+
+function inferFromRow(field: string, row: Record<string, unknown>, exampleOutput: unknown): unknown {
+  // Mock heuristics that produce a value that "looks right" in common
+  // demo scenarios. The real provider would route through a real model.
+  if (field === 'priority') {
+    const arr = Number(row.arr ?? row.amount ?? row.price ?? 0)
+    return arr > 100_000 ? 'high' : arr > 30_000 ? 'medium' : 'low'
+  }
+  if (field === 'tier') {
+    const arr = Number(row.arr ?? row.amount ?? 0)
+    return arr > 500_000 ? 'enterprise' : arr > 100_000 ? 'growth' : 'starter'
+  }
+  if (field === 'tags' || field === 'category') {
+    return typeof exampleOutput === 'string' ? exampleOutput : 'auto-tag'
+  }
+  if (typeof exampleOutput === 'string') return exampleOutput
+  if (typeof exampleOutput === 'number') return exampleOutput
+  return exampleOutput ?? 'auto'
+}
+
+function buildMockSummary(prompt: string): AISummary {
+  const sliceMatch = prompt.match(/Slice size: (\d+) row/)
+  const n = sliceMatch ? parseInt(sliceMatch[1]!, 10) : 0
+  const fields = extractSummaryFields(prompt)
+  return {
+    text:
+      n === 1
+        ? `Single record. Notable signals come from ${fields.slice(0, 2).join(' and ') || 'the available fields'}.`
+        : `${n} rows in scope. The distribution skews toward live / active records, with a long tail in ${fields[0] ?? 'amount'}.`,
+    bullets: [
+      `${n} row${n === 1 ? '' : 's'} sampled`,
+      fields[0] ? `Largest variance in ${fields[0]}` : 'Tight clustering across visible fields',
+      fields[1] ? `${fields[1]} concentrates around the median` : 'Few outliers',
+      'Mock summary - wire setAIProvider() to a real model for actual analysis',
+    ],
+    highlightedFields: fields.slice(0, 3),
+  }
+}
+
+function extractSummaryFields(prompt: string): string[] {
+  const m = prompt.match(/Columns:\n([\s\S]*?)\n\n/)
+  if (!m) return []
+  return (m[1] ?? '')
+    .split('\n')
+    .map((l) => l.match(/^- (\w+)/)?.[1])
+    .filter((s): s is string => !!s)
+}
+
+function buildMockClassify(prompt: string): { predictions: Array<{ rowIndex: number; value: string; confidence: number }> } {
+  const labelsMatch = prompt.match(/Allowed labels[\s\S]*?:\n([\s\S]*?)\n\n/)
+  // Capture the label up to the first colon, whitespace or end-of-line so
+  // we don't pick up the rubric ("- at-risk: churn signals..." -> "at-risk").
+  const labels = (labelsMatch?.[1] ?? '')
+    .split('\n')
+    .map((l) => l.match(/^-\s*([^\s:]+)/)?.[1])
+    .filter((s): s is string => !!s)
+  const rowLines = (prompt.match(/Rows to classify[\s\S]*?:\n([\s\S]*?)\n\n/)?.[1] ?? '').split('\n').filter(Boolean)
+  const predictions = rowLines.map((line) => {
+    const m = line.match(/^Row (\d+): "(.*)"/)
+    if (!m || labels.length === 0) return null
+    const rowIndex = parseInt(m[1]!, 10)
+    const text = (m[2] ?? '').toLowerCase()
+    // Pick the label whose token appears in the text; otherwise hash.
+    const hit = labels.find((l) => text.includes(l.toLowerCase()))
+    const value = hit ?? labels[Math.abs(hashStr(text)) % labels.length]!
+    return { rowIndex, value, confidence: hit ? 0.92 : 0.6 + Math.random() * 0.2 }
+  }).filter((p): p is { rowIndex: number; value: string; confidence: number } => !!p)
+  return { predictions }
+}
+
+function hashStr(s: string): number {
+  let h = 0
+  for (let i = 0; i < s.length; i += 1) h = (h * 31 + s.charCodeAt(i)) | 0
+  return h
+}