@toclocoinc/lattice-grid 1.58.0 → 1.60.0

package/lattice-grid.d.ts

@@ -1,5 +1,5 @@
 /*!
- * Lattice Grid 1.58.0, type declarations
+ * Lattice Grid 1.60.0, type declarations
  * Copyright (c) 2026 TOCLOCO Inc. All rights reserved.
  * https://latticegrid.dev
  */
@@ -541,6 +541,125 @@ export interface ColumnValueSpec {
   quickFilterText?: (p: ValueParams) => string;
 }
 
+/**
+ * One label/value line in a {@link TooltipSpec}.
+ *
+ * Both halves are written as text by the grid, whatever they contain.
+ */
+export interface TooltipRow {
+  /** The line's label, drawn on the leading edge. */
+  label?: unknown;
+  /** The line's value, drawn on the trailing edge. */
+  value?: unknown;
+}
+
+/**
+ * Structured tooltip content the grid renders for you (BACKLOG-0001204): a
+ * heading, a list of label/value lines, and a closing note.
+ *
+ * Every field is written as **text**, never as markup, so a spec built out of
+ * row values needs no escaping and cannot become HTML by accident. Return
+ * `{ html }` from `render` when markup is genuinely wanted.
+ */
+export interface TooltipSpec {
+  /** A heading for the tooltip. */
+  title?: unknown;
+  /** Label/value lines, in order. */
+  rows?: TooltipRow[];
+  /** A closing note under the lines, drawn quieter than them. */
+  note?: unknown;
+}
+
+/**
+ * What a tooltip's `render` and `mount` are given: the same identification
+ * `cell:clicked` carries, plus the cell element itself and the grid.
+ *
+ * Resolved from the DOM at the moment the tooltip opens rather than when the
+ * pointer arrived, so a pooled row re-used in between names the row it is
+ * showing now.
+ */
+export interface TooltipParams {
+  /** The row under the pointer or the keyboard cursor. */
+  row: Row;
+  /** That row's key. */
+  key: string;
+  /** Its display index. */
+  index: number;
+  /** The column the cell belongs to. */
+  colId: string;
+  /** The resolved column. */
+  column: Column;
+  /** The cell's value. */
+  value: unknown;
+  /** The cell's formatted text. */
+  text: string;
+  /** The cell element the tooltip is anchored to. */
+  cell: HTMLElement;
+  /** The grid. */
+  grid: Grid;
+}
+
+/**
+ * A rich, keyboard-accessible tooltip for a column's cells (BACKLOG-0001204) —
+ * the object form of `cell.tooltip`, drawn by the grid rather than handed to
+ * the browser as a native `title`.
+ *
+ * Shown after a delay (`tooltip.delay`, 400ms by default) on hover *and* on
+ * keyboard focus; the cell points at it with `aria-describedby`; it can be
+ * hovered without closing and Escape dismisses it (WCAG 2.2 AA, 1.4.13). It
+ * closes on scroll, because rows are pooled and a bubble left open would be
+ * anchored to a node that is now showing a different row.
+ */
+export interface ColumnTooltipSpec {
+  /**
+   * Produce the content. Four shapes, and the difference between the last two
+   * is a security property rather than a style choice:
+   *
+   * - an **element** — your own DOM, attached as it is;
+   * - a **{@link TooltipSpec}** — `{ title, rows, note }`, rendered as text;
+   * - **`{ html }`** — the only wrapper that inserts markup, scrubbed of script
+   *   the same way `allowUnsafeTemplates` output is;
+   * - a **string** — *always* text, never markup.
+   *
+   * The last rule is what makes `render: (p) => p.value` safe: a value comes
+   * from row data, and data must not be able to promote itself to HTML.
+   */
+  render?: (params: TooltipParams) => HTMLElement | TooltipSpec | { html: string } | string | null | undefined;
+  /**
+   * Put live content in the tooltip — a sparkline, a KPI tile — by calling into
+   * a module bundle your application loaded. The grid core never imports a
+   * module, so anything live is mounted here by you.
+   */
+  mount?: (el: HTMLElement, params: TooltipParams) => void;
+  /**
+   * Tear down whatever `mount` built. Called every time the tooltip closes, so
+   * nothing keeps running behind a hidden box.
+   */
+  unmount?: (el: HTMLElement) => void;
+}
+
+/**
+ * Grid-level defaults for the rich cell tooltip (BACKLOG-0001204), set once for
+ * every column rather than repeated on each.
+ *
+ * Defaults only: it switches nothing on. A tooltip exists because a column
+ * declares `cell.tooltip`, and a grid whose columns declare none has no
+ * tooltips whatever is set here.
+ */
+export interface TooltipConfig {
+  /**
+   * How long the pointer or the keyboard cursor must rest on a cell before the
+   * tooltip is built, in milliseconds. 400 by default.
+   *
+   * The delay is why a pointer sweeping across the grid mounts nothing: a
+   * tooltip that built a chart on every cell it crossed would be unusable, and
+   * `0` asks for exactly that.
+   */
+  delay?: number;
+  /** How wide the tooltip may grow. A number is pixels; a string is used as written. */
+  maxWidth?: number | string;
+}
+
 export interface ColumnCellSpec {
   decoration?: DecorationName | DecorationSpec;
   variant?: VariantSpec;
@@ -551,7 +670,15 @@ export interface ColumnCellSpec {
   class?: string | string[] | ((p: CellParams) => string | string[]);
   classWhen?: Record<string, string | ((p: CellParams) => boolean)>;
   style?: CellStyle | ((p: CellParams) => CellStyle);
-  tooltip?: string | ((p: CellParams) => string);
+  /**
+   * A tooltip for this column's cells.
+   *
+   * A string or a function is the plain-text case and becomes the browser's own
+   * `title`. An object is a {@link ColumnTooltipSpec}: a tooltip the grid draws,
+   * which can carry structure, markup or live content and which a keyboard user
+   * can reach (BACKLOG-0001204).
+   */
+  tooltip?: string | ((p: CellParams) => string) | ColumnTooltipSpec;
   align?: Align;
   /**
    * Vertical alignment of this column's cell content, overriding the grid-level
@@ -635,6 +762,31 @@ export interface ColumnLayoutSpec {
    * the grid only when nothing else is fixed.
    */
   width?: number | string;
+  /**
+   * `'content'` sizes the column to what it is actually showing, the way
+   * `columns.autoSize()` does, and keeps doing it: on the first paint, and
+   * again whenever the rows change, the columns are shown, hidden, reordered
+   * or pinned, or the grid is resized. It is the declarative form of the
+   * imperative call, so a host no longer has to re-issue `autoSize()` after
+   * every data change.
+   *
+   * Sized to the *visible* content, not to the widest value in the dataset:
+   * the measurement reads the rows the renderer has mounted, because measuring
+   * a million rows is not a plan. It measures the heading too, so a column
+   * whose title is longer than its values widens to show the title.
+   *
+   * **Anything the caller states outranks it.** A declared `width` wins, and
+   * so does a width the user drags to — a resize is recorded as a `width`, so
+   * from that moment the column is that wide and the fit no longer touches it.
+   * `min` and `max` clamp the fitted width as they clamp any other. `flex` is
+   * resolved before this and wins, the two being contradictory instructions:
+   * `flex` fits the column to the *grid*, this fits it to the *content*.
+   *
+   * Not re-measured on scroll, deliberately: different rows mount as the grid
+   * scrolls, and re-fitting against them would make the columns jitter under
+   * the reader.
+   */
+  fit?: 'content';
   min?: number;
   max?: number;
   flex?: number;
@@ -928,6 +1080,16 @@ export interface Column {
    * the way `align` is. Omitted, the column follows the grid default.
    */
   verticalAlign?: VAlign;
+  /**
+   * When this leaf column is shown, the same union `ColumnGroup` declares
+   * (BACKLOG-0001279). A leaf reads its own `showWhen` exactly as a group
+   * reads its own — `open`/`closed` tie the leaf to an ancestor group's
+   * collapsed state, `always` (the default) shows it regardless — so tying a
+   * leaf's visibility to a group's open/closed state does not require
+   * wrapping it in a `ColumnGroup` of its own just to hold this setting; a
+   * wrapper is for grouping columns, not for this.
+   */
+  showWhen?: 'open' | 'closed' | 'always';
   /** How the column leaves the grid, where that differs from how it is shown. */
   export?: ColumnExportSpec;
   /** Whether the user may group by this column from the interface. */
@@ -1177,6 +1339,38 @@ export interface RemoteRequest {
   sort: SortEntry[];
   context: unknown;
   signal: AbortSignal;
+  /**
+   * The `where` predicates in force, as a runtime the source can evaluate but
+   * not mutate (BACKLOG-0001268). Present **only when at least one predicate is
+   * registered**, so a grid that does not use `where` sends the request it
+   * always sent, field for field.
+   *
+   * A host `fetch` may ignore it, and every existing one does: it is a host
+   * function, so there is nothing to serialise and no engine can evaluate it —
+   * `passes` is dropped by `JSON.stringify` the way `signal` already is. It is
+   * carried for the one reader that can act on it, `createPushdownSource`,
+   * which runs it as the residual over the matching set when that set is under
+   * `whereRowLimit`. The `{ condition }` twin remains the route that narrows
+   * the fetch itself, at any size.
+   */
+  where?: WhereRuntime;
+}
+
+/**
+ * The `where` predicates in force, as a source sees them (BACKLOG-0001268).
+ *
+ * A snapshot rather than the model, so a source can evaluate the predicates but
+ * cannot register or remove one through it.
+ */
+export interface WhereRuntime {
+  /** Whether any predicate is registered at all. */
+  active: boolean;
+  /** The registered names, in registration order — for diagnostics. */
+  names: string[];
+  /** Bumped on every registration or removal, so a cache key can track it. */
+  version: number;
+  /** Does this row survive every registered predicate? */
+  passes(row: unknown, key?: string): boolean;
 }
 
 export interface RemoteResult {
@@ -1874,6 +2068,16 @@ export interface GridConfig {
    */
   verticalAlign?: VAlign;
 
+  /**
+   * Defaults for the rich cell tooltip (BACKLOG-0001204).
+   *
+   * The tooltip itself is declared per column, on `cell.tooltip`; this only
+   * carries the settings that are a house style rather than a per-column
+   * decision. It switches nothing on: a column with no `cell.tooltip` has no
+   * tooltip whatever is set here.
+   */
+  tooltip?: TooltipConfig;
+
   /**
    * Keep the scroll viewport's scrollbars visible (BACKLOG-0000990).
    *
@@ -2330,7 +2534,7 @@ export interface GridConfig {
    * markup `data-lat-group-toggle` and a click on it expands or collapses the
    * group, or call `params.toggle()` from a node you built yourself.
    */
-  groupRenderer?(params: GroupRowParams): string | Node | void;
+  groupRenderer?: (params: GroupRowParams) => string | Node | void;
   /**
    * Which groups start expanded, before anyone has opened or closed one.
    *
@@ -2376,13 +2580,13 @@ export interface GridConfig {
    * should *not* be part of the data, use `pinnedTopRows`.
    */
   fullWidth?: {
-    when(row: Row): boolean;
+    when: (row: Row) => boolean;
     /**
      * Return a string for text, or a node for content. Return nothing and
      * write into `params.element` yourself. An HTML string is deliberately not
      * accepted: see `allowUnsafeTemplates` for that decision elsewhere.
      */
-    render(params: FullWidthParams): string | Node | void;
+    render: (params: FullWidthParams) => string | Node | void;
   };
   /** Total what the filters left rather than the whole set. */
   totalFilteredOnly?: boolean;
@@ -2574,10 +2778,12 @@ export interface GridConfig {
     exportName?: string;
     /**
      * Put the native annotation tools — pen, arrow, rectangle, highlighter — on
-     * the rail. Off by default; each is a real toggle button that shows pressed
-     * while it is the tool in use and turns off when pressed again. The tools
-     * also appear automatically for the duration of a presentation, so this is
-     * only needed to keep them available outside one.
+     * the rail. Each is a real toggle button that shows pressed while it is the
+     * tool in use and turns off when pressed again. Three states, not two:
+     * `true` opts in and keeps the tools on the rail always, presentation or
+     * not; `false` opts OUT and the tools are never added, not even for a
+     * presentation; omitted keeps the default, where the tools are off until a
+     * presentation starts, appear for its duration, and leave when it ends.
      */
     annotate?: boolean;
   };
@@ -2648,7 +2854,7 @@ export interface GridConfig {
    * host's, and owns the model, the key and the privacy decision.
    */
   ai?: {
-    ask(p: {
+    ask: (p: {
     /** The full text to send: the schema description and the question together. */
     prompt: string;
     /** The grid's schema as data: columns, types and operators. No row values. */
@@ -2658,7 +2864,7 @@ export interface GridConfig {
     /** What the user typed. */
     message: string;
     context?: unknown;
-  }): Promise<unknown>;
+  }) => Promise<unknown>;
     schemaOptions?: object;
     context?: unknown;
     element?: HTMLElement;
@@ -3011,11 +3217,31 @@ export interface PushdownAdapter {
 export interface PushdownPlan {
   /** The query the adapter was given. */
   pushed: RemoteRequest;
-  /** What the grid applied afterwards. */
-  residual: { filters: object | null; sort: SortEntry[] | null; quick: string };
+  /**
+   * What the grid applied afterwards. `where` is the host predicate runtime
+   * when one survived the `whereRowLimit` gate, and `null` when none was
+   * registered or the gate refused it (BACKLOG-0001268).
+   */
+  residual: {
+    filters: object | null;
+    sort: SortEntry[] | null;
+    quick: string;
+    where: WhereRuntime | null;
+    /**
+     * Whether the rows the residual runs over are the whole matching set rather
+     * than a fetched fraction (BACKLOG-0001268). Set by the source when it hands
+     * the residual to `applyResidual`; absent on the plan `lastPlan()` reports,
+     * because it is a property of one fetch's result, not of the plan.
+     *
+     * When true the counts the residual produces are whole-dataset counts, so
+     * the page-relative `where` warning is suppressed. Absent counts as not
+     * whole: silence has to be earned.
+     */
+    whole?: boolean;
+  };
   /** Whether the whole result had to be fetched rather than a window. */
   needsAll: boolean;
-  /** Which parts could not be pushed: `filter`, `sort`, `quick`. */
+  /** Which parts could not be pushed: `filter`, `sort`, `quick`, `where`. */
   unpushed: string[];
   /**
    * Whether the whole result was fetched because `fullDataset` is on, rather
@@ -3146,6 +3372,26 @@ export interface PushdownSourceConfig {
    * no-residual short-return warning.
    */
   allowPartialResults?: boolean;
+  /**
+   * The most rows the source will fetch and hold in order to run a twinless
+   * `where` predicate as the residual (BACKLOG-0001268). Defaults to `50_000`,
+   * the same anchor as the grid's `workerThreshold` — the size at which this
+   * codebase already judges a dataset big enough to need different handling.
+   *
+   * A `where` predicate is a host function no engine can evaluate, so the only
+   * way to honour one is to fetch every matching row and filter here. That
+   * silently turns a windowed grid into a whole-dataset download, which is the
+   * thing a pushdown source exists to avoid. So it is a gate, not a free
+   * upgrade: at or past this many matching rows the predicate is **refused and
+   * warned about** — the rows it would exclude stay on screen — rather than the
+   * download being taken on the host's behalf. An adapter that reports no row
+   * total counts as over the limit, because guessing the other way is guessing
+   * your way into the download.
+   *
+   * Raise it when you want that download; the `{ condition }` twin is the route
+   * that narrows the fetch itself and works at any size.
+   */
+  whereRowLimit?: number;
 }
 
 export interface StatisticsApi {
@@ -4227,6 +4473,20 @@ export type EventName =
   /* Cells and editing */
   | 'cell:changed' | 'cell:pending' | 'cell:confirmed' | 'cell:reverted' | 'cell:conflict'
   | 'cell:clicked' | 'cell:dblclicked' | 'cell:contextmenu'
+  /* The pointer entering and leaving a cell (BACKLOG-0001203). Announcements
+   * only, carrying what `cell:clicked` carries plus the cell element as
+   * `target`. A host cannot wire these itself: rows and cells are pooled and
+   * re-used as the grid scrolls, so a listener bound to a cell node fires for
+   * whichever row occupies it next. Nothing in the grid is gated on hover, so
+   * a keyboard user reaches everything a pointer does. */
+  | 'cell:mouseover' | 'cell:mouseout'
+  /* A pointer press and release on a cell (BACKLOG-0001272), the same
+   * convention as the hover pair above: announcements only, carrying what
+   * `cell:clicked` carries plus the cell element as `target`. A host cannot
+   * wire these itself for the same reason it cannot wire the hover pair —
+   * rows and cells are pooled and re-used as the grid scrolls, so a listener
+   * bound to a cell node fires for whichever row occupies it next. */
+  | 'cell:mousedown' | 'cell:mouseup'
   | 'cell:edit:start' | 'cell:edit:end' | 'row:edit:start' | 'row:edit:end'
   | 'row:clicked' | 'row:dblclicked'
   | 'row:pending' | 'row:confirmed' | 'row:reverted' | 'row:conflict'
@@ -4848,6 +5108,13 @@ export interface WhereOptions {
    * of filtering a page client-side. It must be implied by the predicate: the
    * grid ANDs both, so a twin wider than the function costs only time, while one
    * narrower than it hides rows the function would have kept.
+   *
+   * **The twin is what works at any size.** Without one, a pushdown source can
+   * still run the function — but only as the residual over the whole matching
+   * set, so it does so only while that set is under `whereRowLimit` (default
+   * `50_000`) and refuses loudly past it (BACKLOG-0001268). A paged or remote
+   * source cannot run it at all and warns at registration. The twin is pushed
+   * to the engine, so it narrows the fetch itself and none of that applies.
    */
   condition?: FilterSet;
 }
@@ -5869,8 +6136,6 @@ export interface DiffApi {
   report(): Record<string, unknown>;
 }
 
-export type PermissionLevel = 'hidden' | 'read' | 'write' | 'writeOnly';
-
 export interface PermissionsApi {
   levelOf(column: string | ResolvedColumn): PermissionLevel;
   isHidden(column: string | ResolvedColumn): boolean;
@@ -7432,2829 +7697,3 @@ export interface Chart {
   toCSV(): string;
   destroy(): void;
 }
-
-declare module 'lattice-grid/modules/charts' {
-  /** Every type name `createChart` accepts. */
-  export const TYPES: readonly ChartType[];
-  /** The built-in colour schemes, by name. */
-  export const SCHEMES: Readonly<Record<string, readonly string[]>>;
-  export const PALETTE: readonly string[];
-  export function createChart(spec: ChartSpec): Chart;
-  /**
-   * Chart a selected cell range. Derives the chart from the range's shape — a
-   * leading text column becomes the categories, the numeric columns become the
-   * measures — and returns the live chart, or null when the range has nothing
-   * to measure. Respects hidden and unreadable columns. The type is a sensible
-   * default the caller can change with `chart.update({ type })`.
-   */
-  export function chartRange(
-    grid: Grid,
-    opts: {
-      container: Element | string;
-      range?: CellRange;
-      type?: ChartType;
-    } & Partial<ChartSpec>,
-  ): Chart | null;
-  /** Would {@link chartRange} draw something for the grid's current selection? */
-  export function canChartRange(grid: Grid, opts?: { range?: CellRange }): boolean;
-  /**
-   * Decide what a chart of a range should be, without drawing it: the type, the
-   * category column, the measure columns, and a `spec` ready for `createChart`
-   * — or a `reason` naming why the range cannot be charted.
-   */
-  export function deriveRangeSpec(
-    grid: Grid,
-    opts?: { range?: CellRange; type?: ChartType },
-  ): {
-    spec: ChartSpec | null;
-    type: ChartType | null;
-    x: string | null;
-    measures: string[];
-    columns: string[];
-    reason: string | null;
-  };
-  /**
-   * Turn a fitted regression model into diagnostic chart specs ready for
-   * `createChart` (BACKLOG-0000812). Pass a precomputed `model`, or a `spec` to
-   * fit one over the grid, and the `fitted` and `residual` fit-shadow column ids
-   * the residual and QQ plots draw over.
-   *
-   * The presets that map onto grid columns come back as drawable specs: `fit`
-   * (the fit line with its confidence band), `residualsFitted`, `qq`, and
-   * `multicollinearity` (a correlogram over the predictors, with the model's
-   * `vif` alongside). The three that need a per-row or per-coefficient quantity
-   * the grid has no column for — `scaleLocation`, `residualsLeverage`,
-   * `coefficientForest` — come back with a null `spec` and a stable `reason`,
-   * rather than silently dropped.
-   */
-  export function regressionPlots(
-    grid: Grid,
-    opts?: {
-      model?: RegressionModel;
-      spec?: RegressionSpec;
-      fitted?: string;
-      residual?: string;
-      rows?: object[] | ((grid: Grid) => object[]);
-      confidence?: number;
-    },
-  ): {
-    model: RegressionModel | null;
-    plots: Record<
-      'fit' | 'residualsFitted' | 'qq' | 'multicollinearity'
-        | 'scaleLocation' | 'residualsLeverage' | 'coefficientForest',
-      {
-        spec: ChartSpec | null;
-        reason: string | null;
-        vif?: number[] | null;
-        coefficients?: RegressionCoefficient[] | null;
-      }
-    >;
-  };
-  export function registerScheme(name: string, colours: readonly string[]): void;
-  export function resolveScheme(spec?: object): object;
-  export function schemeNames(): string[];
-  export function setDefaultScheme(name: string): void;
-  /**
-   * The definition an extension chart type registers (BACKLOG-0000886). `draw`
-   * receives the base drawing context — `plot`, `bound`, `groups`, `scheme`,
-   * `typography`, `fontSize`, `labels`, `grid`, `spec`, `doc` — plus
-   * `ctx.helpers`, the base's own toolkit of primitives (element factory, scales,
-   * axes, mark pool, distribution kernels), and appends its marks to the layer
-   * groups. `bind` optionally supplies the bound data (default: the by-series
-   * binder); `freeform` lays the chart out without axis gutters; `labelled`
-   * declares that `labels` applies.
-   */
-  interface ChartTypeDefinition {
-    draw: (ctx: object) => object;
-    bind?: (grid: Grid, spec: ChartSpec) => object;
-    freeform?: boolean;
-    labelled?: boolean;
-  }
-  /**
-   * Register an extension chart type so `createChart({ type })` can draw it
-   * (BACKLOG-0000886). Extension types ship as their own opt-in modules, so the
-   * base charts bundle does not grow for a type a caller never imports — you pay
-   * only for the charts you use.
-   */
-  export function registerChartType(name: string, def: ChartTypeDefinition): void;
-  /** Every registered extension chart-type name, in registration order. */
-  export function registeredChartTypes(): string[];
-  export { Chart };
-}
-
-declare module 'lattice-grid/modules/chart-ridgeline' {
-  /**
-   * The ridgeline (joy plot) extension chart type (BACKLOG-0000886). Importing
-   * this module registers `ridgeline` with the base charts module; the base
-   * bundle does not include it unless a caller imports it. Draws one
-   * kernel-density ridge per category (`x`), stacked and overlapping, over the
-   * distribution of a measure (`y`); `spec.overlap` sets the vertical overlap.
-   */
-  export function drawRidgeline(ctx: object): object;
-  export default drawRidgeline;
-}
-
-declare module 'lattice-grid/modules/chart-calendar' {
-  /**
-   * The calendar-heatmap extension chart type (BACKLOG-0000886). Importing this
-   * module registers `calendar`. Draws value-by-day as a GitHub-style grid: `x`
-   * is a date column, `y` the measure summed per day.
-   */
-  export function drawCalendar(ctx: object): object;
-  export default drawCalendar;
-}
-
-declare module 'lattice-grid/modules/chart-splom' {
-  /**
-   * The scatter-plot-matrix (SPLOM) extension chart type (BACKLOG-0000886).
-   * Importing this module registers `splom`. Crosses every pair of the numeric
-   * `columns` (2–6) as a matrix of scatters, naming each variable on the
-   * diagonal.
-   */
-  export function drawSplom(ctx: object): object;
-  /** The SPLOM binding: reads the numeric `columns` off the grid's visible rows. */
-  export function bindSplom(grid: Grid, spec: object): object;
-  export default drawSplom;
-}
-
-declare module 'lattice-grid/modules/chart-hexbin' {
-  /**
-   * The hexbin / 2D-density extension chart type (BACKLOG-0000886). Importing
-   * this module registers `hexbin`. Bins `x`/`y` points into hexagons shaded by
-   * count, so a large scatter reads as a density field rather than overplotting.
-   */
-  export function drawHexbin(ctx: object): object;
-  /** The hexbin binding: reads the numeric `x` and `y` columns off the grid's rows. */
-  export function bindHexbin(grid: Grid, spec: object): object;
-  export default drawHexbin;
-}
-
-declare module 'lattice-grid/modules/chart-roc' {
-  /**
-   * The ROC / PR / calibration extension chart type (BACKLOG-0000886). Importing
-   * this module registers `roc`. `spec.curve` chooses `'roc'` (default, with the
-   * chance diagonal and AUC), `'pr'`, or `'calibration'`; `label` is the outcome
-   * column (positive when truthy or equal to `spec.positive`), `score` the model
-   * score.
-   */
-  export function drawRoc(ctx: object): object;
-  /** The ROC binding: reads the outcome and score off the grid's rows. */
-  export function bindRoc(grid: Grid, spec: object): object;
-  export default drawRoc;
-}
-
-declare module 'lattice-grid/modules/chart-fan' {
-  /**
-   * The fan / forecast extension chart type (BACKLOG-0000886). Importing this
-   * module registers `fan`. Draws `y` (history) as a solid line, `forecast` as a
-   * dashed continuation, and the `lower`/`upper` interval as a widening band.
-   */
-  export function drawFan(ctx: object): object;
-  /** The fan binding: reads the history, forecast and interval columns in row order. */
-  export function bindFan(grid: Grid, spec: object): object;
-  export default drawFan;
-}
-
-declare module 'lattice-grid/modules/chart-decomposition' {
-  /**
-   * The seasonal-decomposition panel extension chart type (BACKLOG-0000886),
-   * companion to the `tsTrend`/`tsSeasonal`/`tsResidual` shadow columns.
-   * Importing this module registers `decomposition`. Draws a stacked panel per
-   * named component column (`observed`/`trend`/`seasonal`/`residual`) sharing one
-   * x axis.
-   */
-  export function drawDecomposition(ctx: object): object;
-  /** The decomposition binding: reads the named component columns in row order. */
-  export function bindDecomposition(grid: Grid, spec: object): object;
-  export default drawDecomposition;
-}
-
-declare module 'lattice-grid/modules/chart-slope' {
-  /**
-   * The slope-chart extension type (BACKLOG-0000886). Importing this module
-   * registers `slope`. One line per `series` connecting its `y` across the `x`
-   * periods — before/after comparison read from the slopes.
-   */
-  export function drawSlope(ctx: object): object;
-  export default drawSlope;
-}
-
-declare module 'lattice-grid/modules/chart-dumbbell' {
-  /**
-   * The dumbbell / connected-dot extension type (BACKLOG-0000886). Importing
-   * this module registers `dumbbell`. Two dots (`start`, `end`) joined by a bar
-   * per `x` category — the gap is the bar's length.
-   */
-  export function drawDumbbell(ctx: object): object;
-  /** The dumbbell binding: reads the category and its two numeric columns. */
-  export function bindDumbbell(grid: Grid, spec: object): object;
-  export default drawDumbbell;
-}
-
-declare module 'lattice-grid/modules/chart-bump' {
-  /**
-   * The bump-chart extension type (BACKLOG-0000886). Importing this module
-   * registers `bump`. One line per `series` plotted by its rank of `y` within
-   * each `x` period — rank-over-time, where crossings are the story.
-   */
-  export function drawBump(ctx: object): object;
-  export default drawBump;
-}
-
-declare module 'lattice-grid/modules/chart-diverging' {
-  /**
-   * The diverging-bar extension type (BACKLOG-0000886). Importing this module
-   * registers `diverging`. Horizontal bars growing left/right from a central
-   * zero over a signed `y`, on a symmetric scale.
-   */
-  export function drawDiverging(ctx: object): object;
-  export default drawDiverging;
-}
-
-declare module 'lattice-grid/modules/chart-parallel' {
-  /**
-   * The parallel-coordinates extension type (BACKLOG-0000886). Importing this
-   * module registers `parallel`. One polyline per row across the numeric
-   * `columns`, each a vertical axis with its own scale; `spec.colourBy` colours
-   * by a category.
-   */
-  export function drawParallel(ctx: object): object;
-  /** The parallel-coordinates binding: reads the dimension columns off the rows. */
-  export function bindParallel(grid: Grid, spec: object): object;
-  export default drawParallel;
-}
-
-declare module 'lattice-grid/modules/chart-icicle' {
-  /**
-   * The icicle extension type (BACKLOG-0000886). Importing this module registers
-   * `icicle`. A hierarchy (the grid's group tree) as nested rectangles in rows,
-   * sized by `y`; drills like the built-in hierarchical types.
-   */
-  export function drawIcicle(ctx: object): object;
-  export default drawIcicle;
-}
-
-declare module 'lattice-grid/modules/chart-waffle' {
-  /**
-   * The waffle / dot-matrix extension type (BACKLOG-0000886). Importing this
-   * module registers `waffle`. Proportion as counted squares (default 100), one
-   * colour per `x` category sized by `y`.
-   */
-  export function drawWaffle(ctx: object): object;
-  export default drawWaffle;
-}
-
-declare module 'lattice-grid/modules/chart-alluvial' {
-  /**
-   * The alluvial extension type (BACKLOG-0000886). Importing this module
-   * registers `alluvial`. Ribbons from `source` categories to `target`
-   * categories sized by `value` — categorical flow between two dimensions.
-   */
-  export function drawAlluvial(ctx: object): object;
-  /** The alluvial binding: aggregates source→target flows off the grid's rows. */
-  export function bindAlluvial(grid: Grid, spec: object): object;
-  export default drawAlluvial;
-}
-
-declare module 'lattice-grid/modules/chart-arc' {
-  /**
-   * The arc-diagram extension type (BACKLOG-0000886). Importing this module
-   * registers `arc`. Nodes on a baseline with `source`→`target` relationships as
-   * semicircular arcs, thickness by `value`.
-   */
-  export function drawArc(ctx: object): object;
-  /** The arc-diagram binding: collects nodes and edges off the grid's rows. */
-  export function bindArc(grid: Grid, spec: object): object;
-  export default drawArc;
-}
-
-declare module 'lattice-grid/modules/chart-bubblemap' {
-  /**
-   * The symbol / bubble-map extension type (BACKLOG-0000886). Importing this
-   * module registers `bubblemap`. Points placed by `lon`/`lat`, each a bubble
-   * with a square-root radius from `size`; needs no outlines and fetches nothing.
-   */
-  export function drawBubbleMap(ctx: object): object;
-  /** The bubble-map binding: reads the coordinate and size columns off the rows. */
-  export function bindBubbleMap(grid: Grid, spec: object): object;
-  export default drawBubbleMap;
-}
-
-declare module 'lattice-grid/modules/chart-hexmap' {
-  /**
-   * The hexbin-map extension type (BACKLOG-0000886). Importing this module
-   * registers `hexmap`. `lon`/`lat` points binned into hexagons shaded by count,
-   * so a geographic density reads without overplotting or outlines.
-   */
-  export function drawHexMap(ctx: object): object;
-  /** The hexbin-map binding: reads the coordinate columns off the grid's rows. */
-  export function bindHexMap(grid: Grid, spec: object): object;
-  export default drawHexMap;
-}
-
-declare module 'lattice-grid/modules/react' {
-  /**
-   * Build the React component.
-   *
-   * A factory rather than a component, because the adapter imports neither
-   * React nor the grid: you pass both in. That is what keeps the package's
-   * promise of no runtime dependencies, and what stops an adapter disagreeing
-   * with the grid version already loaded.
-   *
-   * The live grid is reached through a forwarded ref: `ref.current.grid` is the
-   * same `Grid` the vanilla `createGrid` returns, or null before mount.
-   */
-  export function createLatticeGrid(deps: { React: unknown; createGrid: unknown }): unknown;
-  /** Every grid event, as the prop name a React caller writes. */
-  export const EVENT_NAMES: readonly string[];
-  export function handlerName(event: string): string;
-  export default createLatticeGrid;
-}
-
-declare module 'lattice-grid/modules/vue' {
-  /**
-   * Build the Vue 3 component.
-   *
-   * The Vue runtime and `createGrid` are passed in, for the same reason as the
-   * React adapter: the package ships no dependencies and cannot import either.
-   * The dependency key is lowercase `vue` — `createLatticeGrid({ vue, createGrid })`.
-   *
-   * The live grid is reached through the component's exposed `grid()` method:
-   * with `ref="grid"` on the element, `this.$refs.grid.grid()` returns the same
-   * `Grid` the vanilla `createGrid` returns, or null before mount.
-   */
-  export function createLatticeGrid(deps: { vue: unknown; createGrid: unknown }): unknown;
-  export const EVENT_NAMES: readonly string[];
-  export function dashedName(event: string): string;
-  export default createLatticeGrid;
-}
-
-declare module 'lattice-grid/modules/svelte' {
-  /**
-   * A Svelte action: `use:lattice={config}`.
-   *
-   * The action owns nothing but the node the caller already has, so the grid is
-   * reached one of two ways. Pass an `onGrid` callback in the action params
-   * (BACKLOG-0000785): `use:lattice={{ ...config, onGrid: (g) => (grid = g) }}`
-   * calls it once with the live `Grid` the moment it is built — synchronously,
-   * before `ready` fires — and again if you hand the action a different
-   * `onGrid`. Or read it off an event: every grid event carries the grid on its
-   * `detail`, so `on:ready={(e) => e.detail.grid}` hands you the same `Grid` a
-   * turn after construction. Use `onGrid` when you need the instance during the
-   * first render.
-   */
-  export function createLatticeAction(deps: { createGrid: unknown }): unknown;
-  export const EVENT_NAMES: readonly string[];
-  export function dashedName(event: string): string;
-  export default createLatticeAction;
-}
-
-declare module 'lattice-grid/modules/angular' {
-  /**
-   * Build the Angular standalone component and directive from one shared
-   * controller (BACKLOG-0000805).
-   *
-   * The Angular core namespace and `createGrid` are passed in, for the same
-   * reason as every other adapter: the package ships no dependencies and cannot
-   * import `@angular/core` or the grid. Pass `@angular/common`'s
-   * `isPlatformBrowser` too for an explicit SSR guard; without it the adapter
-   * guards on the presence of a `document`.
-   *
-   * The returned `LatticeGridComponent` (`<lattice-grid [config]="…">`) and
-   * `LatticeGridDirective` (`<div [latticeGrid]="…">`) each expose the live grid
-   * through a `grid` getter — the same `Grid` the vanilla `createGrid` returns,
-   * or null before build — at parity with React's `ref.current.grid`. Grid
-   * events are `@Output`s aliased to their dashed names (`(cell-changed)`).
-   */
-  export function createLatticeGrid(
-    deps: { ng: unknown; createGrid: unknown; isPlatformBrowser?: (id: unknown) => boolean },
-  ): { LatticeGridComponent: unknown; LatticeGridDirective: unknown };
-  export const EVENT_NAMES: readonly string[];
-  export function dashedName(event: string): string;
-  export default createLatticeGrid;
-}
-
-declare module 'lattice-grid/modules/data-router' {
-  /**
-   * A record routed through a data router: any object. Its partition comes from
-   * the router's `key` and its identity within a grid from `rowKey`.
-   */
-  type RouterRecord = Record<string, unknown>;
-
-  /** A per-route diff summary returned by `load`. */
-  interface RouteDiff { added: number; updated: number; removed: number }
-
-  /** A predicate: a property value (`row[key] === value`) or a `fn(row)`. */
-  type RoutePredicate = unknown | ((row: RouterRecord) => boolean);
-
-  /**
-   * Per-route reshaping options (v3, BACKLOG-0000887): `transform` maps/renames/
-   * derives each row before the grid sees it; `filter` gives the grid only the
-   * rows it admits; `sort` (a comparator or `{ key, dir }`) orders what the grid
-   * receives. `rowKey` overrides the router default. All optional.
-   */
-  interface RouteOptions {
-    rowKey?: (string | ((row: RouterRecord) => unknown));
-    transform?: (row: RouterRecord) => RouterRecord;
-    filter?: (row: RouterRecord) => boolean;
-    sort?: (((a: RouterRecord, b: RouterRecord) => number) | { key: string; dir?: 'asc' | 'desc' });
-  }
-
-  /**
-   * A cross-grid selection relation (v2, BACKLOG-0000880): a key map (target
-   * rows whose `to` value is among the selected source rows' `from` values — an
-   * IN set), or a function handed the selected source rows that returns a
-   * target-row predicate.
-   */
-  type SelectionRelation =
-    | { from: string; to: string }
-    | ((selected: RouterRecord[]) => ((row: RouterRecord) => boolean));
-
-  /**
-   * A data router: one arriving stream, partitioned by a property (or composite
-   * predicate), fanned out to a grid per partition (BACKLOG-0000879). Each grid
-   * sees only its slice, updated by keyed diff through the public
-   * `grid.rows.apply` path — no grid-core change, no cross-references between
-   * grids. Snapshots apply keyed diffs (unchanged rows never repaint); deltas add,
-   * update or remove in place by `rowKey`, preserving selection and scroll.
-   */
-  interface DataRouter {
-    /** Attach a grid behind a predicate; `opts` may reshape/filter/sort the route (v3). */
-    attach(grid: unknown, predicate: RoutePredicate, opts?: RouteOptions): DataRouter;
-    /** Attach the "rest" sink for records no explicit route matched. */
-    attachDefault(grid: unknown, opts?: RouteOptions): DataRouter;
-    /** Detach a grid; the host still owns and destroys it. */
-    detach(grid: unknown): DataRouter;
-    /** Apply a full snapshot as a keyed diff per grid; returns per-route counts. */
-    load(snapshot: RouterRecord[]): RouteDiff[];
-    /** Apply incremental deltas, routed and applied in place by `rowKey`. */
-    apply(deltas: { op: 'upsert' | 'delete'; row: RouterRecord }[]): void;
-    /**
-     * Link a source grid's selection to what a target grid receives (v2,
-     * BACKLOG-0000880): the target shows the subset of its partition the
-     * `relation` admits, re-pushed through the keyed-diff path. No selection
-     * shows the full partition; changes are debounced.
-     */
-    link(source: unknown, target: unknown, relation: SelectionRelation): DataRouter;
-    /** Apply any debounced selection refilter synchronously (for tests/determinism). */
-    flush(): DataRouter;
-    /** How many records matched no route. */
-    readonly unrouted: number;
-    /** Detach every grid and drop every link (the host destroys the grids themselves). */
-    destroy(): void;
-  }
-
-  /**
-   * Create a data router that partitions one stream to many grids.
-   *
-   * `key` is the partition property or `fn(row)`; `rowKey` is the identity within
-   * a grid; `overlap` fans a record to every matching route (default: first match
-   * wins); `onUnrouted` receives records that match none; `selectionDebounce` is
-   * the debounce in ms for cross-grid selection refilters (default 16; `0` is
-   * synchronous).
-   */
-  export function createDataRouter(opts: {
-    key: (string | ((row: RouterRecord) => unknown));
-    rowKey?: (string | ((row: RouterRecord) => unknown));
-    overlap?: boolean;
-    onUnrouted?: (item: unknown) => void;
-    selectionDebounce?: number;
-  }): DataRouter;
-  export default createDataRouter;
-}
-
-declare module 'lattice-grid/modules/gantt' {
-  /** One of the four dependency link types (finish-to-start, start-to-start, finish-to-finish, start-to-finish). */
-  export type GanttLinkType = 'FS' | 'SS' | 'FF' | 'SF';
-
-  /** A scheduling constraint: pin the start, pin the finish, or schedule as late as possible. */
-  export type GanttConstraintType =
-    | 'must-start-on' | 'must-finish-on' | 'as-late-as-possible' | 'MSO' | 'MFO' | 'ALAP';
-
-  /** A working-time calendar: a Monday–Friday preset, or explicit working weekdays and holidays. */
-  export type GanttCalendar =
-    | 'weekends'
-    | { workdays?: number[]; holidays?: Array<string | number | Date> };
-
-  /**
-   * A task in a Gantt plan. Give a `duration` or a `start`+`end` (a day-number,
-   * ISO date string or `Date`; one is derived from the other). `milestone: true`
-   * (or `duration: 0`) is a zero-duration point. `parent` nests a task under a
-   * summary, whose window and progress are DERIVED from its children.
-   * `baselineStart`/`baselineEnd` (host-stored) drive planned-vs-actual variance;
-   * `constraint` pins or pulls the task; `assignee` and `height` feed the split
-   * view's grid panel.
-   */
-  export interface GanttTask {
-    id: string | number;
-    name?: string;
-    start?: number | string | Date;
-    end?: number | string | Date;
-    duration?: number;
-    percentComplete?: number;
-    milestone?: boolean;
-    parent?: string | number;
-    baselineStart?: number | string | Date;
-    baselineEnd?: number | string | Date;
-    baseline?: { start?: number | string | Date; end?: number | string | Date };
-    constraint?: GanttConstraintType;
-    constraintDate?: number | string | Date;
-    assignee?: string | string[];
-    assignees?: string[];
-    owner?: string;
-    /**
-     * Explicit resource assignments with fractional units (BACKLOG-0000948):
-     * `units` is a multiplier where 1 is a full-time booking. Use this when a
-     * task books a resource at less (or more) than 100%; a bare `assignee` is
-     * `units: 1`.
-     */
-    assignments?: Array<{ resource?: string; name?: string; id?: string; units?: number }>;
-    /** Leveling priority: a higher value is delayed last (default 0). */
-    priority?: number;
-    /** An explicit row height (px) for the split view; applied to both panels. */
-    height?: number;
-    /**
-     * The budgeted cost (BAC) for earned-value analysis (BACKLOG-0000958). When
-     * omitted the task's duration is used as the budget, giving schedule-only EVM.
-     */
-    cost?: number;
-    /**
-     * The actual cost incurred (ACWP) for earned-value analysis
-     * (BACKLOG-0000958). Left out, the task's cost variance/CPI are `null`.
-     */
-    actualCost?: number;
-  }
-
-  /**
-   * Resource capacities for over-allocation detection and leveling
-   * (BACKLOG-0000948): either a list of resources with a capacity (max
-   * concurrent units, default 1) or a name→capacity map.
-   */
-  export type GanttResourceSpec =
-    | Array<{ id?: string; name?: string; resource?: string; capacity?: number; maxUnits?: number; max?: number; units?: number }>
-    | Record<string, number>;
-
-  /**
-   * A typed dependency between two tasks (by id), with optional lag/lead. `type`
-   * defaults to `'FS'`; either endpoint may be a leaf or a summary.
-   *
-   * `type` also accepts the MS Project string shorthand — `'FS+2'`, `'SS-1'`
-   * (BACKLOG-0001072). It is normalised to the structured form on the way in, so
-   * `gantt.dependencies` always reads back `{ type, lag }` and there is no second
-   * internal representation. Giving both a shorthand lag and a conflicting `lag`
-   * field warns; the explicit field wins.
-   */
-  export interface GanttDependency {
-    from: string | number;
-    to: string | number;
-    type?: GanttLinkType | `${GanttLinkType}${'+' | '-'}${number}`;
-    lag?: number;
-  }
-
-  /** The computed CPM values for one task (a leaf is scheduled, a summary derived). */
-  interface GanttScheduledTask {
-    id: string;
-    name: string;
-    duration: number;
-    es: number;
-    ef: number;
-    ls: number;
-    lf: number;
-    totalFloat: number;
-    critical: boolean;
-    percentComplete: number | null;
-    parent: string | null;
-    isSummary: boolean;
-    isMilestone: boolean;
-    children: string[];
-    /** The planned (baseline) window, present only when the task carries a baseline. */
-    baselineStart?: number | null;
-    baselineEnd?: number | null;
-    /** Variance vs the baseline (actual − planned, day-numbers); a positive value is a slip. */
-    startVariance?: number | null;
-    finishVariance?: number | null;
-    durationVariance?: number | null;
-  }
-
-  /** An unhonourable scheduling constraint, reported rather than obeyed. */
-  interface GanttConflict {
-    id: string;
-    type: string;
-    at: number | null;
-    earliestFeasible: number;
-  }
-
-  /** A CPM schedule result: per-task dates/float and the critical path, or an error. */
-  interface GanttSchedule {
-    ok: boolean;
-    error?: { code: string; message: string; cycle?: string[] };
-    tasks?: Map<string, GanttScheduledTask>;
-    order?: string[];
-    critical?: string[];
-    criticalPaths?: string[][];
-    projectStart?: number;
-    projectFinish?: number;
-    projectDuration?: number;
-    /** Constraints a predecessor made infeasible (empty when all are satisfied). */
-    conflicts?: GanttConflict[];
-    /** Whether a working-time calendar was applied. */
-    calendar?: boolean;
-    /** The resource over-allocations for this schedule (BACKLOG-0000948). */
-    overAllocations?: GanttOverAllocation[];
-    /** The full resource-load report for this schedule (BACKLOG-0000948). */
-    resourceLoad?: GanttResourceLoad;
-  }
-
-  /** One contiguous load segment for a resource: how many units are booked over a span. */
-  interface GanttResourceSegment {
-    start: number;
-    end: number;
-    load: number;
-    taskIds: string[];
-  }
-
-  /** A resource booked beyond its capacity across concurrent tasks (BACKLOG-0000948). */
-  interface GanttOverAllocation {
-    resource: string;
-    capacity: number;
-    start: number;
-    end: number;
-    load: number;
-    taskIds: string[];
-  }
-
-  /** The per-resource load and the over-allocations across a schedule (BACKLOG-0000948). */
-  interface GanttResourceLoad {
-    ok: boolean;
-    resources: Array<{ resource: string; capacity: number; peak: number; segments: GanttResourceSegment[] }>;
-    overAllocations: GanttOverAllocation[];
-    byResource: Map<string, { capacity: number; peak: number; segments: GanttResourceSegment[] }>;
-  }
-
-  /** The result of resource leveling: the shifted tasks and what moved (BACKLOG-0000948). */
-  interface GanttLevelResult {
-    ok: boolean;
-    resolved?: boolean;
-    tasks?: GanttTask[];
-    schedule?: GanttSchedule;
-    moves?: Array<{ id: string; from: number; to: number; delay: number }>;
-    remaining?: GanttOverAllocation[];
-    error?: { code: string; message: string };
-  }
-
-  /** A placement violation flagged by `findViolations`. */
-  interface GanttViolation {
-    id: string;
-    placedStart: number;
-    earliestStart: number;
-    by: number;
-  }
-
-  /** The four link types, in documented order. */
-  export const LINK_TYPES: readonly GanttLinkType[];
-
-  /** Error codes the scheduler reports (rather than throwing) on bad input. */
-  export const SCHEDULE_ERROR: Record<string, string>;
-
-  /**
-   * Compute the CPM schedule for a set of tasks and dependencies: forward and
-   * backward passes over the leaf tasks honouring FS/SS/FF/SF + lag, slack/float
-   * and the zero-float critical path, with summaries derived from their children,
-   * milestones scheduled as points, and dependency cycles refused (never looped).
-   */
-  export function computeSchedule(tasks: GanttTask[], deps?: GanttDependency[], options?: { projectStart?: number | string | Date; deadline?: number | string | Date; calendar?: GanttCalendar | null }): GanttSchedule;
-
-  /** The tasks placed earlier than their earliest feasible start (manual validation). */
-  export function findViolations(tasks: GanttTask[], schedule: GanttSchedule): GanttViolation[];
-
-  /** Format an engine day-number as an ISO calendar date (`YYYY-MM-DD`, UTC). */
-  export function toISODate(day: number): string | null;
-
-  /** Earned-value metrics for one task or the whole project (BACKLOG-0000958). */
-  interface GanttEarnedValueRow {
-    id: string;
-    name: string;
-    isSummary: boolean;
-    isMilestone: boolean;
-    percentComplete: number | null;
-    /** Whether a baseline (not the fallback scheduled window) drove PV. */
-    hasBaseline: boolean;
-    /** Whether any actual cost fed AC (else AC/CV/CPI are null). */
-    hasActualCost: boolean;
-    /** Budget at completion (the task's cost, or its duration when no cost). */
-    bac: number;
-    /** Planned Value (BCWS): budgeted cost of the work scheduled by the status date. */
-    pv: number;
-    /** Earned Value (BCWP): budgeted cost of the work performed (BAC × %complete). */
-    ev: number;
-    /** Actual Cost (ACWP): what the work performed actually cost, or null. */
-    ac: number | null;
-    /** Schedule Variance (EV − PV); positive is ahead of schedule. */
-    sv: number;
-    /** Cost Variance (EV − AC); positive is under budget; null without AC. */
-    cv: number | null;
-    /** Schedule Performance Index (EV / PV); null when PV is zero. */
-    spi: number | null;
-    /** Cost Performance Index (EV / AC); null without AC or when AC is zero. */
-    cpi: number | null;
-  }
-
-  /** The earned-value result at a status date (BACKLOG-0000958). */
-  interface GanttEarnedValue {
-    ok: boolean;
-    error?: { code: string; message: string };
-    /** The status date the metrics were evaluated at (day-number). */
-    statusDate?: number;
-    /** Every task keyed by id (leaf, summary and derived). */
-    byTask?: Map<string, GanttEarnedValueRow>;
-    /** The same rows in schedule order. */
-    rows?: GanttEarnedValueRow[];
-    /** The project total, rolled up as money sums of the leaves. */
-    project?: GanttEarnedValueRow;
-  }
-
-  /**
-   * Compute earned-value management (EVM) metrics for a scheduled plan at a
-   * status date (BACKLOG-0000958): PV/BCWS from the baseline, EV/BCWP from
-   * %complete, AC/ACWP from the per-task `actualCost`, and the derived SV/CV and
-   * SPI/CPI — per leaf, rolled up to summaries and the project. The math is
-   * implemented locally in the module (no core-compute dependency).
-   */
-  export function computeEarnedValue(
-    tasks: GanttTask[],
-    schedule: GanttSchedule,
-    options?: { statusDate?: number | string | Date; costField?: string; actualCostField?: string },
-  ): GanttEarnedValue;
-
-  /** A headless Gantt controller: holds the model, recomputes on edits, emits changes. */
-  interface Gantt {
-    readonly tasks: GanttTask[];
-    readonly dependencies: GanttDependency[];
-    readonly schedule: GanttSchedule | null;
-    readonly critical: string[];
-    /** Constraints the latest schedule could not honour (empty when all are satisfied). */
-    readonly conflicts: GanttConflict[];
-    readonly autoSchedule: boolean;
-    readonly grid: unknown;
-    /** The over-allocations from the latest schedule (BACKLOG-0000948). */
-    readonly overAllocations: GanttOverAllocation[];
-    /** The latest resource-load report, or null before a successful schedule (BACKLOG-0000948). */
-    readonly resourceLoad: GanttResourceLoad | null;
-    setTasks(tasks: GanttTask[]): GanttSchedule;
-    setDependencies(deps: GanttDependency[]): GanttSchedule;
-    applyEdit(patch: { id: string | number; start?: number; end?: number; duration?: number }, editOpts?: { writeBack?: boolean }): GanttSchedule;
-    compute(): GanttSchedule;
-    findViolations(): GanttViolation[];
-    /**
-     * Compute the resource load and over-allocations on demand (BACKLOG-0000948),
-     * optionally overriding the capacities for this call.
-     */
-    resources(loadOpts?: { resources?: GanttResourceSpec; defaultCapacity?: number }): GanttResourceLoad;
-    /**
-     * Resolve resource over-allocation by shifting tasks later — resource
-     * leveling (BACKLOG-0000948). Honours the CPM dependencies and the
-     * working-time calendar. Mutates the model unless `{ dryRun: true }`; with
-     * `{ writeBack: true }` and a bound grid the moved tasks are pushed through
-     * the grid's edit surface.
-     */
-    level(levelOpts?: {
-      dryRun?: boolean;
-      writeBack?: boolean;
-      priorityField?: string;
-      maxIterations?: number;
-      resources?: GanttResourceSpec;
-      defaultCapacity?: number;
-    }): GanttLevelResult;
-    /** Export the scheduled tasks as CSV; `{ dates: true }` writes ISO dates. */
-    toCSV(csvOpts?: { dates?: boolean }): string;
-    /**
-     * Export the current plan as Microsoft Project (MSPDI) XML (BACKLOG-0000950):
-     * tasks, dependencies, constraints, baseline, resources and assignments, plus
-     * the working-time calendar, serialised with the computed schedule.
-     */
-    toMSPDI(xmlOpts?: { hoursPerDay?: number; projectName?: string }): string;
-    /**
-     * The live consumer surface, mirroring `grid.rows.apply`, so a Data Router
-     * can drive the Gantt like any other view. Keyed by the controller's rowKey.
-     */
-    readonly rows: {
-      apply(change: { add?: GanttTask[]; update?: GanttTask[]; remove?: Array<string | GanttTask> }): {
-        added: GanttTask[]; updated: GanttTask[]; removed: string[];
-      };
-    };
-    on(event: 'schedule' | 'error', fn: (payload: unknown) => void): () => void;
-    off(event: 'schedule' | 'error', fn: (payload: unknown) => void): void;
-    /**
-     * Render the plan into a container as an SVG timeline (bars, dependency
-     * arrows, critical-path highlight, today line, non-working shading,
-     * milestones, progress). The view redraws when the schedule recomputes.
-     */
-    mount(container: unknown, options?: {
-      /**
-       * The plot width. `'container'` (the default) measures the element it was
-       * mounted into and keeps following it, so a plan in a tab, drawer,
-       * accordion or split pane fits without the host writing a
-       * `ResizeObserver` (BACKLOG-0001079); a container with no box yet holds a
-       * 720px fallback rather than drawing at zero. A number is honoured
-       * exactly and installs no observer. Ignored under `zoom`, which warns.
-       */
-      width?: number | 'container';
-      rowHeight?: number;
-      labelWidth?: number;
-      rowLabels?: boolean;
-      showArrows?: boolean;
-      showCritical?: boolean;
-      showProgress?: boolean;
-      dateAxis?: boolean;
-      /**
-       * The today line, as a plan day-number or a calendar date. A date is
-       * converted into plan space through `projectEpoch` (BACKLOG-0001079), so
-       * "put the line on the real today" is expressible for a relative plan.
-       */
-      today?: number | string | Date;
-      /**
-       * The calendar date plan day 0 stands for (BACKLOG-0001079).
-       *
-       * Display-only: axis ticks, bar labels, tooltips, screen-reader text and
-       * the built-in `'weekends'` shading move with it; the schedule, `getState`
-       * and the CSV/MSPDI exports do not. Without it, the engine's contract makes
-       * day 0 the Unix epoch, which is why a plan written as day offsets renders
-       * as January 1970. A host-supplied `nonWorking` function still receives raw
-       * plan days.
-       */
-      projectEpoch?: number | string | Date | null;
-      nonWorking?: 'weekends' | ((day: number) => boolean);
-      label?: 'name' | 'percent' | 'dates' | 'none' | ((task: GanttScheduledTask) => string);
-      /** Whether bars can be dragged to move/resize (default true). */
-      editable?: boolean;
-      /** Pixels from a bar's right edge that begin a resize rather than a move. */
-      resizeZone?: number;
-      /** Time-scale zoom: a level, or raw pixels-per-day. Omit to fit the width. */
-      zoom?: 'day' | 'week' | 'month' | 'quarter' | number;
-      /** Scroll so the today line is in view after drawing. */
-      scrollToToday?: boolean;
-      /** Show a hover tooltip (dates/duration/%/slack); default true. */
-      tooltip?: boolean;
-      /** Group tasks into swimlanes by a task property name or `fn(task)`. */
-      groupBy?: string | ((task: GanttTask) => unknown);
-      /** Keyboard editing + focusable bars + ARIA announcements (default true). */
-      keyboard?: boolean;
-      /** Days a keyboard arrow moves/resizes a task (default 1). */
-      moveStep?: number;
-    }): unknown;
-    /**
-     * Mount the JOINED split view (BACKLOG-0000938): one continuous, row-aligned
-     * surface with a left task-grid panel (Task Name tree with expand/collapse,
-     * assignee avatars, a circular % ring, plus any host columns) and the right
-     * timeline, sharing a single vertical scroll so every grid row lines up
-     * exactly with its bar row. The timeline scrolls horizontally on its own.
-     * Composes the controller's schedule; makes no change to grid core.
-     */
-    mountSplit(container: unknown, options?: {
-      height?: number;
-      rowHeight?: number;
-      headerHeight?: number;
-      gridWidth?: number;
-      indent?: number;
-      zoom?: 'day' | 'week' | 'month' | 'quarter' | number;
-      today?: number;
-      nonWorking?: 'weekends' | ((day: number) => boolean);
-      calendar?: GanttCalendar | null;
-      showArrows?: boolean;
-      showProgress?: boolean;
-      showBaseline?: boolean;
-      barLabel?: 'name' | 'percent' | 'dates' | 'none' | ((task: GanttScheduledTask) => string);
-      /**
-       * Surface earned-value metrics in `kind: 'evm'` columns (BACKLOG-0000958).
-       * `true` computes EVM at the today line (or the project finish); an object
-       * overrides the status date and the cost field names.
-       */
-      evm?: boolean | { statusDate?: number | string | Date; costField?: string; actualCostField?: string };
-      columns?: Array<{ key: string; title?: string; width?: number; kind?: 'name' | 'assignee' | 'progress' | 'evm'; metric?: 'bac' | 'pv' | 'ev' | 'ac' | 'sv' | 'cv' | 'spi' | 'cpi'; digits?: number; render?: (task: GanttScheduledTask, ctx: { rawTask: GanttTask; depth: number }) => unknown }>;
-    }): unknown;
-    /**
-     * Capture a baseline (planned) snapshot of the current schedule as HOST data
-     * (this does not mutate the tasks). Store it and feed it back as
-     * `baselineStart`/`baselineEnd` task fields to get variance and ghost bars.
-     */
-    captureBaseline(): Array<{ id: string; baselineStart: number; baselineEnd: number; baselineDuration: number }>;
-    /**
-     * Compute earned-value (EVM) metrics for the current plan at a status date
-     * (BACKLOG-0000958): PV/EV/AC and the derived SV/CV/SPI/CPI per task, rolled
-     * up to summaries and the project. Budget (BAC) is the task's `cost`, or its
-     * duration when no cost is given; AC comes from `actualCost`.
-     */
-    earnedValue(evmOpts?: { statusDate?: number | string | Date; costField?: string; actualCostField?: string }): GanttEarnedValue;
-    /** Detach the mounted view, if any. The host still owns the container. */
-    unmount(): void;
-    /** The mounted view, or null. */
-    readonly view: unknown;
-    destroy(): void;
-  }
-
-  /**
-   * Create a Gantt controller over a task list and a dependency list. Computes
-   * the CPM schedule immediately and again on every `setTasks`/`setDependencies`/
-   * `applyEdit`, emitting `schedule` on success and `error` on a cycle or bad
-   * input. `grid` is stored for the write-back binding; `autoSchedule` requests
-   * dependent cascading.
-   */
-  export function createGantt(opts?: {
-    tasks?: GanttTask[];
-    dependencies?: GanttDependency[];
-    /** The schedule anchor: a day-number, ISO date string or Date. It only sets the floor a task with no predecessor starts on; it does not change how the schedule is computed. */
-    projectStart?: number | string | Date;
-    /** A project deadline (a day-number, ISO string or Date); tasks that cannot meet it get negative float. */
-    deadline?: number | string | Date;
-    /** A working-time calendar: skip weekends/holidays, durations in working days. */
-    calendar?: GanttCalendar | null;
-    /** Resource capacities for over-allocation detection and leveling (BACKLOG-0000948). */
-    resources?: GanttResourceSpec;
-    /** The capacity for a resource with none stated (default 1 = one full-time booking). */
-    defaultCapacity?: number;
-    autoSchedule?: boolean;
-    grid?: unknown;
-    /** Map task fields to grid column ids to enable drag write-back. */
-    columns?: { start?: string; end?: string; duration?: string };
-    /** Task identity for the live `rows.apply` surface (a field or fn); default 'id'. */
-    rowKey?: string | ((row: GanttTask) => unknown);
-    /** Auto-mount into this element at construction. */
-    element?: unknown;
-  }): Gantt;
-  export default createGantt;
-
-  /** The model {@link importMSPDI} returns and {@link exportMSPDI} takes. */
-  interface GanttMSPDIModel {
-    tasks: GanttTask[];
-    dependencies?: GanttDependency[];
-    resources?: GanttResourceSpec;
-    projectStart?: number | string | Date;
-    calendar?: GanttCalendar | null;
-    schedule?: GanttSchedule;
-  }
-
-  /**
-   * Import a Microsoft Project (MSPDI) XML document (BACKLOG-0000950) into the
-   * module's model: the task tree, typed dependencies with lag, constraints,
-   * baseline, %complete, resources with capacity, the resource assignments, and
-   * the working-time calendar. The result is ready to pass to {@link createGantt}.
-   */
-  export function importMSPDI(xml: string, opts?: { hoursPerDay?: number }): {
-    ok: boolean;
-    error?: string;
-    tasks: GanttTask[];
-    dependencies: GanttDependency[];
-    resources: Array<{ id: string; name: string; capacity: number }>;
-    projectStart?: number;
-    calendar?: null | { workdays: number[]; holidays: number[] };
-  };
-
-  /**
-   * Export a Gantt model to Microsoft Project (MSPDI) XML (BACKLOG-0000950). A
-   * scheduled model may be passed so start/finish dates are the computed ones.
-   */
-  export function exportMSPDI(model: GanttMSPDIModel, opts?: { hoursPerDay?: number; projectName?: string }): string;
-}
-
-declare module 'lattice-grid/modules/webcomponent' {
-  /**
-   * Register `<lattice-grid>`.
-   *
-   * This module carries the grid inside it. Use it *or* `createGrid` in one
-   * page, never both: two copies keep separate registries, and a renderer
-   * registered through one will not appear in the other.
-   *
-   * The live grid is reached through the element's `grid` getter: `el.grid` is
-   * the same `Grid` the vanilla `createGrid` returns, or null while the element
-   * is disconnected.
-   */
-  export function defineLatticeGrid(tag?: string): void;
-  /**
-   * Build the `<lattice-grid>` element class. The one argument is the grid
-   * factory the element creates its grid with — `createGrid`-shaped, and
-   * defaulting to it — injectable for tests. Returns the class, or `null`
-   * where `HTMLElement` is undefined (a Node import, a server-side pass).
-   */
-  export function createLatticeGridElement(
-    factory?: (element: Element, config: GridConfig) => Grid,
-  ): typeof HTMLElement | null;
-  export const TAG_NAME: string;
-  export const EVENT_PREFIX: string;
-  export const ATTRIBUTE_CONFIG: Readonly<Record<string, unknown>>;
-  export function observedAttributeNames(): string[];
-  export function domEventName(event: string): string;
-  export class GridElementController {}
-  // Core factories re-exported from this module so they bind to the one engine
-  // the element already carries: a type built with these here shares the
-  // element's registry rather than a second copy's (BACKLOG-0000787). Typed by
-  // reference to the base package.
-  export { createCurrencyType, createUnitType, registerUnitSystem, createStat } from 'lattice-grid';
-  export default defineLatticeGrid;
-}
-
-declare module 'lattice-grid/modules/htmx' {
-  /**
-   * The htmx integration, which re-exports the base API alongside its own,
-   * a page using it imports this and never the base package as well.
-   */
-  export function createGrid(element: Element, config: GridConfig): Grid;
-  export function autoInit(root?: ParentNode): Grid[];
-  /**
-   * Wire the htmx lifecycle events on a document: grids are built in each
-   * swapped-in fragment, released before htmx detaches one, and their view
-   * state carried across history navigation. Called once on import against
-   * the global `document`; call it again only for another document. Returns
-   * the function that removes every listener it installed.
-   */
-  export function attach(doc?: Document): () => void;
-  export function initWithin(root: ParentNode): Grid[];
-  export function destroyWithin(root: ParentNode): void;
-  export function gridElementsWithin(root: ParentNode): Element[];
-  export function hydrateTable(table: Element, config?: GridConfig): Grid;
-  export function readTable(table: Element): { columns: Column[]; rows: unknown[] };
-  export function rowsFromFragment(fragment: ParentNode): unknown[];
-  export function rowsFromJson(text: string): unknown[];
-  /**
-   * Parse a response into rows by its content type: JSON through
-   * `rowsFromJson`, anything else through `rowsFromFragment` against the
-   * columns given. The fragment arrives already parsed; this never touches
-   * `DOMParser` or `innerHTML`. Returns the rows and, when the body carried
-   * one, the total.
-   */
-  export function ingestResponse(
-    response: { contentType: string; text?: string; fragment?: ParentNode },
-    columns: { field: string }[],
-  ): { rows: unknown[]; total: number | undefined };
-  /**
-   * Drive server-side sort and filter through htmx. `trigger` is the element
-   * carrying the htmx request attributes (`hx-get`, `hx-target`,
-   * `hx-trigger="lattice:query-changed"`); the grid's query parameters are
-   * merged into that element's request and its response ingested. Returns the
-   * function that detaches everything this attached.
-   */
-  export function driveServerMode(
-    grid: Grid,
-    trigger: Element,
-    opts?: { columns?: { field: string }[] },
-  ): () => void;
-  /**
-   * Load rows in chunks as the user nears the end of what is loaded.
-   * `sentinelEl` is the element carrying `hx-get` and
-   * `hx-trigger="revealed, lattice:scroll-near-end"`; `threshold` is how many
-   * rows from the end counts as near (default 20). Returns the function that
-   * detaches everything this attached.
-   */
-  export function driveInfiniteScroll(
-    grid: Grid,
-    sentinelEl: Element,
-    opts?: { columns?: { field: string }[]; threshold?: number },
-  ): () => void;
-  export function driveOobUpdates(grid: Grid, opts?: object): () => void;
-  export function serialiseState(grid: Grid): string;
-  export function restoreState(grid: Grid, state: string): void;
-  export function saveStateWithin(root: ParentNode): void;
-  export function restoreStateWithin(root: ParentNode): void;
-  export function queryParams(grid: Grid): Record<string, string>;
-  export function warnIfLargeHtmlPayload(rows: number): void;
-  export const QUERY_CHANGED_EVENT: string;
-  export const SCROLL_NEAR_END_EVENT: string;
-  export const HTML_ROW_WARNING_THRESHOLD: number;
-  // The core factory surface this module re-exports, so an htmx page builds its
-  // configured columns (a currency type, a unit type, a stat) from the one
-  // engine it already carries rather than a second copy (BACKLOG-0000786).
-  // Typed by reference to the base package; names the base package leaves
-  // untyped stay untyped here too.
-  export {
-    createHeadlessGrid, version, getVersion, Grid, Registry, registerModules,
-    createRadixType, createUnitType, registerUnitSystem, defineUnit, UNIT_SYSTEMS, parseUnit, formatUnit,
-    createCurrencyType, parseMoney, formatMoney, convertMoney, rateFunction, MISSING_RATE,
-    Messages, createMessages, auditCatalogue,
-    EN_GB, MESSAGE_KEYS, DEFAULT_LOCALE, formatList, resolveLocale, LOCALES, resolveCatalogue,
-    EN_US, FR_FR, FR_CA, IT_IT, ES_ES, PT_BR, DE_DE, NL_NL, SV_SE, DA_DK, NB_NO, FI_FI,
-    PL_PL, CS_CZ, HU_HU, RO_RO, UK_UA, EL_GR, JA_JP, AR, AR_SA,
-    Window, openWindow, WINDOW_KINDS,
-    evaluateFormula, referencesOf, looksLikeFormula, compileRules, ingest, ingestSync,
-    createPushdownSource, planQuery, splitFilters, applyResidual, capabilitiesOf, resolveMutate, NO_CAPABILITIES,
-    odataAdapter, restAdapter, dfqlAdapter, duckdbAdapter,
-    createStat, deltaOf, toneOf,
-  } from 'lattice-grid';
-  // American licence aliases mirror the base package (dom/index.js).
-  export { setLicence as setLicense, licenceInfo as licenseInfo, licenceState as licenseState } from 'lattice-grid';
-}
-
-declare module 'lattice-grid/modules/dhtmlx-compat' {
-  /**
-   * A dhtmlx Grid-shaped API over Lattice, for migrating a piece at a time.
-   *
-   * The module shares the page's one core rather than bundling its own: the
-   * grid it builds comes from the `lattice-grid` package the app already loads
-   * (or the `LatticeGrid` global a script tag publishes), so a licence set on
-   * that core applies to these grids too. Load the core alongside this module —
-   * a bundler wires the peer import for you; a `<script src>` page loads the
-   * global build first.
-   */
-  export class Grid {
-    constructor(container: Element | string, config?: object);
-  }
-  export default Grid;
-}
-
-declare module 'lattice-grid/modules/devtools' {
-  /**
-   * The devtools panel, including the accessibility checks.
-   *
-   * The grid is handed in rather than imported: a module may depend on nothing
-   * in core, or the bundler inlines the whole grid into it.
-   */
-  export function createDevtools(opts: { grid: Grid; container?: Element }): {
-    element: Element;
-    refresh(): void;
-    destroy(): void;
-  };
-  export function expose(grid: Grid, name?: string): void;
-  /**
-   * Whether the console entry point is compiled in. A build that replaces the
-   * activation token with `false` removes the global entirely; in every other
-   * build this is `true`.
-   */
-  export const CONSOLE_ACTIVATION: boolean;
-  export default createDevtools;
-}
-
-declare module 'lattice-grid/modules/mock-socket' {
-  /** One record on a feed: any object. Its partition comes from a property and its identity from `rowKey`. */
-  type FeedRow = Record<string, unknown>;
-
-  /** One change in a delta batch, in the shape the data router applies. */
-  interface FeedChange { op: 'upsert' | 'delete'; row: FeedRow }
-
-  /**
-   * A message on the wire. A snapshot carries the full opening set; a delta
-   * carries the changes since. The reader parses `event.data` and switches on
-   * `kind`, exactly as against a real feed that framed its messages the same way.
-   */
-  interface FeedMessage {
-    kind: 'snapshot' | 'delta';
-    /** Present on a snapshot: the full opening set of rows. */
-    rows?: FeedRow[];
-    /** Present on a delta: the changes to apply. */
-    changes?: FeedChange[];
-  }
-
-  /** A feed: any iterator that yields a snapshot first, then deltas forever. */
-  type Feed = Iterator<FeedMessage>;
-
-  /**
-   * A serverless stand-in for a live `WebSocket`. It presents the same surface
-   * as the browser's `WebSocket` — `readyState` and the state constants,
-   * `onopen`/`onmessage`/`onclose`/`onerror`, `addEventListener`, `send` and
-   * `close` — so the code that reads it does not change when it is swapped for a
-   * real socket. It opens after a short delay, emits the feed's first value as a
-   * snapshot, then pumps one value per tick as a delta.
-   */
-  export class MockWebSocket {
-    static readonly CONNECTING: 0;
-    static readonly OPEN: 1;
-    static readonly CLOSING: 2;
-    static readonly CLOSED: 3;
-    readonly CONNECTING: 0;
-    readonly OPEN: 1;
-    readonly CLOSING: 2;
-    readonly CLOSED: 3;
-    readyState: number;
-    url: string;
-    onopen: ((event: { type: string }) => void) | null;
-    onmessage: ((event: { type: string; data: string }) => void) | null;
-    onclose: ((event: { type: string; code: number; reason: string; wasClean: boolean }) => void) | null;
-    onerror: ((event: { type: string; error: unknown }) => void) | null;
-    /**
-     * @param init the feed and its timing: `feed` (snapshot first, then deltas);
-     *   `rate` ms between deltas (default 1000); `jitter` random plus-or-minus ms
-     *   per gap (default 0); `seed` for that jitter (default 1); `snapshotDelay`
-     *   ms before opening (default 60); `pauseWhenHidden` stops while the tab is
-     *   hidden (default true); `url` a cosmetic address.
-     */
-    constructor(init: {
-      feed: Feed;
-      rate?: number;
-      jitter?: number;
-      seed?: number;
-      snapshotDelay?: number;
-      pauseWhenHidden?: boolean;
-      url?: string;
-    });
-    addEventListener(type: string, fn: (event: unknown) => void): void;
-    removeEventListener(type: string, fn: (event: unknown) => void): void;
-    /** A real socket sends upstream; here it is accepted and ignored. */
-    send(data?: unknown): void;
-    /** Stop the feed until `resume()`; the socket stays open (a demo/test affordance). */
-    pause(): void;
-    /** Resume a paused feed. */
-    resume(): void;
-    /** Close the socket, stop the feed and emit a clean `close`. */
-    close(): void;
-  }
-
-  /**
-   * mulberry32: a small seeded pseudo-random generator, so a custom feed can be
-   * seeded the same way the shipped ones are. The same seed yields the same
-   * sequence of values in `[0, 1)`.
-   */
-  export function rng(seed: number): () => number;
-
-  /**
-   * A mixed operations feed — orders, shipments and incidents across three
-   * regions plus a throughput rollup — the Data Router tutorial partitions
-   * across several grids and a chart from one source. Yields a snapshot, then
-   * deltas forever. Seedable for a repeatable stream.
-   */
-  export function opsFeed(options?: {
-    seed?: number;
-    orders?: number;
-    shipments?: number;
-    incidents?: number;
-    batch?: number;
-  }): Generator<FeedMessage>;
-
-  /**
-   * A market-data feed: instruments whose prices random-walk each tick, each
-   * record carrying `type: 'price'`, `symbol`, `last`, `chg` and a bid/ask. The
-   * price/random-walk feed behind the trading-terminal tutorial. Yields a
-   * snapshot, then deltas forever. Seedable for a repeatable stream.
-   */
-  export function priceFeed(options?: {
-    seed?: number;
-    symbols?: { symbol: string; last: number }[];
-    move?: number;
-    batch?: number;
-    spread?: number;
-  }): Generator<FeedMessage>;
-
-  export default MockWebSocket;
-}
-
-declare module 'lattice-grid/modules/kanban' {
-  /** A row backing a card: any object. Its column comes from `columnProperty` and its identity from `rowKey`. */
-  type KanbanRow = Record<string, unknown>;
-
-  /**
-   * A card model — one row as it appears on the board. `fields` holds the
-   * resolved display text for each mapped card field; `columnId` is the column
-   * the card sits in; `points` is the numeric points value (0 when absent).
-   * `swimlane`/`sprint`/`epic`/`order` are read from their configured properties
-   * and carried for the later cycles that render them.
-   */
-  interface KanbanCard {
-    key: unknown;
-    row: KanbanRow;
-    columnId: string | null;
-    points: number;
-    hasPoints: boolean;
-    order?: unknown;
-    swimlane?: unknown;
-    sprint?: unknown;
-    epic?: unknown;
-    fields: Record<string, string>;
-  }
-
-  /** A column with its cards and aggregates. `over` is true when `count` exceeds `wipLimit`. */
-  interface KanbanColumn {
-    id: string;
-    title: string;
-    color: string | null;
-    wipLimit: number | null;
-    collapsed: boolean;
-    cards: KanbanCard[];
-    count: number;
-    points: number;
-    over: boolean;
-  }
-
-  /** A column definition: an id string, or an object configuring one column. */
-  type KanbanColumnDef = string | {
-    id: string;
-    title?: string;
-    color?: string;
-    wipLimit?: number;
-    collapsed?: boolean;
-    /**
-     * A per-column SLA override (BACKLOG-0000960): a lone threshold read as the
-     * breach level, or a `{ warn, breach }` pair. Overrides the global `sla`
-     * thresholds for cards in this column (precedence: lane → column → global).
-     */
-    sla?: KanbanSlaThreshold | { warn?: KanbanSlaThreshold; breach?: KanbanSlaThreshold };
-    /** A per-column warn threshold — the shorthand for `sla: { warn }`. */
-    slaWarn?: KanbanSlaThreshold;
-    /** A per-column breach threshold — the shorthand for `sla: { breach }`. */
-    slaBreach?: KanbanSlaThreshold;
-  };
-
-  /** A card field editor handle returned by a host editor factory. */
-  interface KanbanEditor {
-    el: HTMLElement;
-    focus?: () => void;
-    destroy?: () => void;
-  }
-
-  /** A card field mapping: a property path, a function, or an object opting into inline edit. */
-  type KanbanFieldMap = string | ((row: KanbanRow) => unknown) | {
-    field: string;
-    edit?: boolean;
-    editor?: (ctx: { card: KanbanCard; field: string; value: string; commit: (value: unknown) => void; cancel: () => void }) => KanbanEditor;
-  };
-
-  /** The field-to-property mapping that drives the card template. */
-  interface KanbanCardMap {
-    title?: KanbanFieldMap;
-    subtitle?: KanbanFieldMap;
-    labels?: KanbanFieldMap;
-    assignee?: KanbanFieldMap;
-    due?: KanbanFieldMap;
-    cover?: KanbanFieldMap;
-    progress?: KanbanFieldMap;
-    badges?: KanbanFieldMap;
-    accent?: KanbanFieldMap;
-    [field: string]: KanbanFieldMap | undefined;
-  }
-
-  /** Granular readonly: the whole board, or selectively by column id and card key. */
-  type KanbanReadonly = boolean | {
-    board?: boolean;
-    columns?: Record<string, boolean>;
-    cards?: Record<string, boolean>;
-  };
-
-  /** The payload every board event carries. */
-  interface KanbanEvent {
-    card: KanbanCard;
-    column: string | null;
-    el?: unknown;
-    originalEvent?: unknown;
-  }
-
-  /**
-   * A card-aging / SLA threshold (BACKLOG-0000960): a raw millisecond count, or
-   * a `{ weeks, days, hours, minutes, seconds, ms }` spec whose fields are summed
-   * (`{ days: 3, hours: 12 }` → 3.5 days). A negative or non-finite value means
-   * "no threshold at this level".
-   */
-  type KanbanSlaThreshold = number | {
-    weeks?: number; week?: number; w?: number;
-    days?: number; day?: number; d?: number;
-    hours?: number; hour?: number; h?: number;
-    minutes?: number; minute?: number; m?: number; min?: number;
-    seconds?: number; second?: number; s?: number; sec?: number;
-    ms?: number; milliseconds?: number;
-  };
-
-  /**
-   * Card-aging / SLA configuration (BACKLOG-0000960). A card is measured against a
-   * `warn` and a `breach` threshold; the view puts an age chip on aged cards and a
-   * highlight on breached ones, and a rising crossing fires the `card:sla` event
-   * and the matching `onWarn`/`onBreach` callback (signature `(level, rows)`, the
-   * Data Router alert handler's). Thresholds resolve most-specific-first:
-   * lane → column → global. Reached at runtime as {@link Kanban#sla}.
-   */
-  interface KanbanSlaConfig {
-    /** The global warn threshold. */
-    warn?: KanbanSlaThreshold;
-    /** The global breach threshold. */
-    breach?: KanbanSlaThreshold;
-    /** Per-column overrides by column id (each a threshold or a `{ warn, breach }` pair). */
-    columns?: Record<string, KanbanSlaThreshold | { warn?: KanbanSlaThreshold; breach?: KanbanSlaThreshold }>;
-    /** Per-swimlane overrides by lane id (each a threshold or a `{ warn, breach }` pair). */
-    lanes?: Record<string, KanbanSlaThreshold | { warn?: KanbanSlaThreshold; breach?: KanbanSlaThreshold }>;
-    /**
-     * Where the ageing clock starts: `'column'` (default) measures time in the
-     * card's current column; `'board'` measures age since the card arrived/was
-     * created.
-     */
-    basis?: 'column' | 'board';
-    /** A row property holding the wall-clock time the card entered its column. */
-    enteredProperty?: string;
-    /** A row property holding the wall-clock time the card was created. */
-    createdProperty?: string;
-    /** Whether cards in a done column are exempt from ageing (default true). */
-    ignoreDone?: boolean;
-    /** Whether the flow transition log drives the ageing basis when present (default true). */
-    useTransitionLog?: boolean;
-    /** Show the age chip on every aged card (`'always'`), or only on warn/breach (`'threshold'`, default). */
-    showAge?: 'always' | 'threshold';
-    /** A wall-clock epoch clock, injectable for deterministic tests (default `Date.now`). */
-    now?: () => number;
-    /** A re-check interval in ms so a card breaching by sitting still still lights up (0 = off). */
-    tick?: number;
-    /** Called on a rising crossing to warn level, `(level, rows)` — the router alert handler's shape. */
-    onWarn?: (level: 'warn' | 'breach', rows: KanbanRow[]) => void;
-    /** Called on a rising crossing to breach level, `(level, rows)` — the router alert handler's shape. */
-    onBreach?: (level: 'warn' | 'breach', rows: KanbanRow[]) => void;
-  }
-
-  /** The computed SLA state of one card (BACKLOG-0000960). */
-  interface KanbanSlaState {
-    key: unknown;
-    columnId: string | null;
-    lane?: unknown;
-    /** The ageing-clock start epoch (ms), or null when no time source could be resolved. */
-    start: number | null;
-    /** The card's age in ms, or null when unknown. */
-    ageMs: number | null;
-    /** A short human age label (`2d`, `5h`, …), '' when unknown. */
-    ageText: string;
-    /** The resolved warn threshold in ms, or null. */
-    warnMs: number | null;
-    /** The resolved breach threshold in ms, or null. */
-    breachMs: number | null;
-    /** The classified level, or null when the card cannot be aged. */
-    level: 'ok' | 'warn' | 'breach' | null;
-    /** True when `level` is `'breach'`. */
-    breached: boolean;
-  }
-
-  /**
-   * The card-aging / SLA monitor (BACKLOG-0000960), reached as {@link Kanban#sla}
-   * when a `sla` config is supplied. Pure and DOM-free: it computes each card's
-   * ageing state from the board's card model and the flow transition log, and the
-   * view paints it.
-   */
-  interface KanbanSla {
-    /** The normalised SLA config (read-only). */
-    readonly config: object;
-    /** Recompute every card's SLA state without emitting anything. */
-    sync(): KanbanSla;
-    /** Recompute and fire `card:sla`/`onWarn`/`onBreach` on each rising crossing. */
-    evaluate(opts?: { emit?: boolean }): KanbanSlaState[];
-    /** Establish the baseline, notify on the current state, and start the optional tick. */
-    start(): KanbanSla;
-    /** The SLA state of one card (by card model or key), or null when unknown. */
-    stateFor(cardOrKey: KanbanCard | unknown): KanbanSlaState | null;
-    /** Every card's current SLA state. */
-    states(): KanbanSlaState[];
-    /** The cards currently at breach level. */
-    breaches(): KanbanSlaState[];
-    /** The cards currently at warn level (not yet breached). */
-    warnings(): KanbanSlaState[];
-    /** Stop the tick and drop the board subscriptions. */
-    destroy(): void;
-  }
-
-  /**
-   * Kanban configuration. Every structural property is named here so the same
-   * board maps DemandFlow (a status field, `points`, `sprint`, `epic`, a
-   * swimlane property) and any customer schema without code change.
-   */
-  interface KanbanConfig {
-    rows?: KanbanRow[];
-    grid?: unknown;
-    rowKey?: string | ((row: KanbanRow) => unknown);
-    columnProperty?: string;
-    columns?: KanbanColumnDef[];
-    columnOrder?: string[];
-    pointsProperty?: string;
-    showPoints?: boolean;
-    orderProperty?: string;
-    swimlaneProperty?: string;
-    /** Render the 2D swimlane layout using `swimlaneProperty` (default false). */
-    swimlanes?: boolean;
-    /** Explicit lane definitions; otherwise lanes come from the distinct swimlane values. */
-    lanes?: (string | { id: string; title?: string })[];
-    /** An explicit lane order by id (also set by a lane-header-drag reorder). */
-    laneOrder?: string[];
-    /** Enforce `wipLimit` as a hard gate: a move that would exceed it is refused (default false). */
-    enforceWip?: boolean;
-    /** A custom card template: return an HTML string or a DOM node to own the whole card body. */
-    cardRenderer?: (card: KanbanCard, ctx: { column: KanbanColumn; readonly: boolean; el: HTMLElement; doc: Document }) => string | Node | void;
-    sprintProperty?: string;
-    epicProperty?: string;
-    /** A configurable sprint dataset: the canonical sprint list (order + titles), shown even when empty. */
-    sprints?: (string | { id: unknown; title?: string })[];
-    /** The initially selected sprint id, `Kanban.BACKLOG`, or undefined for all. */
-    sprint?: unknown;
-    /** The initially selected epic id, or undefined for all. */
-    epic?: unknown;
-    /** Column ids that count as "done" for a rollup's progress (also a column def's `done: true`). */
-    doneColumns?: string[];
-    /** Card pop-out: a nested child grid or board (master-detail by composition). */
-    children?: KanbanChildren;
-    /** Card virtualization for tall columns: true, or `{ rowHeight, overscan, threshold, viewport }`. */
-    virtualize?: boolean | { rowHeight?: number; overscan?: number; threshold?: number; viewport?: number };
-    /**
-     * Card aging / SLA highlighting (BACKLOG-0000960): warn/breach thresholds
-     * (globally, per column and/or per lane) that age each card and fire
-     * `card:sla` on a rising crossing. Opt-in; reached at runtime as
-     * {@link Kanban#sla}. See {@link KanbanSlaConfig}.
-     */
-    sla?: KanbanSlaConfig;
-    /** A saved board state (from `getState`) to restore on construction. */
-    state?: object;
-    /** Show a per-column add-card affordance. */
-    addCard?: boolean;
-    /** Persist a standalone inline edit; return false or a rejected promise to revert. */
-    onCardEdit?: (event: { card: KanbanCard; key: unknown; field: string; fieldPath: string; value: unknown }) => boolean | void | Promise<boolean | void>;
-    /**
-     * Create a card for a column on add-card; return the row to create (with
-     * its key), a Promise of that row, or nothing to auto-generate. A rejected
-     * Promise creates no card and leaves the board unchanged (BACKLOG-0001230).
-     */
-    onAddCard?: (columnId: string) => KanbanRow | Promise<KanbanRow> | void;
-    /** A predicate filter over cards; only matching cards are shown. */
-    filter?: (row: KanbanRow, card: KanbanCard) => boolean;
-    /** Quick-filter text matched case-insensitively across card fields. */
-    quickFilter?: string;
-    card?: KanbanCardMap;
-    readonly?: KanbanReadonly;
-    ariaLabel?: string;
-    emptyText?: string;
-    /** Whether card selection is enabled (default true). */
-    selectable?: boolean;
-    /** Host-localised words for the move announcements (grabbed/moved/dropped/reverted/cancelled). */
-    labels?: Record<string, string>;
-    /**
-     * Veto/confirm a move before any write. Return `false` (or a promise of it)
-     * to refuse; `from`/`to` are column ids, `index` the target position.
-     */
-    onBeforeMove?: (card: KanbanCard, from: string | null, to: string, index: number | null) => boolean | Promise<boolean>;
-    /**
-     * Persist a move on a standalone (non-grid) board. Return `false` or a
-     * rejected promise to revert the optimistic move. On a grid-bound board the
-     * grid's write-back pipeline persists instead and this is not called.
-     */
-    onCardMove?: (event: KanbanMoveEvent) => boolean | void | Promise<boolean | void>;
-    /** A per-card context menu: items, or `fn(card, selectedCards)` returning items. Suppresses `card:contextmenu`. */
-    contextMenu?: KanbanMenuItem[] | ((card: KanbanCard, selected: KanbanCard[]) => KanbanMenuItem[]);
-    onCardClick?: (event: KanbanEvent) => void;
-    onCardDblClick?: (event: KanbanEvent) => void;
-    onCardContextMenu?: (event: KanbanEvent) => void;
-  }
-
-  /**
-   * Card pop-out configuration. The child view is a full composed grid (via
-   * `factory`, a `createGrid`), a nested board (`asBoard`), or a custom `render`.
-   * The child set is the rows whose `property` equals the card key, or the
-   * `load(card)` result. Recursion falls out: a nested board can pop its own
-   * children.
-   */
-  interface KanbanChildren {
-    /** Parent-id property linking child rows to a card within the same dataset. */
-    property?: string;
-    /** Per-card child rows, sync or async — an alternative (or addition) to `property`. */
-    load?: (card: KanbanCard) => KanbanRow[] | Promise<KanbanRow[]>;
-    /** Whether a card can be expanded, overriding the property/load inference. */
-    hasChildren?: (card: KanbanCard) => boolean;
-    /** Where the pop-out appears (default `drawer`). */
-    present?: 'drawer' | 'modal' | 'inline';
-    /** The grid factory (a `createGrid`) that builds the child grid. */
-    factory?: (container: HTMLElement, options: object) => { destroy?: () => void };
-    /** Make the child a nested board (recursive) instead of a grid. */
-    asBoard?: boolean;
-    /** Options for the child grid/board — an object or `fn(card)`. */
-    gridOptions?: object | ((card: KanbanCard) => object);
-    /** Fully custom child render; returns a cleanup function. */
-    render?: (container: HTMLElement, ctx: { card: KanbanCard; rows: KanbanRow[]; board: Kanban; depth: number }) => (void | (() => void));
-    /** The pop-out title (default the card title). */
-    title?: (card: KanbanCard) => string;
-  }
-
-  /** One context-menu item. `action` receives the card, the selected cards, and the board. */
-  interface KanbanMenuItem {
-    label: string;
-    action?: (ctx: { card: KanbanCard; cards: KanbanCard[]; board: Kanban }) => void;
-    disabled?: boolean;
-  }
-
-  /** The payload of a `card:move` (and `card:reverted`) event. */
-  interface KanbanMoveEvent {
-    keys: unknown[];
-    cards: KanbanCard[];
-    from: (string | null)[];
-    to: string;
-    index: number | null;
-    orders: number[] | null;
-  }
-
-  /** The keyed-diff consumer surface a board shares with a grid, so a Data Router routes to it directly. */
-  interface KanbanRows {
-    apply(change: { add?: KanbanRow[]; update?: KanbanRow[]; remove?: unknown[] }): void;
-    forEach(fn: (row: KanbanRow, key: unknown) => void): void;
-    readonly count: number;
-  }
-
-  /**
-   * Named card predicates, composed with AND (BACKLOG-0001229), following the
-   * grid's `filters.where` convention (BACKLOG-0001202). Several may be
-   * registered under different names at once; each can be replaced or removed
-   * without touching the others. `setFilter(fn)` is unchanged sugar for
-   * `where(DEFAULT, fn)` / `where(DEFAULT, null)`.
-   */
-  interface KanbanFilters {
-    /** The reserved name `board.setFilter` registers/removes under. */
-    readonly DEFAULT: string;
-    /** The registered names, in registration order. */
-    where(): string[];
-    /** Register or replace the predicate under `name`. */
-    where(name: string, predicate: (row: KanbanRow, card: KanbanCard) => boolean): Kanban;
-    /** Remove whatever is registered under `name`; a no-op if nothing was. */
-    where(name: string, predicate: null): Kanban;
-    /** Re-run every named predicate (or one, by name) and re-render. */
-    reapply(name?: string): boolean;
-  }
-
-  /**
-   * A board instance: a kanban view of grid rows as cards grouped into columns.
-   * It consumes data through the same keyed-diff `rows.apply` contract a grid
-   * exposes, so `dataRouter.attach(value, board)` drives it like any other
-   * viewer.
-   */
-  interface Kanban {
-    readonly el: unknown | null;
-    readonly rowKey: string | ((row: KanbanRow) => unknown);
-    rows: KanbanRows;
-    /** The card-aging / SLA monitor, present only when a `sla` config was supplied (BACKLOG-0000960). */
-    sla?: KanbanSla;
-    columns(): KanbanColumn[];
-    column(id: string): KanbanColumn | undefined;
-    count(id: string): number;
-    points(id: string): number;
-    cards(): KanbanCard[];
-    card(key: unknown): KanbanCard | undefined;
-    on(name: string, fn: (event: KanbanEvent) => void): () => void;
-    off(name: string, fn: (event: KanbanEvent) => void): void;
-    readonly(scope?: { column?: string; card?: unknown }): boolean;
-    /**
-     * Move one or more cards to a column (and, with an order property, to a
-     * position within it), through the `onBeforeMove` veto and the grid's
-     * shipped write-back path. The single entry point behind drag-and-drop and
-     * keyboard move.
-     */
-    move(keys: unknown | unknown[], toColumn: string, toIndex?: number | null, toLane?: string): Promise<{ moved: unknown[]; reverted: boolean }>;
-    /** The selected card keys. */
-    selection(): unknown[];
-    /** Whether a card is selected. */
-    isSelected(key: unknown): boolean;
-    /** Change the selection: `set` (replace), `add`, `toggle` or `remove`. */
-    select(keys: unknown | unknown[], mode?: 'set' | 'add' | 'toggle' | 'remove'): Kanban;
-    /** Clear the selection. */
-    clearSelection(): Kanban;
-    /** Collapse, expand or toggle a column (emits `column:collapse`). */
-    collapseColumn(id: string, collapsed?: boolean): Kanban;
-    /** Collapse, expand or toggle a swimlane (emits `swimlane:collapse`). */
-    collapseLane(id: string, collapsed?: boolean): Kanban;
-    /** Reorder the columns to the given id order (emits `column:reorder`). */
-    reorderColumns(order: string[]): Kanban;
-    /** Move one column before another (or to the end); emits `column:reorder`. */
-    moveColumn(id: string, beforeId: string | null): Kanban;
-    /** Reorder the swimlanes to the given id order (emits `swimlane:reorder`). */
-    reorderLanes(order: string[]): Kanban;
-    /** Move one swimlane before another (or to the end); emits `swimlane:reorder`. */
-    moveLane(id: string, beforeId: string | null): Kanban;
-    /** Named card predicates, composed with AND (BACKLOG-0001229). See {@link KanbanFilters}. */
-    filters: KanbanFilters;
-    /** Set a predicate filter over cards, or clear it with null. Sugar for `filters.where(filters.DEFAULT, fn)`. */
-    setFilter(fn: ((row: KanbanRow, card: KanbanCard) => boolean) | null): Kanban;
-    /** Set the quick-filter text matched across card fields. Independent of every `filters.where` predicate. */
-    setQuickFilter(text: string): Kanban;
-    /** Distinct values of a property with card counts — the raw material for a facet control. */
-    facets(property: string): { value: unknown; count: number }[];
-    /** The sentinel `setSprint` value that selects the backlog (cards with no sprint). */
-    readonly BACKLOG: unknown;
-    /** Select the shown sprint (`BACKLOG` for the backlog, undefined for all); emits `sprint:changed`. */
-    setSprint(sprint: unknown): Kanban;
-    /** Show only the backlog (cards with no sprint). */
-    showBacklog(): Kanban;
-    /** Select the shown epic (undefined for all); emits `epic:changed`. */
-    setEpic(epic: unknown): Kanban;
-    /** The distinct sprint values (the switcher's options); a configured `sprints` dataset pins the order. */
-    sprints(): unknown[];
-    /** The sprint dataset as `{ id, title }` descriptors — the configured list plus any data-only sprint. */
-    sprintDefs(): { id: unknown; title: string }[];
-    /** The distinct epic values. */
-    epics(): unknown[];
-    /** Roll rows up by a property: per-bucket count, points, done and progress. */
-    rollup(property: string): { value: unknown; count: number; points: number; doneCount: number; donePoints: number; progress: number }[];
-    /** The epic rollup (empty when no epic property is configured). */
-    epicRollup(): { value: unknown; count: number; points: number; doneCount: number; donePoints: number; progress: number }[];
-    /** Whether a card can be expanded to a child pop-out. */
-    canExpand(card: KanbanCard): boolean;
-    /** Open a card's children in a pop-out (drawer/modal/inline); emits `card:expand`/`card:drill`. */
-    expand(key: unknown): Promise<object | null>;
-    /** Close any open card pop-out. */
-    closeDetail(): Kanban;
-    /** Whether a mapped card field is opted into inline edit and writable. */
-    isFieldEditable(name: string): boolean;
-    /** Start inline editing a card's field (the grid's own field editor when bound); no-op headless. */
-    editCard(key: unknown, name?: string): object | null;
-    /** Commit an inline edit through the write-back path (grid.edit.setCells when bound); emits `card:edit`. */
-    applyEdit(key: unknown, name: string, value: unknown): Promise<boolean>;
-    /**
-     * Add a card to a column and open it in inline edit; emits `card:add`.
-     * Returns the new key directly, or a Promise of it when `onAddCard`
-     * returns a Promise or a `beforeAdd` handler defers (BACKLOG-0001230); a
-     * rejected `onAddCard` Promise resolves this to `null` with no card added.
-     */
-    addCard(columnId: string, seed?: KanbanRow): unknown | Promise<unknown>;
-    /** Serialise the restorable state: collapsed columns/lanes, order, filter, sprint/epic, selection. */
-    getState(): object;
-    /** Restore a state snapshot from {@link Kanban#getState}. */
-    setState(snapshot: object): Kanban;
-    /** Mark the board loading (renders a host-localised loading state). */
-    setLoading(loading: boolean): Kanban;
-    /** Set (or clear with null) an error state, rendered as a host-supplied message. */
-    setError(message: string | null): Kanban;
-    setRows(rows: KanbanRow[]): Kanban;
-    /**
-     * Replace the board's configured column set (BACKLOG-0001228). Keeps card
-     * placement and interaction state (collapsed columns, column order, quick
-     * filter, selection) for every column id that survives; a dropped id is
-     * not specially handled — a card whose value has nowhere configured to go
-     * re-derives an ad hoc column rather than becoming `unplaced` (the same
-     * "never silently drop a card" rule an unconfigured value already gets).
-     */
-    setColumns(defs: KanbanColumnDef[]): Kanban;
-    refresh(): Kanban;
-    destroy(): void;
-  }
-
-  /**
-   * Create a board (kanban) view of rows, grouped into columns by a configurable
-   * property. Pass a DOM element to render into, or `null` for a headless board
-   * that computes the same column/card model without a DOM.
-   */
-  export function createKanban(el: HTMLElement | null, config?: KanbanConfig): Kanban;
-  export default createKanban;
-}
-
-declare module 'lattice-grid/modules/kpi' {
-  /** A row backing a KPI aggregate: any object. Its identity comes from `rowKey`. */
-  type KPIRow = Record<string, unknown>;
-
-  /** The aggregation kinds a tile can compute. `custom` is a host reducer over the rows. */
-  type KPIAggregation = 'sum' | 'avg' | 'min' | 'max' | 'count' | 'countDistinct' | 'custom';
-
-  /** Number formatting for a tile value. `percent` treats the value as a ratio (0.42 → 42%). */
-  type KPIFormat =
-    | 'number' | 'currency' | 'percent' | 'compact'
-    | { type?: 'number' | 'currency' | 'percent' | 'compact'; decimals?: number; currency?: string; locale?: string };
-
-  /**
-   * A semantic threshold: two cut points and a direction. `higherIsBetter` (the
-   * default) makes a value at/above `warn` good, at/above `critical` a warning,
-   * below it critical; `lowerIsBetter` mirrors it. Colour is a host concern.
-   */
-  interface KPIThresholds {
-    warn: number;
-    critical: number;
-    direction?: 'higherIsBetter' | 'lowerIsBetter';
-  }
-
-  /** An explicit band: the `status` of the first band whose half-open `[min, max)` contains the value. */
-  interface KPIBand {
-    min?: number;
-    max?: number;
-    status: 'good' | 'warn' | 'critical';
-  }
-
-  /** An optional sparkline series: the `y` field plotted in order of the `x` field (or insertion). */
-  interface KPISparkline {
-    x?: string;
-    y: string | ((row: KPIRow) => unknown);
-  }
-
-  /** One tile: an aggregate over the routed rows, with optional filter, format, threshold and trend. */
-  interface KPITile {
-    /** A stable identity for the tile (defaults to the label, then the index). */
-    id?: string;
-    /** The tile's accessible label. */
-    label?: string;
-    /** The aggregation kind, or a reducer `(rows, tile) => value` for a custom tile. */
-    aggregation?: KPIAggregation | ((rows: KPIRow[], tile: object) => unknown);
-    /** The reducer for a `custom` aggregation, when `aggregation` is the string `'custom'`. */
-    compute?: (rows: KPIRow[], tile: object) => unknown;
-    /** The field the aggregation reads (a path or accessor). Ignored by `count`. */
-    field?: string | ((row: KPIRow) => unknown);
-    /** A predicate limiting the rows this tile aggregates. */
-    filter?: (row: KPIRow) => boolean;
-    /** Value formatting. */
-    format?: KPIFormat;
-    /** A comparison target rendered alongside the value. */
-    target?: number;
-    /** A baseline the tile's delta is measured against. */
-    baseline?: number;
-    /** Threshold bands, either two cut points or an explicit band list. */
-    thresholds?: KPIThresholds;
-    /** Explicit status bands (an alternative to `thresholds`). */
-    bands?: KPIBand[];
-    /** A trend sparkline series. */
-    sparkline?: KPISparkline | string;
-  }
-
-  /**
-   * The hierarchy a KPI panel arranges its tiles into (BACKLOG-0001059): a rail
-   * of top-level items that expand to the indicators beneath them, each parent
-   * highlighted with the worst status below it.
-   *
-   * The shape is declared with `path` or `parentKey` — the same two shapes the
-   * grid's tree data and the tree-select editor take — over the **tile specs**,
-   * not the rows. With neither declared, one is derived by splitting the tile
-   * ids on `separator`, so `system.compute.cpu` files itself under Compute
-   * under System. A panel whose ids carry no separator stays flat, and `false`
-   * keeps it flat whatever they look like.
-   *
-   * A tile's `field` is never a source: a dot there already means a nested
-   * object property.
-   */
-  interface KPITreeConfig {
-    /** The tile's own place in the hierarchy, its own segment last. */
-    path?: (tile: KPITile) => (string | number)[];
-    /** The id of the tile this one sits under, or a reader for it. */
-    parentKey?: string | ((tile: KPITile) => unknown);
-    /** The heading tiles whose parent is not in the panel are gathered under. */
-    orphans?: 'root' | string;
-    /** The separator a derived hierarchy splits a tile id on. Defaults to `.`. */
-    separator?: string;
-    /** Which branches start open: every one (`true`), or these node keys. */
-    expanded?: true | string[];
-  }
-
-  /**
-   * One node of the rail.
-   *
-   * **No value rolls up.** `value` and `formatted` are the node's own tile's
-   * reading, and are `null` on a level the hierarchy synthesised, because the
-   * running accumulators cannot be composed without a rescan.
-   *
-   * **Severity does.** `rollup` is the worst status at or below the node, which
-   * is what a collapsed branch reports. `unknown` is excluded from it on
-   * purpose — ranking "nothing was measured" as the worst would hide a real
-   * warning underneath it — and is surfaced as `unknown`, a count of the
-   * descendants that measured nothing, so neither can pass unnoticed.
-   */
-  interface KPINodeModel {
-    /** The node's stable identity: the tile id, or the path of a synthesised level. */
-    key: string;
-    /** The tile id, or null on a synthesised level. */
-    id: string | null;
-    label: string;
-    /** Depth, 0 at the top level. */
-    level: number;
-    /** Its place among its siblings, from 1, and how many there are. */
-    posinset: number;
-    setsize: number;
-    hasChildren: boolean;
-    expanded: boolean;
-    children: KPINodeModel[];
-    /** The node's own tile, or null on a synthesised level. */
-    tile: KPITileModel | null;
-    value: unknown;
-    formatted: string | null;
-    /** The node's own status. */
-    status: 'good' | 'warn' | 'critical' | 'unknown' | null;
-    /** The worst status at or below the node. Never `unknown`. */
-    rollup: 'good' | 'warn' | 'critical' | null;
-    /** How many tiles at or below the node measured nothing. */
-    unknown: number;
-    /** How many tiles are at or below the node. */
-    items: number;
-  }
-
-  /** A computed tile, as it appears in the model. */
-  interface KPITileModel {
-    id: string;
-    label: string;
-    aggregation: string;
-    field?: string;
-    value: unknown;
-    formatted: string;
-    /**
-     * The tile's semantic band, or `unknown` when the tile measured nothing.
-     * `unknown` is decided from data presence before any threshold is
-     * consulted: an aggregation over nothing returns the identity of its
-     * operation (`sum` and `count` return 0), and 0 is a number a threshold
-     * grades, so without it an empty panel would report as a healthy one.
-     *
-     * Two things make a tile `unknown`: the panel holds no rows at all, or the
-     * tile's `field` names no column on the bound grid, so it never read a cell
-     * to reduce over. A tile whose `filter` matches none of the rows the panel
-     * *does* hold is neither — it has measured a real zero and is banded
-     * normally. `null` means the tile has no thresholds or bands configured.
-     */
-    status: 'good' | 'warn' | 'critical' | 'unknown' | null;
-    target?: number;
-    baseline?: number;
-    delta: number | null;
-    deltaPercent: number | null;
-    deltaFormatted?: string;
-    count: number;
-    sparkline: number[] | null;
-  }
-
-  /** The payload every tile event carries. */
-  interface KPIEvent {
-    tile: KPITileModel;
-    id: string;
-    originalEvent?: unknown;
-  }
-
-  /** KPI panel configuration. */
-  interface KPIConfig {
-    rows?: KPIRow[];
-    grid?: unknown;
-    rowKey?: string | ((row: KPIRow) => unknown);
-    /**
-     * Extra columns of the bound `grid` to project onto the rows a tile `filter`
-     * sees, beyond the fields the tiles themselves declare. A grid-bound panel
-     * hands a filter a projection, not a whole grid row, so a filter over a
-     * column no tile names would otherwise read `undefined` and report a
-     * confident zero. Ignored on a panel over a plain `rows` array.
-     */
-    fields?: string[];
-    tiles?: KPITile[];
-    columns?: number;
-    ariaLabel?: string;
-    nullText?: string;
-    /** Arrange the tiles as a hierarchy; `false` keeps the panel flat. */
-    tree?: KPITreeConfig | false;
-    /**
-     * The catalogue the panel's own text is read from. A panel routinely has no
-     * grid to borrow one off — two of its three input modes have none — so this
-     * is the first-class way to translate it. A grid's own `messages` satisfies
-     * the shape; a key it does not carry falls back to English.
-     */
-    messages?: { t(key: string, params?: Record<string, unknown>): string };
-    onTileClick?: (event: KPIEvent) => void;
-    onTileDblClick?: (event: KPIEvent) => void;
-    onTileContextMenu?: (event: KPIEvent) => void;
-    onNodeToggle?: (event: { key: string; expanded: boolean; node?: KPINodeModel }) => void;
-    onChange?: (event: { model: { tiles: KPITileModel[]; nodes?: KPINodeModel[] } }) => void;
-  }
-
-  /** The keyed-diff consumer surface a KPI panel shares with a grid, so a Data Router routes to it directly. */
-  interface KPIRows {
-    apply(change: { add?: KPIRow[]; update?: KPIRow[]; remove?: unknown[] }): void;
-    forEach(fn: (row: KPIRow, key: unknown) => void): void;
-    readonly count: number;
-  }
-
-  /**
-   * A KPI / stat-tile panel: a grid of aggregate tiles over a dataset. It
-   * consumes data through the same keyed-diff `rows.apply` contract a grid
-   * exposes, so `dataRouter.attach(value, kpi)` drives it like any other viewer,
-   * updating each tile incrementally from the routed delta.
-   */
-  interface KPI {
-    readonly el: unknown | null;
-    readonly rowKey: string | ((row: KPIRow) => unknown);
-    /** Whether the panel renders as a hierarchy rather than a flat tile grid. */
-    readonly tree: boolean;
-    rows: KPIRows;
-    tiles(): KPITileModel[];
-    tile(id: string): KPITileModel | undefined;
-    value(id: string): unknown;
-    /** The top-level nodes of the hierarchy. Empty on a flat panel. */
-    nodes(): KPINodeModel[];
-    /** One node by its key, at any depth. */
-    node(key: string): KPINodeModel | undefined;
-    /** The nodes on screen: the roots, plus the children of every open branch. */
-    visibleNodes(): KPINodeModel[];
-    expand(key: string): KPI;
-    collapse(key: string): KPI;
-    toggle(key: string): KPI;
-    setRows(rows: KPIRow[]): KPI;
-    refresh(): KPI;
-    getState(): object;
-    setState(snapshot: object): KPI;
-    on(name: string, fn: (event: KPIEvent) => void): () => void;
-    off(name: string, fn: (event: KPIEvent) => void): void;
-    destroy(): void;
-  }
-
-  /**
-   * Create a KPI / stat-tile panel over rows or a bound grid. Pass a DOM element
-   * to render into, or `null` for a headless panel that computes the same tile
-   * model without a DOM.
-   */
-  export function createKPI(el: HTMLElement | null, config?: KPIConfig): KPI;
-  export default createKPI;
-}
-
-declare module 'lattice-grid/modules/ai' {
-  /**
-   * The provider-agnostic model callback the host supplies (BACKLOG-0000965).
-   * The module never imports a provider SDK, reads a key, or makes a network
-   * call — it builds this payload and awaits the host's reply. A host may wrap a
-   * chat provider (`{ text }`), a completion (a bare string), a tool-calling turn
-   * (`{ toolCalls }`), or a structured provider (`{ structured }`).
-   */
-  type AIAsk = (payload: {
-    /** The narrate-only system instruction. */
-    system: string;
-    /** The single user message: the facts block and the ask. */
-    message: string;
-    /** System and message joined, for a completion-shaped provider. */
-    prompt: string;
-    /** The running chat, including any tool results, for a chat-shaped provider. */
-    messages: Array<{ role: string; content: string; [k: string]: unknown }>;
-    /** The read-only tool definitions, present only on the tool-use path. */
-    tools?: object[];
-    /** The grid's generated schema (no row values). */
-    schema?: unknown;
-    /** An abort signal the host should honour. */
-    signal?: AbortSignal;
-  }) => Promise<
-    | string
-    | { text?: string; content?: string; toolCalls?: object[]; structured?: unknown }
-  >;
-
-  /** A single computed figure a narrative is grounded on. */
-  interface AIFact {
-    id: string;
-    label: string;
-    /** The raw numeric value, or null for a context-only fact. */
-    value: number | null;
-    /** The pre-formatted display string the model is told to use verbatim. */
-    display: string;
-    kind: string;
-    colId?: string;
-  }
-
-  /**
-   * A narrative target. `view` narrates the current filtered view; `column`
-   * narrates one column's profile; `forecast` adds its projection; `kpi`/`chart`
-   * narrate figures the caller passes through in `facts`; `risk` assembles a
-   * project RISK SUMMARY from the separate Gantt / Kanban modules' public outputs
-   * (BACKLOG-0000979).
-   */
-  interface AITarget {
-    kind?: 'view' | 'column' | 'forecast' | 'kpi' | 'chart' | 'risk';
-    colId?: string;
-    /** Forecast options, for `kind: 'forecast'`. */
-    options?: object;
-    /** Caller-supplied figures for a KPI/chart Explain, grounded like the rest. */
-    facts?: Array<{ id?: string; label: string; value: unknown; display?: string; kind?: string; colId?: string }>;
-    /**
-     * For `kind: 'risk'`: a Gantt instance (from `createGantt`). Read duck-typed
-     * for `earnedValue()` (SPI/CPI/variances) and `schedule` (critical path,
-     * float). The AI bundle never imports the Gantt module.
-     */
-    gantt?: unknown;
-    /**
-     * For `kind: 'risk'`: a Kanban board (from `createKanban`). Read for its
-     * `board.sla` monitor (breach / warning counts). The AI bundle never imports
-     * the Kanban module.
-     */
-    board?: unknown;
-    /** For `kind: 'risk'`: an SLA monitor, if not reached through `board`. */
-    sla?: unknown;
-    /** For `kind: 'risk'`: a precomputed `gantt.earnedValue()` result. */
-    earnedValue?: object;
-    /** For `kind: 'risk'`: a precomputed `gantt.schedule` result. */
-    schedule?: object;
-    /** For `kind: 'risk'`: precomputed SLA breach states. */
-    breaches?: object[];
-    /** For `kind: 'risk'`: precomputed SLA warning states. */
-    warnings?: object[];
-    /** For `kind: 'risk'`: options passed to `gantt.earnedValue()`. */
-    evmOptions?: object;
-    /**
-     * For `kind: 'risk'`: expose the at-risk task NAMES (off by default — a risk
-     * summary carries aggregates only unless the host opts in).
-     */
-    includeTaskNames?: boolean;
-    /**
-     * For `kind: 'risk'`: expose the money figures BAC/PV/EV/AC (off by default).
-     */
-    includeCost?: boolean;
-    /** For `kind: 'risk'`: cap on named at-risk tasks (default 10). */
-    maxTasks?: number;
-  }
-
-  /** The facts packet a narrative grounds on. */
-  interface AIFactsPacket {
-    target: AITarget;
-    facts: AIFact[];
-    /** The numeric values seeding the reconciliation registry. */
-    groundedValues: number[];
-    meta: {
-      kind: string; filtered: boolean; factCount: number; redacted?: boolean; colId?: string;
-      /** For `kind: 'risk'`: which module sources resolved. */
-      sources?: { schedule: boolean; earnedValue: boolean; sla: boolean };
-      /** For `kind: 'risk'`: which opt-in exposures were honoured. */
-      exposed?: { taskNames: boolean; cost: boolean };
-    };
-  }
-
-  /**
-   * The risk facts a board / Gantt risk summary grounds on (BACKLOG-0000979),
-   * from {@link buildRiskFacts}: the facts plus which module sources resolved and
-   * which opt-in exposures (task names, cost) were honoured.
-   */
-  interface AIRiskFacts {
-    facts: AIFact[];
-    meta: {
-      kind: 'risk';
-      sources: { schedule: boolean; earnedValue: boolean; sla: boolean };
-      exposed: { taskNames: boolean; cost: boolean };
-    };
-  }
-
-  /** The result of a narrative: reconciled prose plus what grounded and what did not. */
-  interface AINarrative {
-    /** The narrative, with every ungrounded figure stripped (or flagged). */
-    text: string;
-    facts: AIFact[];
-    /** The figures that reconciled against a computed value. */
-    grounded: string[];
-    /** The figures removed as ungrounded. */
-    flagged: string[];
-    packet: AIFactsPacket;
-    /** How many ask() rounds ran (>1 only on the tool-use path). */
-    rounds: number;
-    mode: 'tools' | 'packet';
-  }
-
-  /** AI module configuration. */
-  interface AIConfig {
-    /** The host's model callback. Falls back to the grid's `ai.ask` when omitted. */
-    ask?: AIAsk;
-    /** Opt into specific features: `'narrative'`, `'insights'`, `'query'`/`'ask'`. All on when omitted. */
-    enable?: string[];
-    /**
-     * Ask-your-data: apply a safe (read-only) query result without a confirm
-     * step. Off by default — the resolved query is shown and waits for Apply.
-     */
-    autoApply?: boolean;
-    /**
-     * A Data Router instance; on applying a query the answer rows are fanned to
-     * its attached viewers (grid + chart + KPI together) via `load()`.
-     */
-    router?: unknown;
-    /** Budgets passed to the schema builder for ask-your-data. */
-    schemaOptions?: object;
-    /** Extra context passed through to `ask()`. */
-    context?: unknown;
-    /** Called with each ask-your-data result. */
-    onQuery?: (result: AIQueryResult) => void;
-    /** Called with each governed-actor proposal (Play C), before any approval. */
-    onProposal?: (result: AIProposal) => void;
-    /**
-     * A Kanban board (from `createKanban`) the governed actor writes moves
-     * through: an NL card move applies via the board's own `beforeMove` gate
-     * (BACKLOG-0000967), never a kanban-specific write bypass.
-     */
-    board?: unknown;
-    /** Cap on rows any tool result carries to `ask()`. */
-    maxRows?: number;
-    /** Columns whose values must never leave the browser. */
-    redact?: string | string[] | ((colId: string) => boolean);
-    /** Force tool-use on or off; auto-detected from how `ask` was supplied otherwise. */
-    tools?: boolean;
-    /** Locale for figure formatting. */
-    locale?: string;
-    /** Column cap for a view summary. */
-    maxColumns?: number;
-    /** What to do with an ungrounded figure: `'strip'` (default) or `'flag'`. */
-    reconcile?: 'strip' | 'flag';
-    /** An element to mount the insights panel into. */
-    element?: HTMLElement;
-    /** Called when a narrative is produced. */
-    onNarrative?: (result: AINarrative) => void;
-    /** Called when `ask()` errors; the grid stays usable. */
-    onError?: (error: { error: unknown; target: AITarget }) => void;
-  }
-
-  /** The report from applying an ask-your-data query. */
-  interface AIApplyReport {
-    ok: boolean;
-    /** The action types that were applied. */
-    applied: string[];
-    /** Actions that threw while applying. */
-    failed: Array<{ type: string; reason: string }>;
-    /** Actions refused by the read-only gate — a mutation is never applied. */
-    refused: Array<{ type: string; reason: string }>;
-    /** How many answer rows were fanned to a router's viewers. */
-    fannedOut: number;
-  }
-
-  /**
-   * The result of an ask-your-data question (BACKLOG-0000966): a validated,
-   * READ-ONLY query spec — never rows — that the host reviews before applying.
-   */
-  interface AIQueryResult {
-    /** True when the spec is safe to apply: at least one read, nothing unsafe. */
-    ok: boolean;
-    /** The user's question. */
-    question: string;
-    /** The core plan (from `grid.ai.plan`). */
-    plan: Record<string, unknown>;
-    /** The read-only actions that will run — the validated query spec. */
-    actions: object[];
-    /** Actions refused as not read-only (a mutation the model asked for). */
-    unsafe: Array<{ type: string; reason: string }>;
-    /** Parts the core validator dropped (unknown column, bad operator, …). */
-    rejected: Array<{ at: string; what: string; reason: string }>;
-    /** The model's own one-line summary, if any. */
-    explain: string;
-    /** The validated query spec as data. */
-    spec: { actions: object[] };
-    /** The apply report once applied, or null. */
-    applied: AIApplyReport | null;
-    /** The resolved query in one human sentence, from the validated spec. */
-    describe(): string;
-    /** Apply the query (re-gated), fanning the answer to a router if configured. */
-    apply(opts?: { router?: unknown; onResult?: (rows: object[]) => void }): AIApplyReport;
-  }
-
-  /** One before/after change in a governed-actor proposal (BACKLOG-0000967). */
-  interface AIDiffEntry {
-    /** The target row key. */
-    key: string;
-    /** A human label identifying the row (a name-like column, else the key). */
-    rowLabel: string;
-    /** The target column id. */
-    colId: string;
-    /** The column's title, for the diff header. */
-    colTitle: string;
-    /** The current stored value. */
-    oldValue: unknown;
-    /** The current value as shown (a lookup id mapped to its label). */
-    oldDisplay: string;
-    /** The proposed stored value (a label resolved to its option id). */
-    newValue: unknown;
-    /** The proposed value as shown. */
-    newDisplay: string;
-  }
-
-  /**
-   * A governed-actor proposal (Play C, BACKLOG-0000967): the model's structured
-   * edits, VALIDATED and resolved against the current view — never written until
-   * a human approves. `apply()` writes ONLY through the grid's own gate.
-   */
-  interface AIProposal {
-    /** True when there is at least one applicable change and nothing needs a pick first. */
-    ok: boolean;
-    /** The user's instruction. */
-    instruction: string;
-    /** `'view'` (the filtered set, the default) or `'all'` (an opted-in widen). */
-    scope: 'view' | 'all';
-    /** How many rows the scope covers. */
-    scopeCount: number;
-    /** The scope in words, always stated in the confirm/diff. */
-    scopeText: string;
-    /** Whether any proposal was a bulk (`scope:'view'`) edit. */
-    bulk: boolean;
-    /** The before/after diff — exactly what would change. Nothing is written yet. */
-    diff: AIDiffEntry[];
-    /** Proposals refused before apply (unknown column, unknown label, bad type/range, no match). */
-    rejected: Array<{ reason: string; [k: string]: unknown }>;
-    /** Matches needing a human pick (>1 row for one phrase), with candidates. */
-    ambiguous: Array<{ reason: string; candidates: Array<{ key: string; label: string }>; [k: string]: unknown }>;
-    /** Named targets found only outside the view, offered for an opt-in widen. */
-    outOfView: Array<{ reason: string; candidates: Array<{ key: string; label: string }>; [k: string]: unknown }>;
-    /** Matches whose value already equals the ask (nothing to change). */
-    noops: Array<{ reason: string; [k: string]: unknown }>;
-    /** The apply report once applied, or null. */
-    applied: AIProposalReport | null;
-    /** The proposal in one human sentence, always stating the scope. */
-    describe(): string;
-    /** Apply the approved diff through the gate (`beforeEdit`, or `beforeMove` for a board). */
-    apply(opts?: { board?: unknown }): Promise<AIProposalReport>;
-  }
-
-  /** The report from applying a governed-actor proposal. */
-  interface AIProposalReport {
-    /** True when at least one edit landed. */
-    ok: boolean;
-    /** How many edits landed through the gate. */
-    applied: number;
-    /** How many edits were attempted. */
-    requested: number;
-    /** How many were stopped by a before-handler veto. */
-    vetoed: number;
-    /** Which gated path applied them: `'setCells'`, `'board.move'`, or `'none'`. */
-    via: string;
-  }
-
-  /**
-   * An AI controller over a live grid. It explains the grid's computed figures
-   * (Play A), answers questions with validated read-only query specs (Play B),
-   * and PROPOSES governed edits a human approves and the grid's own gate applies
-   * (Play C). `grid.ai` (in core) is the complementary intent/plan skill layer
-   * this consumes.
-   */
-  interface AI {
-    /** The mounted insights panel element, or null. */
-    readonly el: HTMLElement | null;
-    /** Whether a usable `ask()` is configured. */
-    readonly ready: boolean;
-    /** Produce a grounded, reconciled narrative for a target. */
-    explain(target?: AITarget, opts?: object): Promise<AINarrative>;
-    /** An alias for {@link AI.explain}. */
-    narrate(target?: AITarget, opts?: object): Promise<AINarrative>;
-    /**
-     * Produce a grounded, reconciled board / Gantt RISK SUMMARY
-     * (BACKLOG-0000979): a plain-language reading like "3 tasks at risk on the
-     * critical path, SPI 0.67, 2 SLA breaches". A convenience over
-     * `explain({ kind: 'risk', ... })`; the module sources go in `sources`
-     * (`gantt`, `board`/`sla`, or precomputed outputs). Every figure runs through
-     * the same reconciliation guard as {@link AI.explain}.
-     */
-    riskSummary(sources?: {
-      gantt?: unknown; board?: unknown; sla?: unknown;
-      earnedValue?: object; schedule?: object; breaches?: object[]; warnings?: object[];
-      includeTaskNames?: boolean; includeCost?: boolean; maxTasks?: number; evmOptions?: object;
-    }, opts?: object): Promise<AINarrative>;
-    /** Mount (or re-target) the insights panel into an element. */
-    insights(el?: HTMLElement, opts?: object): AI;
-    /** Build an "Explain" button bound to a target. */
-    attachExplain(target: AITarget, opts?: object): HTMLElement | null;
-    /** Build the facts packet for a target without calling `ask()`. */
-    facts(target?: AITarget, opts?: object): AIFactsPacket;
-    /**
-     * Ask-your-data: turn a question into a validated, read-only query spec, run
-     * it in the engine, and (on apply) fan the answer to router-attached viewers.
-     * Returns a result the host reviews; `autoApply` applies a safe read for you.
-     */
-    query(question: string, opts?: {
-      autoApply?: boolean; router?: unknown; schemaOptions?: object;
-      context?: unknown; tools?: boolean; signal?: AbortSignal;
-      onResult?: (rows: object[]) => void;
-    }): Promise<AIQueryResult>;
-    /** Apply a reviewed query result (the confirm path); re-gated at the seam. */
-    applyQuery(result: AIQueryResult, opts?: { router?: unknown; onResult?: (rows: object[]) => void }): AIApplyReport;
-    /** Mount the ask-your-data bar (input, Ask, auto-apply toggle, preview, Apply/Discard). */
-    askBar(el?: HTMLElement, opts?: object): AI;
-    /**
-     * Governed actor (Play C): ask the model for structured edit PROPOSALS over
-     * the current view, validate and resolve them (label -> stored value, locate
-     * a named row, reject unknown columns/labels/out-of-range), and return a
-     * reviewable {@link AIProposal} with a before/after diff. NOTHING is written
-     * — the model proposes; a human approves.
-     */
-    propose(instruction: string, opts?: {
-      widen?: boolean; board?: unknown; schemaOptions?: object; maxRows?: number;
-      context?: unknown; redact?: string | string[] | ((colId: string) => boolean);
-      signal?: AbortSignal;
-    }): Promise<AIProposal>;
-    /**
-     * Apply an approved proposal — the human-approval step. Writes ONLY through
-     * the gate: a grid cell edit via `grid.edit.setCells({ origin: 'ai' })` (the
-     * `beforeEdit` veto), a kanban move via `board.move({ origin: 'ai' })` (the
-     * `beforeMove` veto). A vetoing host handler stops the write.
-     */
-    applyProposal(result: AIProposal, opts?: { board?: unknown }): Promise<AIProposalReport>;
-    /**
-     * Mount the governed-actor bar: an instruction input, Propose, a before/after
-     * diff preview stating the scope, and Approve/Discard. Approve applies
-     * through the gate.
-     */
-    actorBar(el?: HTMLElement, opts?: object): AI;
-    on(name: 'narrative' | 'query' | 'proposal' | 'error' | string, fn: (payload: object) => void): () => void;
-    off(name: string, fn: (payload: object) => void): void;
-    destroy(): void;
-  }
-
-  /**
-   * Create an AI narrative / insights controller over a live grid. The grid may
-   * be headless or rendered; the module grounds every figure on the grid's
-   * engine and calls only the host's `ask()`.
-   */
-  export function createAI(grid: unknown, config?: AIConfig): AI;
-
-  /**
-   * Build the RISK-SUMMARY facts packet (BACKLOG-0000979) from the separate
-   * Gantt / Kanban modules' public outputs — SPI/CPI and variances from
-   * `gantt.earnedValue()`, tasks at risk / on the critical path from
-   * `gantt.schedule`, and SLA breaches from `board.sla`. Reads the module
-   * instances (or their precomputed outputs) duck-typed off `target`; the AI
-   * bundle imports neither module. This is the exact grounded set
-   * `explain({ kind: 'risk' })` would use, exposed for preview and testing.
-   */
-  export function buildRiskFacts(target: AITarget, opts?: {
-    locale?: string; fmt?: (value: number) => string;
-  }): AIRiskFacts;
-
-  export default createAI;
-}
-
-declare module 'lattice-grid/modules/tabs' {
-  /**
-   * One tab: an id, a display label, a grid config, and — for a derived tab —
-   * the parent tab id plus the narrowing forwarded onto the derived source
-   * built for it (`source: { mode: 'derived', from: <parent's grid>, ... }`).
-   * The derivation keys are the ones `packages/core/src/source/derive.js`
-   * already understands; this module invents none of its own.
-   */
-  interface TabDescriptor {
-    /** A stable, unique id. Required. */
-    id: string;
-    /** The tab button's text. Defaults to `id`. */
-    label?: string;
-    /** The grid config passed to `createGrid` for this tab (merged with the derived `source`, when `from` is set). */
-    config?: object;
-    /** The parent tab id to derive from. When set, `config.source` is built for you and any of your own is replaced (with a warning). */
-    from?: string;
-    /** Row predicate forwarded to the derived source. */
-    where?: (row: unknown) => boolean;
-    /** Group-by forwarded to the derived source. */
-    group?: unknown;
-    groupBy?: unknown;
-    /** Time-bucketing forwarded to the derived source. */
-    bucket?: unknown;
-    /** Join spec forwarded to the derived source. */
-    join?: unknown;
-    /** Array-field unnesting forwarded to the derived source. */
-    unnest?: unknown;
-    /** `'live' | 'idle' | 'manual' | number` forwarded to the derived source. */
-    refresh?: 'live' | 'idle' | 'manual' | number;
-    /** Cross-filter wiring forwarded to the derived source. */
-    crossFilter?: unknown;
-    /** Which slice of the parent's rows to derive from: `'filtered' | 'all' | 'selected' | 'grouped'`. */
-    follow?: 'filtered' | 'all' | 'selected' | 'grouped';
-    /** Row limit forwarded to the derived source. */
-    limit?: number;
-    /** Sort forwarded to the derived source. */
-    sort?: unknown;
-    /** Statistical-profile derivation, forwarded to the derived source. */
-    profile?: unknown;
-    /** This tab's panel's own `aria-label`, when the label alone is not enough context. */
-    ariaLabel?: string;
-  }
-
-  /** The payload every tab-change event carries. */
-  interface TabChangeEvent {
-    id: string;
-    previousId: string | null;
-    origin?: 'api' | 'user' | 'init';
-    reason?: string | null;
-    /** Cancel the switch (only meaningful on `beforeTabChange`). */
-    preventDefault?: (reason?: string) => void;
-    defaultPrevented?: boolean;
-  }
-
-  /** Tabbed-grid configuration. */
-  interface TabsConfig {
-    /** The grid factory to mount each tab with, e.g. `import { createGrid } from 'lattice-grid'`. Required. */
-    createGrid: (el: HTMLElement, config: object) => unknown;
-    /** The tabs, in display order. Required, at least one. */
-    tabs: TabDescriptor[];
-    /** The initially active tab id. Defaults to the first tab. */
-    active?: string;
-    /** The tablist landmark's accessible name. */
-    ariaLabel?: string;
-    /** An explicit message-catalogue override; otherwise a mounted tab's own `grid.messages` is used. */
-    messages?: { t(key: string, params?: Record<string, unknown>): string };
-    onTabChange?: (event: TabChangeEvent) => void;
-    onBeforeTabChange?: (event: TabChangeEvent) => boolean | void | Promise<boolean>;
-    onTabChangeCancelled?: (event: TabChangeEvent) => void;
-  }
-
-  /**
-   * A tabbed grid: a `role="tablist"` strip above a stack of `role="tabpanel"`
-   * regions, each hosting its own, independently-configured grid instance
-   * (BACKLOG-0001039). A tab's grid mounts on first activation and is kept
-   * alive, hidden, until `destroy()`.
-   */
-  interface Tabs {
-    readonly el: HTMLElement;
-    /** The currently active tab id. */
-    readonly activeId: string;
-    /** The configured tab ids, in order. */
-    tabs(): string[];
-    /** The live grid instance for a tab, or `null` before it has been materialised. */
-    tab(id: string): unknown | null;
-    /** Whether a tab's grid has been created yet. */
-    isMounted(id: string): boolean;
-    /** Switch the active tab, gated by `beforeTabChange`. */
-    activate(id: string, opts?: { origin?: 'api' | 'user' }): boolean | Promise<boolean>;
-    on(name: 'beforeTabChange' | 'tab:changed' | 'tabChange:cancelled' | string, fn: (event: TabChangeEvent) => void): () => void;
-    off(name: string, fn: (event: TabChangeEvent) => void): void;
-    /** Tear the whole strip down; destroys every mounted tab's grid. */
-    destroy(): void;
-  }
-
-  /**
-   * Create a tabbed grid over a host element. Each tab is a full,
-   * independently-configured grid instance; a tab may derive from another via
-   * `from`, reusing the shipped `source: { mode: 'derived' }` mechanism.
-   */
-  export function createTabs(el: HTMLElement, config: TabsConfig): Tabs;
-  export default createTabs;
-}
-
-declare module 'lattice-grid/modules/layout' {
-  /**
-   * One window on the cell grid.
-   *
-   * Deliberately **not** named `WindowSpec`: that name is already taken by the
-   * rolling-statistics window (`{ kind: 'count'|'time'|'session', span, size }`)
-   * and reusing it would put `kind: 'session'` next to a dashboard pane.
-   */
-  interface LayoutWindow {
-    /** A stable, unique id. Required. */
-    id: string;
-    /** The 1-based column the window starts in. Auto-placed when omitted. */
-    xPos?: number;
-    /** The 1-based row the window starts in. Auto-placed when omitted. */
-    yPos?: number;
-    /** How many columns it spans (default 1). */
-    xSize?: number;
-    /** How many rows it spans (default 1). */
-    ySize?: number;
-    /** The title shown in the chrome bar, and the name every control takes. */
-    title?: string;
-    /** Whether to draw the title bar (default `true`). */
-    chrome?: boolean;
-    /** Whether to offer a close button (default `false`). */
-    closable?: boolean;
-    /** Whether the window can be moved by drag or keyboard (default `false`). */
-    movable?: boolean;
-    /** Whether the window can be resized by drag or keyboard (default `false`). */
-    resizable?: boolean;
-    /**
-     * Whether to offer a maximise control in the chrome (default `false`).
-     *
-     * Maximising fills the **layout host**, not the browser window, and hides
-     * every other window for the duration. Escape restores it, unless a payload
-     * has already claimed the key.
-     */
-    maximisable?: boolean;
-    /**
-     * Whether to offer a minimise control in the chrome (default `false`).
-     *
-     * A window with `chrome: false` cannot be minimised whatever this says:
-     * there would be nothing left on screen to restore it with.
-     */
-    minimisable?: boolean;
-    /** Padding inside the window; the layout's `padding` (default `'5px'`) otherwise. */
-    padding?: number | string;
-    /** The `id` given to the payload container (default `` `${id}-body` ``). */
-    payloadId?: string;
-    /** The window's accessible name, when the title alone is not enough context. */
-    ariaLabel?: string;
-  }
-
-  /**
-   * The three capabilities a layout-level default and `setInteractive()` cover.
-   *
-   * These are the layout **defaults**, not the per-window resolution: a window
-   * that declared `movable: false` stays pinned whatever these say.
-   *
-   * Three values, not two. `undefined` means no layout-level default is in force
-   * and each window's own flag decides; `true` unlocks everything that did not
-   * opt out; `false` is an active lock. Reporting `undefined` as `false` would
-   * read correctly and round-trip wrongly, so it is reported as it is.
-   */
-  interface LayoutInteractive {
-    movable: boolean | undefined;
-    resizable: boolean | undefined;
-    closable: boolean | undefined;
-  }
-
-  /** The plain, JSON-safe arrangement `getLayout()` returns and `setLayout()` takes. */
-  interface LayoutSnapshot {
-    columns: number;
-    rows: number;
-    windows: { id: string; xPos: number; yPos: number; xSize: number; ySize: number }[];
-  }
-
-  /** A cell placement, as carried on the move and resize events. */
-  interface LayoutPlacement {
-    xPos: number;
-    yPos: number;
-    xSize: number;
-    ySize: number;
-  }
-
-  /** The payload of `window:moved`, `beforeWindowMove`, `beforeWindowResize`. */
-  interface LayoutMoveEvent {
-    id: string;
-    from: LayoutPlacement;
-    /** Where the window was asked to go. */
-    to: LayoutPlacement;
-    /** Where it actually ended up, which under `compact: 'vertical'` may differ. */
-    landed?: LayoutPlacement;
-    origin?: 'api' | 'user' | 'init';
-    reason?: string | null;
-    /** Cancel the action (only meaningful on a `before*` event). */
-    preventDefault?: (reason?: string) => void;
-    defaultPrevented?: boolean;
-  }
-
-  /**
-   * The payload of `window:resized` — the measured **content box** of the
-   * payload container, not a cell count. Emitted when the container genuinely
-   * changes size, including on the opening frame; never with a zero box.
-   */
-  interface LayoutResizeEvent {
-    id: string;
-    payloadId: string;
-    /** The payload container itself, so a host can act on it directly. */
-    payload: HTMLElement;
-    width: number;
-    height: number;
-    xPos: number;
-    yPos: number;
-    xSize: number;
-    ySize: number;
-  }
-
-  /** The payload of `window:closed` and `beforeWindowClose`. */
-  interface LayoutCloseEvent {
-    id: string;
-    payloadId: string;
-    /** The payload container, handed back so the host can destroy what it mounted. */
-    payload?: HTMLElement;
-    origin?: 'api' | 'user';
-    reason?: string | null;
-    preventDefault?: (reason?: string) => void;
-    defaultPrevented?: boolean;
-  }
-
-  /** The payload of `layout:changed`: the whole arrangement, plus what moved it. */
-  interface LayoutChangedEvent extends LayoutSnapshot {
-    cause: string;
-  }
-
-  /** Dashboard layout configuration. */
-  interface LayoutConfig {
-    /** Cell columns across the mounted element (default 12). */
-    columns?: number;
-    /** Cell rows down the mounted element (default 6). */
-    rows?: number;
-    /** Horizontal overflow (default `'static'`). */
-    overflowX?: 'static' | 'scroll';
-    /** Vertical overflow (default `'static'`). */
-    overflowY?: 'static' | 'scroll';
-    /** Fixed column track size, used only when `overflowX` is `'scroll'` (default `'240px'`). */
-    columnWidth?: number | string;
-    /** Fixed row track size, used only when `overflowY` is `'scroll'` (default `'160px'`). */
-    rowHeight?: number | string;
-    /** The gap between cells (default `'8px'`). */
-    gap?: number | string;
-    /** The default padding inside a window (default `'5px'`). */
-    padding?: number | string;
-    /** Rearrangement (default `'vertical'`): push displaced windows down, then pull up. */
-    compact?: 'vertical' | 'none';
-    /**
-     * The default `movable` for every window that does not declare its own
-     * (default `false`). This states a default, so `false` takes nothing away
-     * from a window that declared `movable: true`; `setInteractive(false)` is
-     * the active lock that does.
-     */
-    movable?: boolean;
-    /** The default `resizable` for windows that declare none (default `false`); see `movable`. */
-    resizable?: boolean;
-    /** The default `closable` for windows that declare none (default `false`); see `movable`. */
-    closable?: boolean;
-    /**
-     * The default `maximisable` for windows that declare none (default `false`).
-     *
-     * Not touched by `setInteractive()`: a display mode neither moves nor resizes
-     * a window in the arrangement, so a locked dashboard can still be blown up
-     * to read.
-     */
-    maximisable?: boolean;
-    /** The default `minimisable` for windows that declare none (default `false`); see `maximisable`. */
-    minimisable?: boolean;
-    /** The windows, in mount order. */
-    windows?: LayoutWindow[];
-    /** An arrangement to apply at mount, as produced by `getLayout()`. */
-    layout?: LayoutSnapshot;
-    /** The layout region's accessible name. */
-    ariaLabel?: string;
-    /** A message catalogue, e.g. `grid.messages`; built-in English seeds otherwise. */
-    messages?: { t(key: string, params?: Record<string, unknown>): string };
-    onWindowMoved?: (event: LayoutMoveEvent) => void;
-    onWindowResized?: (event: LayoutResizeEvent) => void;
-    onWindowClosed?: (event: LayoutCloseEvent) => void;
-    onLayoutChanged?: (event: LayoutChangedEvent) => void;
-    onBeforeWindowMove?: (event: LayoutMoveEvent) => boolean | void | Promise<boolean>;
-    onBeforeWindowResize?: (event: LayoutMoveEvent) => boolean | void | Promise<boolean>;
-    onBeforeWindowClose?: (event: LayoutCloseEvent) => boolean | void | Promise<boolean>;
-    onWindowMoveCancelled?: (event: LayoutMoveEvent) => void;
-    onWindowResizeCancelled?: (event: LayoutMoveEvent) => void;
-    onWindowCloseCancelled?: (event: LayoutCloseEvent) => void;
-  }
-
-  /**
-   * A reconfigurable dashboard: a cell grid inside an element, and a set of
-   * windows on it that a user can move, resize and close by pointer or by
-   * keyboard (BACKLOG-0001108).
-   *
-   * The module is **payload-agnostic**: a window body is a container with an id,
-   * which this module creates and sizes and never reads. It tells a payload it
-   * was resized by emitting `window:resized`; it never calls into one, because it
-   * cannot know what one is.
-   */
-  interface Layout {
-    readonly el: HTMLElement;
-    /** The window ids, in mount order. */
-    windows(): string[];
-    /** The payload container for a window, or `null`. */
-    payload(id: string): HTMLElement | null;
-    /** A copy of one window's current descriptor, or `null`. */
-    window(id: string): LayoutWindow | null;
-    /** Add a window after mount; returns its payload container. */
-    add(spec: LayoutWindow): HTMLElement;
-    /** Move or resize a window, through the same before-events the drag uses. */
-    move(id: string, to: Partial<LayoutPlacement>): boolean | Promise<boolean>;
-    /** Close a window through `beforeWindowClose`; the payload is not destroyed. */
-    close(id: string): boolean | Promise<boolean>;
-    /**
-     * Blow one window up to fill the layout host, hiding the rest.
-     *
-     * It fills the **host element**, not the browser window, so there is no
-     * `position: fixed` (whose containing block is the nearest ancestor carrying
-     * a `transform` or a `contain`, which is why the same rule fills the screen
-     * on one page and lands in a 300px box on the next), no reparenting and
-     * nothing that can disturb the page around the dashboard.
-     *
-     * **Nothing moves**: no compaction runs, no placement changes, and the
-     * payload container is the same DOM node throughout. **Escape restores it**,
-     * from anywhere inside the layout — a focused grid body cell or column
-     * heading included — unless a payload has already claimed the key: an open
-     * cell editor, filter menu or column menu closes first, and the next Escape
-     * restores the window. Afterwards focus lands on the window's maximise
-     * control. A minimised window is expanded first, and maximising a second
-     * window restores the first.
-     */
-    maximise(id: string): boolean;
-    /**
-     * Collapse one window to a single row: its payload is hidden and its chrome
-     * stays, carrying the control that brings it back.
-     *
-     * On screen it becomes one row and the windows below pull up into the space
-     * under `compact: 'vertical'`. In the arrangement nothing moves at all — the
-     * collapse is a projection of it — so `restore()` gives back exactly the
-     * arrangement that was there, in **any** order and with any number of other
-     * windows still collapsed.
-     *
-     * A window with `chrome: false` is refused, with a warning naming it.
-     */
-    minimise(id: string): boolean;
-    /** Leave whichever display mode a window is in; `false` when it was in none. */
-    restore(id: string): boolean;
-    /** The id of the window filling the host, or `null`. At most one. */
-    maximised(): string | null;
-    /** The ids of every currently minimised window, in mount order. */
-    minimised(): string[];
-    /**
-     * The full current arrangement.
-     *
-     * **A mode is not an arrangement**: this reports the *underlying* placement
-     * of a maximised or minimised window — where it will be when restored — never
-     * the geometry it is drawn at.
-     */
-    getLayout(): LayoutSnapshot;
-    /** Restore an arrangement; never throws on garbage. */
-    setLayout(incoming: LayoutSnapshot | LayoutWindow[]): number;
-    /** A versioned snapshot, following core's and gantt's shape. */
-    getState(): { version: number; layout: LayoutSnapshot };
-    /** Restore a `getState()` snapshot; never throws on garbage. */
-    setState(snapshot: unknown): number;
-    /**
-     * Lock or unlock the dashboard at runtime — the "Edit layout" button. A
-     * boolean sets all three capabilities; an object sets only the keys it
-     * carries. Nothing is destroyed, so every payload survives the toggle.
-     *
-     * The asymmetry is deliberate: **you can always take a capability away; you
-     * can never grant one where the developer said no.** `setInteractive(false)`
-     * locks every window, including one whose own spec says `movable: true`;
-     * `setInteractive(true)` unlocks only the windows that never opted out.
-     *
-     * `config.movable: false` and `setInteractive(false)` are deliberately not
-     * the same thing: the config states the *default* for windows that declare
-     * nothing (and `false` is already that default, so it takes nothing away from
-     * a window that opted in), while this is an *active lock*.
-     *
-     * A key carrying `undefined` is treated as absent, so
-     * `setInteractive(getInteractive())` is a no-op in every state.
-     *
-     * A locked layout is not a read-only dashboard: this module never reads or
-     * writes a payload, so a grid inside a window is made read-only with the
-     * grid's own settings.
-     */
-    setInteractive(value: boolean | Partial<LayoutInteractive>): LayoutInteractive;
-    /**
-     * The layout-level interactivity now in force, as a copy — `undefined` where
-     * no layout-level default is set, so the result round-trips through
-     * `setInteractive`.
-     */
-    getInteractive(): LayoutInteractive;
-    /** Re-measure every window and emit `window:resized` for those that changed. */
-    refresh(): number;
-    on(
-      name: 'window:moved' | 'window:resized' | 'window:closed' | 'layout:changed'
-        | 'beforeWindowMove' | 'beforeWindowResize' | 'beforeWindowClose'
-        | 'windowMove:cancelled' | 'windowResize:cancelled' | 'windowClose:cancelled'
-        | '*' | string,
-      fn: (event: any) => unknown,
-    ): () => void;
-    off(name: string, fn: (event: any) => unknown): void;
-    /** Tear the layout down; whatever the host mounted in a payload is the host's to destroy. */
-    destroy(): void;
-  }
-
-  /** Create a reconfigurable dashboard layout over a host element. */
-  export function createLayout(el: HTMLElement, config?: LayoutConfig): Layout;
-  export default createLayout;
-}