@svgrid/enterprise 2.2.1 → 2.3.0

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}

@@ -8,7 +8,8 @@ vi.mock('./export', () => ({
   },
 }))
 
-import { aiExport, setAIProvider, mockAIProvider } from './ai'
+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 }
@@ -46,6 +47,8 @@ beforeEach(() => {
   calls.length = 0
   setLicenseKey('SVENTERPRISE-DEV-TEST')
   setAIProvider(mockAIProvider)
+  // aiExport delegates to the registered engine - here the mocked exportGrid.
+  registerExportProvider(exportGrid)
 })
 
 describe('aiExport - the demo 203 "grouped PDF" query', () => {

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

@@ -17,7 +17,8 @@ vi.mock('./export-serialize', async (importOriginal) => {
   return { ...actual, downloadBlobFile: () => {}, downloadTextFile: () => {} }
 })
 
-import { aiExport, setAIProvider, mockAIProvider } from './ai'
+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)
@@ -70,6 +71,8 @@ beforeEach(() => {
   captured.parts = {}
   setLicenseKey('SVENTERPRISE-DEV-TEST')
   setAIProvider(mockAIProvider)
+  // aiExport is free (grid) and delegates the real write to enterprise's engine.
+  registerExportProvider(exportGrid)
 })
 
 describe('aiExport - "export orders over $300" (xlsx default)', () => {

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

@@ -12,7 +12,8 @@ vi.mock('./export-serialize', async (importOriginal) => {
   }
 })
 
-import { aiExport, aiFindAnomalies, setAIProvider, mockAIProvider } from './ai'
+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 }
@@ -44,6 +45,9 @@ 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)
 })
 afterEach(() => setAIProvider(null))
 

package/src/alerts/alert-engine-attach.ts

@@ -0,0 +1,165 @@
+/**
+ * Headless glue between the pure engine and the running grid.
+ *
+ * The grid's `onCellValueChange` fires only for edits made through the grid, not
+ * for streaming feeds / server pushes / a programmatic `data = ...`. Alerts must
+ * react to all of those, so we observe changes by diffing snapshots (the same
+ * approach the grid's `attachAutoSavedView` uses for state). `applyAlertEvents`
+ * routes fired events
+ * to their side effects (toast, log) and returns the visual bits (conditional
+ * formats + cells to flash) for the caller to paint. The `<SvGridAlerts>`
+ * overlay drives this reactively via `$effect`; `attachAlertEngine` offers the
+ * same as a plain-JS interval poll for non-Svelte hosts.
+ */
+import type { ConditionalFormat } from '@svgrid/grid/format'
+import { toast } from '@svgrid/grid'
+import { alertStore } from './alert-store.svelte'
+import { toConditionalFormats } from './alert-formats'
+import { createAlertEngine, type AlertEngine } from './alert-engine'
+import type { AlertEvent, AlertRule } from './alert-types'
+
+export type FlashTarget = { rowId: string; columnId?: string }
+
+export type ApplyAlertOptions = {
+  /**
+   * Gate which fired events actually raise a toast. Every event is still logged
+   * (the badge/panel stay accurate) - this only suppresses the visible toast, so
+   * a busy live feed does not become a toast storm. Return `false` to skip the
+   * toast. Defaults to always-toast.
+   */
+  shouldToast?: (event: AlertEvent) => boolean
+}
+
+/**
+ * Perform the side effects of a batch of fired events and return the visual
+ * output: every event is recorded in the log (so the badge/panel stay accurate),
+ * `toast` actions raise a toast (subject to `shouldToast`), and
+ * `badge`/`highlight`/`cellFlash` actions yield formats + flash targets for the
+ * caller to apply to the grid.
+ *
+ * The whole batch lands in the log in ONE reactive write (`pushMany`) so a burst
+ * of firings from a single evaluation does not thrash the store.
+ */
+export function applyAlertEvents<TData = Record<string, unknown>>(
+  events: ReadonlyArray<AlertEvent>,
+  getRowId: (row: TData) => string,
+  options: ApplyAlertOptions = {},
+): { formats: ConditionalFormat<TData>[]; flashes: FlashTarget[] } {
+  if (events.length === 0) return { formats: [], flashes: [] }
+  alertStore.pushMany(events)
+  const allow = options.shouldToast
+  for (const event of events) {
+    if (event.actions.some((a) => a.kind === 'toast') && (!allow || allow(event))) {
+      toast[event.severity](event.message)
+    }
+  }
+  const flashes: FlashTarget[] = []
+  for (const event of events) {
+    if (event.rowId && event.actions.some((a) => a.kind === 'cellFlash')) {
+      flashes.push({ rowId: event.rowId, columnId: event.columnId })
+    }
+  }
+  return { formats: toConditionalFormats(events, getRowId), flashes }
+}
+
+export type AttachAlertOptions<TData> = {
+  rules: AlertRule[]
+  getRowId: (row: TData) => string
+  /** Read the grid's current rows. */
+  getData: () => ReadonlyArray<TData>
+  getValue?: (row: TData, columnId: string) => unknown
+  locale?: string | ReadonlyArray<string>
+  /** Merge alert-driven conditional formats into the grid. */
+  applyFormats?: (formats: ConditionalFormat<TData>[]) => void
+  /** Flash a cell (e.g. call `api.flashCells`). */
+  flashCell?: (target: FlashTarget) => void
+  /** Poll interval in ms (`0` disables polling - drive `tick()` yourself). */
+  intervalMs?: number
+}
+
+export type AlertAttachment<TData> = {
+  engine: AlertEngine<TData>
+  /** Run one evaluation pass against the latest data. */
+  tick(): void
+  /** Push new rules into the engine (e.g. after the user edits a rule). */
+  setRules(rules: AlertRule[]): void
+  detach(): void
+}
+
+/**
+ * Wire the engine to a data source. On the first pass it seeds edges silently
+ * from the current snapshot (so pre-existing matches do not fire); thereafter
+ * each pass fires newly-matching rows.
+ *
+ * Perf: cloning a previous snapshot is gated on `engine.needsPrev()`. For a rule
+ * set that is purely `dataChange`/aggregate (the common case) NO clone is taken -
+ * `engine.evaluate` re-checks the current rows and its edge memory (the `active`
+ * set) fires each row exactly once when it starts matching. Only `relativeChange`
+ * rules, which compare prev -> next, pay for a snapshot. This is the non-Svelte
+ * poll host; for the reactive overlay, `createAlertObserver` adds a scheduler and
+ * an O(changed) push path. Returns `detach()` to stop.
+ */
+export function attachAlertEngine<TData = Record<string, unknown>>(
+  opts: AttachAlertOptions<TData>,
+): AlertAttachment<TData> {
+  const engine = createAlertEngine<TData>({
+    rules: opts.rules,
+    getRowId: opts.getRowId,
+    getValue: opts.getValue,
+    locale: opts.locale,
+  })
+
+  let prev: TData[] | null = null
+  let seeded = false
+
+  const snapshot = (rows: ReadonlyArray<TData>): TData[] =>
+    rows.map((r) => (r && typeof r === 'object' ? ({ ...r } as TData) : r))
+
+  const flush = (events: AlertEvent[]) => {
+    if (events.length === 0) return
+    const { formats, flashes } = applyAlertEvents(events, opts.getRowId)
+    if (formats.length && opts.applyFormats) opts.applyFormats(formats)
+    if (opts.flashCell) flashes.forEach((f) => opts.flashCell?.(f))
+  }
+
+  const tick = () => {
+    const rows = opts.getData()
+    const needsPrev = engine.needsPrev()
+    let events: AlertEvent[]
+    if (!seeded) {
+      // Silent seed: arm edges from the current set, fire nothing.
+      engine.evaluate(rows)
+      events = []
+      seeded = true
+    } else if (needsPrev) {
+      events = engine.evaluateTransition(prev ?? [], rows)
+    } else {
+      // No rule reads prev - the edge set dedups, so no clone/diff is needed.
+      events = engine.evaluate(rows)
+    }
+    prev = needsPrev ? snapshot(rows) : null
+    flush(events)
+  }
+
+  const interval = opts.intervalMs ?? 400
+  let timer: ReturnType<typeof setInterval> | null = null
+  if (interval > 0) {
+    tick()
+    timer = setInterval(tick, interval)
+  }
+
+  return {
+    engine,
+    tick,
+    setRules(rules) {
+      engine.setRules(rules)
+      engine.reset()
+      prev = null
+      seeded = false
+    },
+    detach() {
+      if (timer) clearInterval(timer)
+      timer = null
+    },
+  }
+}

package/src/alerts/alert-engine.test.ts

@@ -0,0 +1,135 @@
+import { describe, expect, it } from 'vitest'
+import { createAlertEngine, renderTemplate } from './alert-engine'
+import type { AlertRule } from './alert-types'
+
+type Row = { id: string; price: number; region: string; status: string }
+
+const rows = (over: Partial<Row>[] = []): Row[] =>
+  [
+    { id: 'a', price: 120, region: 'EU', status: 'open' },
+    { id: 'b', price: 80, region: 'US', status: 'open' },
+  ].map((r, i) => ({ ...r, ...(over[i] ?? {}) }))
+
+const getRowId = (r: Row) => r.id
+
+const rule = (over: Partial<AlertRule> = {}): AlertRule => ({
+  id: 'r1',
+  name: 'High price',
+  enabled: true,
+  severity: 'warning',
+  scope: 'row',
+  predicate: { kind: 'cmp', column: 'price', op: 'greaterThan', value: 100 },
+  trigger: { type: 'dataChange' },
+  actions: [{ kind: 'toast', message: '{region} price is {value}' }],
+  createdAt: 0,
+  ...over,
+})
+
+const engine = (r: AlertRule[]) => createAlertEngine<Row>({ rules: r, getRowId, now: () => 1000 })
+
+describe('dataChange edge firing', () => {
+  it('fires once when a row starts matching, not on every pass', () => {
+    const e = engine([rule()])
+    const first = e.evaluate(rows())
+    expect(first).toHaveLength(1)
+    expect(first[0]!.rowId).toBe('a')
+    // Re-evaluating the same data must not re-fire.
+    expect(e.evaluate(rows())).toHaveLength(0)
+  })
+
+  it('re-arms after a row stops matching', () => {
+    const e = engine([rule()])
+    e.evaluate(rows())
+    // 'a' drops below threshold -> no fire, edge memory cleared.
+    expect(e.evaluate(rows([{ price: 90 }]))).toHaveLength(0)
+    // 'a' climbs back over -> fires again.
+    expect(e.evaluate(rows([{ price: 130 }]))).toHaveLength(1)
+  })
+
+  it('fires on transition when a row newly matches after an edit', () => {
+    const e = engine([rule()])
+    const prev = rows([{ price: 90 }]) // 'a' below threshold
+    e.evaluate(prev)
+    const events = e.evaluateTransition(prev, rows([{ price: 130 }]))
+    expect(events).toHaveLength(1)
+    expect(events[0]!.rowId).toBe('a')
+  })
+
+  it('respects disabled rules', () => {
+    const e = engine([rule({ enabled: false })])
+    expect(e.evaluate(rows())).toHaveLength(0)
+  })
+})
+
+describe('relativeChange firing', () => {
+  it('fires when a value jumps by more than the threshold', () => {
+    const r = rule({
+      id: 'r2',
+      trigger: { type: 'relativeChange', expr: { kind: 'percentChange', column: 'price', op: '>', value: 5, abs: true } },
+      predicate: { kind: 'const', value: true },
+    })
+    const e = engine([r])
+    const prev = rows()
+    e.evaluate(prev)
+    const events = e.evaluateTransition(prev, rows([{ price: 140 }])) // +16%
+    expect(events).toHaveLength(1)
+    expect(events[0]!.columnId).toBe('price')
+  })
+
+  it('gates relativeChange on the predicate', () => {
+    const r = rule({
+      id: 'r3',
+      trigger: { type: 'relativeChange', expr: { kind: 'changed', column: 'status' } },
+      predicate: { kind: 'cmp', column: 'status', op: 'equals', value: 'closed' },
+    })
+    const e = engine([r])
+    const prev = rows()
+    // status changes open -> pending: predicate (== closed) fails -> no fire.
+    expect(e.evaluateTransition(prev, rows([{ status: 'pending' }]))).toHaveLength(0)
+    // status changes open -> closed: fires.
+    expect(e.evaluateTransition(prev, rows([{ status: 'closed' }]))).toHaveLength(1)
+  })
+})
+
+describe('aggregate scope', () => {
+  it('fires one edge event when the whole-set predicate flips true', () => {
+    const r = rule({
+      id: 'agg',
+      scope: 'aggregate',
+      predicate: { kind: 'scalarCmp', left: { kind: 'agg', fn: 'sum', column: 'price' }, op: '>', right: { kind: 'lit', value: 250 } },
+    })
+    const e = engine([r])
+    expect(e.evaluate(rows())).toHaveLength(0) // 120+80 = 200
+    const fired = e.evaluate(rows([{ price: 200 }])) // 200+80 = 280
+    expect(fired).toHaveLength(1)
+    expect(fired[0]!.rowId).toBeUndefined()
+  })
+})
+
+describe('validateEdit', () => {
+  it('vetoes an edit that trips a preventEdit validation rule', () => {
+    const r = rule({
+      id: 'v',
+      trigger: { type: 'validation' },
+      predicate: { kind: 'cmp', column: 'price', op: 'lessThan', value: 0 },
+      actions: [{ kind: 'preventEdit', message: 'Price cannot be negative' }],
+    })
+    const e = engine([r])
+    const target = rows()[0]!
+    expect(e.validateEdit(target, 'price', -5).vetoed).toBe(true)
+    expect(e.validateEdit(target, 'price', 50).vetoed).toBe(false)
+  })
+})
+
+describe('renderTemplate', () => {
+  it('fills tokens from the firing context', () => {
+    expect(
+      renderTemplate('{rule}: {region} = {value}', {
+        rule: rule(),
+        row: { region: 'EU' },
+        columnId: 'price',
+        value: 120,
+      }),
+    ).toBe('High price: EU = 120')
+  })
+})

package/src/alerts/alert-engine.ts

@@ -0,0 +1,260 @@
+/**
+ * The pure alert engine - no DOM, no timers. It turns rules + data snapshots
+ * into `AlertEvent`s, with true-edge de-duplication so a `dataChange` rule fires
+ * once when a row starts matching (not on every re-evaluation while it keeps
+ * matching). The reactive/observing wrapper lives in `alert-engine-attach.ts`.
+ */
+import { evaluateChange, evaluatePredicate } from '../expressions/evaluate'
+import { collectColumnRefs } from '../expressions/parse'
+import type { EvalContext } from '../expressions/expression-types'
+import type { AlertEvent, AlertRule } from './alert-types'
+
+export type AlertEngineOptions<TData> = {
+  rules: AlertRule[]
+  getRowId: (row: TData) => string
+  /** Resolve a column id to a value (defaults to `row[id]`). */
+  getValue?: (row: TData, columnId: string) => unknown
+  locale?: string | ReadonlyArray<string>
+  /** Clock for `firedAt` (injectable for deterministic tests). */
+  now?: () => number
+}
+
+export type ValidateEditResult = {
+  vetoed: boolean
+  events: AlertEvent[]
+}
+
+export type AlertEngine<TData> = {
+  setRules(rules: AlertRule[]): void
+  getRules(): AlertRule[]
+  /** Full-snapshot pass: fires `dataChange`/`scheduled`/aggregate edges. */
+  evaluate(rows: ReadonlyArray<TData>): AlertEvent[]
+  /** Prev -> next pass: fires `relativeChange` plus `dataChange` edges. */
+  evaluateTransition(prev: ReadonlyArray<TData>, next: ReadonlyArray<TData>): AlertEvent[]
+  /** Would editing `(row, columnId) -> nextValue` trip a validation rule? */
+  validateEdit(row: TData, columnId: string, nextValue: unknown): ValidateEditResult
+  /**
+   * True iff some enabled rule reads a row's PREVIOUS value (a `relativeChange`
+   * trigger). When false, the observer can skip cloning prev-snapshots entirely
+   * - the hot-path saver for `dataChange`/aggregate-only rule sets over big feeds.
+   */
+  needsPrev(): boolean
+  /** True iff some enabled rule is aggregate-scope (needs the full row set). */
+  needsFullSet(): boolean
+  /** Forget edge memory so matching rows can fire again. */
+  reset(): void
+}
+
+const AGG_ROW_KEY = '*'
+
+/** Fill message-template tokens from the firing context. */
+export function renderTemplate(
+  template: string,
+  ctx: { rule: AlertRule; row?: Record<string, unknown>; columnId?: string; value?: unknown },
+): string {
+  const { rule, row, columnId, value } = ctx
+  return template
+    .replace(/\{rule\}/g, rule.name)
+    .replace(/\{severity\}/g, rule.severity)
+    .replace(/\{column\}/g, columnId ?? '')
+    .replace(/\{value\}/g, value == null ? '' : String(value))
+    .replace(/\{row\.([\w$]+)\}/g, (_m, key: string) => fmt(row?.[key]))
+    .replace(/\{([\w$]+)\}/g, (m, key: string) => (row && key in row ? fmt(row[key]) : m))
+}
+
+function fmt(v: unknown): string {
+  return v == null ? '' : String(v)
+}
+
+function defaultMessage(rule: AlertRule): string {
+  return rule.name
+}
+
+export function createAlertEngine<TData = Record<string, unknown>>(
+  options: AlertEngineOptions<TData>,
+): AlertEngine<TData> {
+  let rules = options.rules
+  const getValue = options.getValue
+  const now = options.now ?? (() => Date.now())
+  // Edge memory: keys currently satisfying a `dataChange`/aggregate predicate.
+  const active = new Set<string>()
+
+  const ctxFor = (row: TData, rows?: ReadonlyArray<TData>, prev?: TData): EvalContext<TData> => ({
+    row,
+    prev,
+    rows,
+    getValue,
+    locale: options.locale,
+  })
+
+  const val = (row: TData, columnId?: string): unknown =>
+    columnId == null
+      ? undefined
+      : getValue
+        ? getValue(row, columnId)
+        : (row as Record<string, unknown>)?.[columnId]
+
+  // A representative column for the message `{value}`/`{column}` tokens: the
+  // rule's explicit target, else the first column its predicate references.
+  const primaryColumn = (rule: AlertRule): string | undefined =>
+    rule.columns?.[0] ?? collectColumnRefs(rule.predicate)[0]
+
+  function buildEvent(
+    rule: AlertRule,
+    opts: { row?: TData; rowId?: string; columnId?: string; value?: unknown },
+  ): AlertEvent {
+    const msgAction = rule.actions.find((a) => a.message)
+    const template = msgAction?.message ?? defaultMessage(rule)
+    const message = renderTemplate(template, {
+      rule,
+      row: opts.row as Record<string, unknown> | undefined,
+      columnId: opts.columnId,
+      value: opts.value,
+    })
+    return {
+      ruleId: rule.id,
+      ruleName: rule.name,
+      severity: rule.severity,
+      scope: rule.scope,
+      triggerType: rule.trigger.type,
+      rowId: opts.rowId,
+      columnId: opts.columnId,
+      value: opts.value,
+      message,
+      actions: rule.actions,
+      firedAt: now(),
+    }
+  }
+
+  /** Aggregate-scope: one edge event when the predicate over all rows flips true. */
+  function evaluateAggregate(rule: AlertRule, rows: ReadonlyArray<TData>): AlertEvent[] {
+    const key = `${rule.id}::${AGG_ROW_KEY}`
+    const first = rows[0]
+    const matches = first != null && evaluatePredicate(rule.predicate, ctxFor(first, rows))
+    if (matches && !active.has(key)) {
+      active.add(key)
+      return [buildEvent(rule, {})]
+    }
+    if (!matches) active.delete(key)
+    return []
+  }
+
+  /** Row/cell dataChange: edge event when a row newly satisfies the predicate. */
+  function evaluateDataChangeRow(
+    rule: AlertRule,
+    row: TData,
+    rows: ReadonlyArray<TData>,
+  ): AlertEvent[] {
+    const id = options.getRowId(row)
+    const key = `${rule.id}::${id}`
+    const matches = evaluatePredicate(rule.predicate, ctxFor(row, rows))
+    if (matches && !active.has(key)) {
+      active.add(key)
+      const source = primaryColumn(rule)
+      // Expose the column on the event only for cell scope; still surface its
+      // value for the message tokens regardless of scope.
+      const columnId = rule.scope === 'cell' ? source : undefined
+      return [buildEvent(rule, { row, rowId: id, columnId, value: val(row, source) })]
+    }
+    if (!matches) active.delete(key)
+    return []
+  }
+
+  /** relativeChange: fires whenever the change test holds for a prev->next row. */
+  function evaluateRelative(
+    rule: AlertRule,
+    row: TData,
+    prev: TData | undefined,
+    rows: ReadonlyArray<TData>,
+  ): AlertEvent[] {
+    if (rule.trigger.type !== 'relativeChange' || prev == null) return []
+    const changed = evaluateChange(rule.trigger.expr, ctxFor(row, rows, prev))
+    if (!changed) return []
+    // Gate on the predicate too, so "price jumped AND price > 100" is expressible.
+    if (!evaluatePredicate(rule.predicate, ctxFor(row, rows, prev))) return []
+    const columnId = rule.trigger.expr.column
+    return [
+      buildEvent(rule, {
+        row,
+        rowId: options.getRowId(row),
+        columnId,
+        value: val(row, columnId),
+      }),
+    ]
+  }
+
+  function activeRules(): AlertRule[] {
+    return rules.filter((r) => r.enabled)
+  }
+
+  return {
+    setRules(next) {
+      rules = next
+    },
+    getRules() {
+      return rules
+    },
+    needsPrev() {
+      return rules.some((r) => r.enabled && r.trigger.type === 'relativeChange')
+    },
+    needsFullSet() {
+      return rules.some((r) => r.enabled && r.scope === 'aggregate')
+    },
+    reset() {
+      active.clear()
+    },
+
+    evaluate(rows) {
+      const events: AlertEvent[] = []
+      for (const rule of activeRules()) {
+        if (rule.scope === 'aggregate') {
+          events.push(...evaluateAggregate(rule, rows))
+        } else if (rule.trigger.type === 'dataChange' || rule.trigger.type === 'scheduled') {
+          for (const row of rows) events.push(...evaluateDataChangeRow(rule, row, rows))
+        }
+      }
+      return events
+    },
+
+    evaluateTransition(prev, next) {
+      const prevById = new Map<string, TData>()
+      for (const row of prev) prevById.set(options.getRowId(row), row)
+      const events: AlertEvent[] = []
+      for (const rule of activeRules()) {
+        if (rule.scope === 'aggregate') {
+          events.push(...evaluateAggregate(rule, next))
+          continue
+        }
+        for (const row of next) {
+          const before = prevById.get(options.getRowId(row))
+          if (rule.trigger.type === 'relativeChange') {
+            events.push(...evaluateRelative(rule, row, before, next))
+          } else if (rule.trigger.type === 'dataChange') {
+            events.push(...evaluateDataChangeRow(rule, row, next))
+          }
+        }
+      }
+      return events
+    },
+
+    validateEdit(row, columnId, nextValue) {
+      const candidate = { ...(row as Record<string, unknown>), [columnId]: nextValue } as TData
+      const events: AlertEvent[] = []
+      let vetoed = false
+      for (const rule of activeRules()) {
+        if (rule.trigger.type !== 'validation') continue
+        if (!evaluatePredicate(rule.predicate, ctxFor(candidate))) continue
+        events.push(
+          buildEvent(rule, {
+            row: candidate,
+            rowId: options.getRowId(candidate),
+            columnId,
+            value: nextValue,
+          }),
+        )
+        if (rule.actions.some((a) => a.kind === 'preventEdit')) vetoed = true
+      }
+      return { vetoed, events }
+    },
+  }
+}