@svgrid/enterprise 2.2.1 → 2.3.1

package/src/SvPivotDesigner.svelte

@@ -31,6 +31,7 @@
     popIn,
     createDismissableLayer,
     createFocusTrap,
+    onScrollOutside,
     type ColumnDef,
     type ChartType,
     type MenuItem,
@@ -692,9 +693,8 @@
     trap.activate()
     const layer = createDismissableLayer({ element: () => ctxPanelEl, onDismiss: closeCtx })
     layer.activate()
-    const onScroll = () => closeCtx()
-    window.addEventListener('scroll', onScroll, true)
-    return () => { layer.release(); trap.release(); window.removeEventListener('scroll', onScroll, true) }
+    const offScroll = onScrollOutside(() => ctxPanelEl, closeCtx)
+    return () => { layer.release(); trap.release(); offScroll() }
   })
 
   function clearWell(well: Well) {

package/src/SvRecordDetail.svelte

@@ -19,7 +19,9 @@
   type Section = { label: string; fields: string[] }
   type Related = {
     label: string
-    schema: EntitySchema
+    // Accept any specialized EntitySchema<T> (the type param is invariant); this is
+    // pure presentation over the schema's field metadata + plain record rows.
+    schema: EntitySchema<any>
     rows?: ReadonlyArray<Row>
     /** The child field pointing back at this record. */
     foreignKey: string
@@ -46,7 +48,9 @@
     loading = false,
     height,
   }: {
-    schema: EntitySchema
+    // Accept any specialized EntitySchema<T> (the type param is invariant); this is
+    // pure presentation over the schema's field metadata + plain record rows.
+    schema: EntitySchema<any>
     rows?: ReadonlyArray<Row>
     /** The specific record to show. Omit to self-drive off `rows`. */
     row?: Row

package/src/SvSchedule.svelte

@@ -23,7 +23,9 @@
     loading = false,
     height,
   }: {
-    schema: EntitySchema
+    // Accept any specialized EntitySchema<T> (the type param is invariant); this is
+    // pure presentation over the schema's field metadata + plain record rows.
+    schema: EntitySchema<any>
     rows?: ReadonlyArray<Row>
     /** The date / datetime field that places a row on the calendar. */
     dateField: string

package/src/{ai-export-pdf.test.ts → ai-export-pdf.dom.test.ts}

@@ -1,74 +1,77 @@
-import { beforeEach, describe, expect, it, vi } from 'vitest'
-
-// Capture exactly what exportGrid receives (so we don't need pdfmake / the DOM).
-const calls: Array<{ format: string; rows?: unknown[]; groupBy?: string[] }> = []
-vi.mock('./export', () => ({
-  exportGrid: async (_api: unknown, opts: { format: string; rows?: unknown[]; groupBy?: string[] }) => {
-    calls.push({ format: opts.format, rows: opts.rows as unknown[], groupBy: opts.groupBy })
-  },
-}))
-
-import { aiExport, setAIProvider, mockAIProvider } from './ai'
-import { setLicenseKey } from './license'
-
-type Order = { country: string; company: string; product: string; quantity: number; price: number }
-const rows: Order[] = Array.from({ length: 120 }, (_, i) => ({
-  country: ['USA', 'UK', 'Germany'][i % 3]!,
-  company: `Co${i}`,
-  product: 'Widget',
-  quantity: 5 + (i % 50),
-  price: Math.round((10 + ((i * 41) % 480)) * 100) / 100, // spread 10..490
-}))
-
-function makeApi() {
-  return {
-    getData: () => rows,
-    // Simulate the grid returning EVERYTHING (the reactive-filter bug we route around).
-    getDisplayedRows: () => rows,
-    getSelectedRows: () => [],
-    getColumns: () => [
-      { id: 'country', field: 'country', header: 'Country', visible: true },
-      { id: 'company', field: 'company', header: 'Company', visible: true },
-      { id: 'product', field: 'product', header: 'Product', visible: true },
-      { id: 'quantity', field: 'quantity', header: 'Qty', visible: true },
-      { id: 'price', field: 'price', header: 'Price', visible: true },
-    ],
-    getState: () => ({ grouping: [] }),
-    clearAllFilters: vi.fn(),
-    clearSort: vi.fn(),
-    setFilter: vi.fn(),
-    setSort: vi.fn(),
-    setGroupBy: vi.fn(),
-  } as any
-}
-
-beforeEach(() => {
-  calls.length = 0
-  setLicenseKey('SVENTERPRISE-DEV-TEST')
-  setAIProvider(mockAIProvider)
-})
-
-describe('aiExport - the demo 203 "grouped PDF" query', () => {
-  it('parses the plan and exports non-empty, filtered, grouped rows', async () => {
-    const plan = await aiExport(makeApi(), 'export orders over $300 as a grouped PDF by country')
-
-    expect(plan.format).toBe('pdf')
-    expect(plan.groupBy).toEqual(['country'])
-    expect(plan.filters).toContainEqual({ field: 'price', operator: 'greaterThan', value: '300' })
-
-    // exportGrid was called with real, filtered rows (not the empty grid view).
-    expect(calls).toHaveLength(1)
-    expect(calls[0]!.format).toBe('pdf')
-    expect(calls[0]!.groupBy).toEqual(['country'])
-    const exported = calls[0]!.rows as Order[]
-    expect(exported.length).toBeGreaterThan(0)
-    expect(exported.every((r) => r.price > 300)).toBe(true)
-    // Rows are contiguous by country (group order preserved).
-    const countries = exported.map((r) => r.country)
-    const firstSeen = [...new Set(countries)]
-    const contiguous = countries.join('|')
-    for (const c of firstSeen) {
-      expect(contiguous).toMatch(new RegExp(`(?:^|\\|)${c}(?:\\|${c})*(?:\\||$)`))
-    }
-  })
-})
+import { beforeEach, describe, expect, it, vi } from 'vitest'
+
+// Capture exactly what exportGrid receives (so we don't need pdfmake / the DOM).
+const calls: Array<{ format: string; rows?: unknown[]; groupBy?: string[] }> = []
+vi.mock('./export', () => ({
+  exportGrid: async (_api: unknown, opts: { format: string; rows?: unknown[]; groupBy?: string[] }) => {
+    calls.push({ format: opts.format, rows: opts.rows as unknown[], groupBy: opts.groupBy })
+  },
+}))
+
+import { aiExport, setAIProvider, mockAIProvider, registerExportProvider } from '@svgrid/grid'
+import { exportGrid } from './export'
+import { setLicenseKey } from './license'
+
+type Order = { country: string; company: string; product: string; quantity: number; price: number }
+const rows: Order[] = Array.from({ length: 120 }, (_, i) => ({
+  country: ['USA', 'UK', 'Germany'][i % 3]!,
+  company: `Co${i}`,
+  product: 'Widget',
+  quantity: 5 + (i % 50),
+  price: Math.round((10 + ((i * 41) % 480)) * 100) / 100, // spread 10..490
+}))
+
+function makeApi() {
+  return {
+    getData: () => rows,
+    // Simulate the grid returning EVERYTHING (the reactive-filter bug we route around).
+    getDisplayedRows: () => rows,
+    getSelectedRows: () => [],
+    getColumns: () => [
+      { id: 'country', field: 'country', header: 'Country', visible: true },
+      { id: 'company', field: 'company', header: 'Company', visible: true },
+      { id: 'product', field: 'product', header: 'Product', visible: true },
+      { id: 'quantity', field: 'quantity', header: 'Qty', visible: true },
+      { id: 'price', field: 'price', header: 'Price', visible: true },
+    ],
+    getState: () => ({ grouping: [] }),
+    clearAllFilters: vi.fn(),
+    clearSort: vi.fn(),
+    setFilter: vi.fn(),
+    setSort: vi.fn(),
+    setGroupBy: vi.fn(),
+  } as any
+}
+
+beforeEach(() => {
+  calls.length = 0
+  setLicenseKey('SVENTERPRISE-DEV-TEST')
+  setAIProvider(mockAIProvider)
+  // aiExport delegates to the registered engine - here the mocked exportGrid.
+  registerExportProvider(exportGrid as never)
+})
+
+describe('aiExport - the demo 203 "grouped PDF" query', () => {
+  it('parses the plan and exports non-empty, filtered, grouped rows', async () => {
+    const plan = await aiExport(makeApi(), 'export orders over $300 as a grouped PDF by country')
+
+    expect(plan.format).toBe('pdf')
+    expect(plan.groupBy).toEqual(['country'])
+    expect(plan.filters).toContainEqual({ field: 'price', operator: 'greaterThan', value: '300' })
+
+    // exportGrid was called with real, filtered rows (not the empty grid view).
+    expect(calls).toHaveLength(1)
+    expect(calls[0]!.format).toBe('pdf')
+    expect(calls[0]!.groupBy).toEqual(['country'])
+    const exported = calls[0]!.rows as Order[]
+    expect(exported.length).toBeGreaterThan(0)
+    expect(exported.every((r) => r.price > 300)).toBe(true)
+    // Rows are contiguous by country (group order preserved).
+    const countries = exported.map((r) => r.country)
+    const firstSeen = [...new Set(countries)]
+    const contiguous = countries.join('|')
+    for (const c of firstSeen) {
+      expect(contiguous).toMatch(new RegExp(`(?:^|\\|)${c}(?:\\|${c})*(?:\\||$)`))
+    }
+  })
+})

package/src/{ai-export-xlsx.test.ts → ai-export-xlsx.dom.test.ts}

@@ -1,87 +1,90 @@
-import { beforeEach, describe, expect, it, vi } from 'vitest'
-
-// Real exportGrid runs (NOT mocked). Capture the xlsx parts / avoid the DOM.
-const captured: { parts: Record<string, string> } = { parts: {} }
-vi.mock('jszip', () => ({
-  default: class {
-    file(p: string, d: string) {
-      captured.parts[p] = d
-    }
-    async generateAsync() {
-      return new Blob([])
-    }
-  },
-}))
-vi.mock('./export-serialize', async (importOriginal) => {
-  const actual = (await importOriginal()) as Record<string, unknown>
-  return { ...actual, downloadBlobFile: () => {}, downloadTextFile: () => {} }
-})
-
-import { aiExport, setAIProvider, mockAIProvider } from './ai'
-import { setLicenseKey } from './license'
-
-// Mirrors the real makeOrders shape - crucially includes `inStock` (boolean)
-// and `quantity`/`index` (numbers that never exceed 300), so the mock must
-// target `price` for "$300", not a boolean or a count.
-type Order = {
-  id: string
-  index: number
-  country: string
-  company: string
-  product: string
-  inStock: boolean
-  quantity: number
-  price: number
-}
-const rows: Order[] = Array.from({ length: 120 }, (_, i) => ({
-  id: `o${i}`,
-  index: i + 1,
-  country: ['USA', 'UK', 'Germany'][i % 3]!,
-  company: `Co${i}`,
-  product: 'Widget',
-  inStock: i % 3 !== 0,
-  quantity: 5 + (i % 50), // max 54 - never > 300
-  price: Math.round((10 + ((i * 41) % 480)) * 100) / 100, // spread 10..490
-}))
-
-function makeApi() {
-  return {
-    getData: () => rows,
-    getDisplayedRows: () => rows,
-    getSelectedRows: () => [],
-    getColumns: () => [
-      { id: 'country', field: 'country', header: 'Country', visible: true },
-      { id: 'company', field: 'company', header: 'Company', visible: true },
-      { id: 'product', field: 'product', header: 'Product', visible: true },
-      { id: 'quantity', field: 'quantity', header: 'Qty', visible: true },
-      { id: 'price', field: 'price', header: 'Price', visible: true, format: { type: 'currency', currency: 'USD' } },
-    ],
-    getState: () => ({ grouping: [] }),
-    getColumnPinning: () => ({ left: [], right: [] }),
-    clearAllFilters: vi.fn(),
-    clearSort: vi.fn(),
-    setFilter: vi.fn(),
-    setSort: vi.fn(),
-    setGroupBy: vi.fn(),
-  } as any
-}
-
-beforeEach(() => {
-  captured.parts = {}
-  setLicenseKey('SVENTERPRISE-DEV-TEST')
-  setAIProvider(mockAIProvider)
-})
-
-describe('aiExport - "export orders over $300" (xlsx default)', () => {
-  it('produces a non-empty xlsx via the real export path', async () => {
-    const plan = await aiExport(makeApi(), 'export orders over $300')
-    expect(plan.format).toBe('xlsx')
-    expect(plan.filters).toContainEqual({ field: 'price', operator: 'greaterThan', value: '300' })
-
-    const sheet = captured.parts['xl/worksheets/sheet1.xml']
-    expect(sheet).toBeTruthy()
-    // header row + at least one data row
-    const rowCount = (sheet!.match(/<row /g) ?? []).length
-    expect(rowCount).toBeGreaterThan(1)
-  })
-})
+import { beforeEach, describe, expect, it, vi } from 'vitest'
+
+// Real exportGrid runs (NOT mocked). Capture the xlsx parts / avoid the DOM.
+const captured: { parts: Record<string, string> } = { parts: {} }
+vi.mock('jszip', () => ({
+  default: class {
+    file(p: string, d: string) {
+      captured.parts[p] = d
+    }
+    async generateAsync() {
+      return new Blob([])
+    }
+  },
+}))
+vi.mock('./export-serialize', async (importOriginal) => {
+  const actual = (await importOriginal()) as Record<string, unknown>
+  return { ...actual, downloadBlobFile: () => {}, downloadTextFile: () => {} }
+})
+
+import { aiExport, setAIProvider, mockAIProvider, registerExportProvider } from '@svgrid/grid'
+import { exportGrid } from './export'
+import { setLicenseKey } from './license'
+
+// Mirrors the real makeOrders shape - crucially includes `inStock` (boolean)
+// and `quantity`/`index` (numbers that never exceed 300), so the mock must
+// target `price` for "$300", not a boolean or a count.
+type Order = {
+  id: string
+  index: number
+  country: string
+  company: string
+  product: string
+  inStock: boolean
+  quantity: number
+  price: number
+}
+const rows: Order[] = Array.from({ length: 120 }, (_, i) => ({
+  id: `o${i}`,
+  index: i + 1,
+  country: ['USA', 'UK', 'Germany'][i % 3]!,
+  company: `Co${i}`,
+  product: 'Widget',
+  inStock: i % 3 !== 0,
+  quantity: 5 + (i % 50), // max 54 - never > 300
+  price: Math.round((10 + ((i * 41) % 480)) * 100) / 100, // spread 10..490
+}))
+
+function makeApi() {
+  return {
+    getData: () => rows,
+    getDisplayedRows: () => rows,
+    getSelectedRows: () => [],
+    getColumns: () => [
+      { id: 'country', field: 'country', header: 'Country', visible: true },
+      { id: 'company', field: 'company', header: 'Company', visible: true },
+      { id: 'product', field: 'product', header: 'Product', visible: true },
+      { id: 'quantity', field: 'quantity', header: 'Qty', visible: true },
+      { id: 'price', field: 'price', header: 'Price', visible: true, format: { type: 'currency', currency: 'USD' } },
+    ],
+    getState: () => ({ grouping: [] }),
+    getColumnPinning: () => ({ left: [], right: [] }),
+    clearAllFilters: vi.fn(),
+    clearSort: vi.fn(),
+    setFilter: vi.fn(),
+    setSort: vi.fn(),
+    setGroupBy: vi.fn(),
+  } as any
+}
+
+beforeEach(() => {
+  captured.parts = {}
+  setLicenseKey('SVENTERPRISE-DEV-TEST')
+  setAIProvider(mockAIProvider)
+  // aiExport is free (grid) and delegates the real write to enterprise's engine.
+  registerExportProvider(exportGrid as never)
+})
+
+describe('aiExport - "export orders over $300" (xlsx default)', () => {
+  it('produces a non-empty xlsx via the real export path', async () => {
+    const plan = await aiExport(makeApi(), 'export orders over $300')
+    expect(plan.format).toBe('xlsx')
+    expect(plan.filters).toContainEqual({ field: 'price', operator: 'greaterThan', value: '300' })
+
+    const sheet = captured.parts['xl/worksheets/sheet1.xml']
+    expect(sheet).toBeTruthy()
+    // header row + at least one data row
+    const rowCount = (sheet!.match(/<row /g) ?? []).length
+    expect(rowCount).toBeGreaterThan(1)
+  })
+})

package/src/{ai-export.test.ts → ai-export.dom.test.ts}

@@ -1,110 +1,114 @@
-import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest'
-
-// Capture downloads instead of touching the DOM (aiExport -> exportGrid).
-const downloads: Array<{ text: string; filename: string }> = []
-vi.mock('./export-serialize', async (importOriginal) => {
-  const actual = (await importOriginal()) as Record<string, unknown>
-  return {
-    ...actual,
-    downloadTextFile: (text: string, filename: string) => {
-      downloads.push({ text, filename })
-    },
-  }
-})
-
-import { aiExport, aiFindAnomalies, setAIProvider, mockAIProvider } from './ai'
-import { setLicenseKey } from './license'
-
-type Row = { region: string; amount: number; name: string }
-const rows: Row[] = [
-  { region: 'EMEA', amount: 100, name: 'A' },
-  { region: 'NA', amount: 2000, name: 'B' },
-  { region: 'EMEA', amount: 50, name: 'C' },
-]
-
-function makeApi() {
-  return {
-    getData: () => rows,
-    getDisplayedRows: () => rows,
-    getSelectedRows: () => [],
-    getColumns: () => [
-      { id: 'region', field: 'region', header: 'Region', visible: true },
-      { id: 'amount', field: 'amount', header: 'Amount', visible: true },
-      { id: 'name', field: 'name', header: 'Name', visible: true },
-    ],
-    getState: () => ({ grouping: [] }),
-    clearAllFilters: vi.fn(),
-    clearSort: vi.fn(),
-    setFilter: vi.fn(),
-    setSort: vi.fn(),
-  } as any
-}
-
-beforeEach(() => {
-  downloads.length = 0
-  setLicenseKey('SVENTERPRISE-DEV-TEST')
-  setAIProvider(mockAIProvider)
-})
-afterEach(() => setAIProvider(null))
-
-describe('aiExport', () => {
-  it('parses format + groupBy + filters; applies to the grid only when asked', async () => {
-    const api = makeApi()
-    const plan = await aiExport(api, 'export deals over 500 grouped by region as a pdf', {
-      run: false,
-      apply: true,
-    })
-    expect(plan.format).toBe('pdf')
-    expect(plan.groupBy).toEqual(['region'])
-    expect(plan.filters).toContainEqual({ field: 'amount', operator: 'greaterThan', value: '500' })
-    // apply: true -> the grid is mutated
-    expect(api.clearAllFilters).toHaveBeenCalled()
-    expect(api.setFilter).toHaveBeenCalledWith('amount', { operator: 'greaterThan', value: '500' })
-    // run:false -> nothing downloaded
-    expect(downloads).toHaveLength(0)
-  })
-
-  it('defaults to xlsx and does NOT touch the grid (apply defaults off)', async () => {
-    const api = makeApi()
-    const plan = await aiExport(api, 'just export everything', { run: false })
-    expect(plan.format).toBe('xlsx')
-    expect(api.clearAllFilters).not.toHaveBeenCalled()
-    expect(api.setFilter).not.toHaveBeenCalled()
-  })
-
-  it('runs the export (downloads) when run is not false', async () => {
-    const api = makeApi()
-    await aiExport(api, 'export as csv', { filename: 'report' })
-    expect(downloads).toHaveLength(1)
-    expect(downloads[0]!.filename).toBe('report.csv')
-  })
-
-  it('exports the plan-filtered rows directly (not the grid displayed rows)', async () => {
-    // getDisplayedRows returns EVERYTHING (as if the grid hadn't re-filtered);
-    // the export must still contain only rows matching the plan's filter.
-    const api = makeApi()
-    await aiExport(api, 'export deals over 500 as csv', { filename: 'big' })
-    const { text } = downloads[0]!
-    expect(text).toContain('2000') // amount 2000 > 500 kept
-    expect(text).not.toContain('100') // amount 100 filtered out
-    expect(text).not.toContain('50') // amount 50 filtered out
-  })
-})
-
-describe('aiFindAnomalies', () => {
-  it('flags a numeric outlier over the scanned rows', async () => {
-    const api = makeApi()
-    const result = await aiFindAnomalies(api, {})
-    expect(result.anomalies.length).toBeGreaterThan(0)
-    const amountAnomaly = result.anomalies.find((a) => a.field === 'amount')
-    expect(amountAnomaly?.value).toBe(2000) // the max in the sample
-    expect(amountAnomaly?.severity).toBe('medium')
-    expect(result.summary).toBeTruthy()
-  })
-
-  it('returns empty for an empty selection', async () => {
-    const api = makeApi()
-    const result = await aiFindAnomalies(api, { target: { kind: 'selection', rowIndices: [] } })
-    expect(result.anomalies).toEqual([])
-  })
-})
+import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest'
+
+// Capture downloads instead of touching the DOM (aiExport -> exportGrid).
+const downloads: Array<{ text: string; filename: string }> = []
+vi.mock('./export-serialize', async (importOriginal) => {
+  const actual = (await importOriginal()) as Record<string, unknown>
+  return {
+    ...actual,
+    downloadTextFile: (text: string, filename: string) => {
+      downloads.push({ text, filename })
+    },
+  }
+})
+
+import { aiExport, aiFindAnomalies, setAIProvider, mockAIProvider, registerExportProvider } from '@svgrid/grid'
+import { exportGrid } from './export'
+import { setLicenseKey } from './license'
+
+type Row = { region: string; amount: number; name: string }
+const rows: Row[] = [
+  { region: 'EMEA', amount: 100, name: 'A' },
+  { region: 'NA', amount: 2000, name: 'B' },
+  { region: 'EMEA', amount: 50, name: 'C' },
+]
+
+function makeApi() {
+  return {
+    getData: () => rows,
+    getDisplayedRows: () => rows,
+    getSelectedRows: () => [],
+    getColumns: () => [
+      { id: 'region', field: 'region', header: 'Region', visible: true },
+      { id: 'amount', field: 'amount', header: 'Amount', visible: true },
+      { id: 'name', field: 'name', header: 'Name', visible: true },
+    ],
+    getState: () => ({ grouping: [] }),
+    clearAllFilters: vi.fn(),
+    clearSort: vi.fn(),
+    setFilter: vi.fn(),
+    setSort: vi.fn(),
+  } as any
+}
+
+beforeEach(() => {
+  downloads.length = 0
+  setLicenseKey('SVENTERPRISE-DEV-TEST')
+  setAIProvider(mockAIProvider)
+  // aiExport is free (grid) and delegates the WRITE to the registered engine;
+  // register enterprise's exportGrid so the download path actually runs.
+  registerExportProvider(exportGrid as never)
+})
+afterEach(() => setAIProvider(null))
+
+describe('aiExport', () => {
+  it('parses format + groupBy + filters; applies to the grid only when asked', async () => {
+    const api = makeApi()
+    const plan = await aiExport(api, 'export deals over 500 grouped by region as a pdf', {
+      run: false,
+      apply: true,
+    })
+    expect(plan.format).toBe('pdf')
+    expect(plan.groupBy).toEqual(['region'])
+    expect(plan.filters).toContainEqual({ field: 'amount', operator: 'greaterThan', value: '500' })
+    // apply: true -> the grid is mutated
+    expect(api.clearAllFilters).toHaveBeenCalled()
+    expect(api.setFilter).toHaveBeenCalledWith('amount', { operator: 'greaterThan', value: '500' })
+    // run:false -> nothing downloaded
+    expect(downloads).toHaveLength(0)
+  })
+
+  it('defaults to xlsx and does NOT touch the grid (apply defaults off)', async () => {
+    const api = makeApi()
+    const plan = await aiExport(api, 'just export everything', { run: false })
+    expect(plan.format).toBe('xlsx')
+    expect(api.clearAllFilters).not.toHaveBeenCalled()
+    expect(api.setFilter).not.toHaveBeenCalled()
+  })
+
+  it('runs the export (downloads) when run is not false', async () => {
+    const api = makeApi()
+    await aiExport(api, 'export as csv', { filename: 'report' })
+    expect(downloads).toHaveLength(1)
+    expect(downloads[0]!.filename).toBe('report.csv')
+  })
+
+  it('exports the plan-filtered rows directly (not the grid displayed rows)', async () => {
+    // getDisplayedRows returns EVERYTHING (as if the grid hadn't re-filtered);
+    // the export must still contain only rows matching the plan's filter.
+    const api = makeApi()
+    await aiExport(api, 'export deals over 500 as csv', { filename: 'big' })
+    const { text } = downloads[0]!
+    expect(text).toContain('2000') // amount 2000 > 500 kept
+    expect(text).not.toContain('100') // amount 100 filtered out
+    expect(text).not.toContain('50') // amount 50 filtered out
+  })
+})
+
+describe('aiFindAnomalies', () => {
+  it('flags a numeric outlier over the scanned rows', async () => {
+    const api = makeApi()
+    const result = await aiFindAnomalies(api, {})
+    expect(result.anomalies.length).toBeGreaterThan(0)
+    const amountAnomaly = result.anomalies.find((a) => a.field === 'amount')
+    expect(amountAnomaly?.value).toBe(2000) // the max in the sample
+    expect(amountAnomaly?.severity).toBe('medium')
+    expect(result.summary).toBeTruthy()
+  })
+
+  it('returns empty for an empty selection', async () => {
+    const api = makeApi()
+    const result = await aiFindAnomalies(api, { target: { kind: 'selection', rowIndices: [] } })
+    expect(result.anomalies).toEqual([])
+  })
+})