@toclocoinc/lattice-grid 1.32.0 → 1.33.0

package/README.md

@@ -4,7 +4,7 @@
 dependencies, no build step required. Optional adapters for React, Vue, Svelte
 and Web Components ship alongside it.
 
-Version 1.32.0 · [latticegrid.dev](https://www.latticegrid.dev) · TOCLOCO Inc
+Version 1.33.0 · [latticegrid.dev](https://www.latticegrid.dev) · TOCLOCO Inc
 
 ---
 

package/docs/API.html

@@ -4094,6 +4094,93 @@ createGrid(el, {
 
     <div class="note"><p>The module imports nothing from the grid: <code>createChart</code> is handed a grid rather than importing one. That is what keeps the charts bundle to the drawing, and it is why the grid must be created first, and why a chart cannot outlive it.</p></div>
 
+    <h3 id="chart-extension-types">Extension chart types — pay only for what you draw</h3>
+    <p>The base charts bundle draws the built-in <code>TYPES</code> and nothing else. A new chart type is a <strong>separate, opt-in module</strong> a caller imports only if they use it (BACKLOG-0000886, on the slim-core seam BACKLOG-0000884). Importing it self-registers the type with the base module through <code>registerChartType</code>; the base <code>Chart</code> consults that registry for any type it does not draw natively. Because the base never imports the extension, the base bundle <strong>does not grow</strong> for a type a caller never uses.</p>
+    <pre><code><span class="kw">import</span> '@toclocoinc/lattice-grid/modules/charts';           <span class="cmt">// the base</span>
+<span class="kw">import</span> '@toclocoinc/lattice-grid/modules/chart-ridgeline';  <span class="cmt">// opt in to one type</span>
+
+createChart({ grid, container: '#dist', type: 'ridgeline', x: 'segment', y: 'value' });</code></pre>
+    <p>An extension declares <code>{ draw, bind?, freeform?, labelled? }</code>. Its <code>draw(ctx)</code> receives the same context a built-in drawer gets — <code>plot</code>, <code>bound</code>, <code>groups</code>, <code>scheme</code>, <code>typography</code>, <code>labels</code>, <code>grid</code>, <code>spec</code> — plus <code>ctx.helpers</code>, the base's own toolkit (element factory, scales, axis drawers, mark pool, distribution kernels). So an extension imports nothing heavy from the base: it receives the toolkit and ships only its own geometry. <code>registeredChartTypes()</code> lists what is registered. <strong>Ridgeline</strong> (<code>drawRidgeline</code>) is the first: one kernel-density ridge per category, stacked and overlapping, over the distribution of a measure — the reading for "how did this distribution change across segments".</p>
+    <pre data-run="js" data-expect="true | true | function" data-covers="export:registerChartType export:registeredChartTypes export:drawRidgeline"><code><span class="kw">const</span> charts = <span class="kw">await</span> import('../packages/modules/charts/index.js');
+<span class="kw">const</span> ridge = <span class="kw">await</span> import('../packages/modules/chart-ridgeline/index.js');
+
+<span class="cmt">// Importing the module self-registered the type against the base registry.</span>
+<span class="kw">const</span> registered = charts.registeredChartTypes().includes('ridgeline');
+<span class="cmt">// registerChartType is idempotent by name, so re-registering is safe.</span>
+charts.registerChartType('ridgeline', { draw: ridge.drawRidgeline });
+
+<span class="kw">return</span> [
+  registered,
+  charts.registeredChartTypes().includes('ridgeline'),
+  typeof ridge.drawRidgeline,
+].join(' | ');</code></pre>
+
+    <p>More lead-pick types ship the same way, each in its own opt-in module — the base bundle stays flat as they are added. <strong>Calendar heatmap</strong> (<code>drawCalendar</code>, <code>type: 'calendar'</code>) lays a measure out value-by-day, GitHub-style, from a date column. <strong>Scatter-plot matrix</strong> (<code>drawSplom</code>/<code>bindSplom</code>, <code>type: 'splom'</code>) crosses every pair of numeric <code>columns</code>. <strong>Hexbin</strong> (<code>drawHexbin</code>/<code>bindHexbin</code>, <code>type: 'hexbin'</code>) bins a scatter into count-shaded hexagons so a million rows read as a density field. Each reads the grid through the public row API, so it follows the grid's filters and sort.</p>
+    <pre data-run="js" data-expect="true | function | function | function | function | function" data-covers="export:drawCalendar export:drawSplom export:bindSplom export:drawHexbin export:bindHexbin"><code><span class="kw">const</span> charts = <span class="kw">await</span> import('../packages/modules/charts/index.js');
+<span class="kw">const</span> cal = <span class="kw">await</span> import('../packages/modules/chart-calendar/index.js');
+<span class="kw">const</span> splom = <span class="kw">await</span> import('../packages/modules/chart-splom/index.js');
+<span class="kw">const</span> hex = <span class="kw">await</span> import('../packages/modules/chart-hexbin/index.js');
+
+<span class="cmt">// Each import self-registered its type; the base bundle carries none of them.</span>
+<span class="kw">const</span> types = charts.registeredChartTypes();
+<span class="kw">return</span> [
+  ['calendar', 'splom', 'hexbin'].every((t) =&gt; types.includes(t)),
+  typeof cal.drawCalendar,
+  typeof splom.drawSplom, typeof splom.bindSplom,
+  typeof hex.drawHexbin, typeof hex.bindHexbin,
+].join(' | ');</code></pre>
+
+    <p>The model-evaluation and time-series lead picks ship the same way. <strong>ROC / PR / calibration</strong> (<code>drawRoc</code>/<code>bindRoc</code>, <code>type: 'roc'</code>, <code>curve: 'roc' | 'pr' | 'calibration'</code>) evaluates a classifier from a <code>label</code> and a <code>score</code> column, with the AUC. <strong>Fan / forecast</strong> (<code>drawFan</code>/<code>bindFan</code>, <code>type: 'fan'</code>) draws history, a point forecast, and a widening prediction interval from <code>y</code>/<code>forecast</code>/<code>lower</code>/<code>upper</code>. <strong>Decomposition panel</strong> (<code>drawDecomposition</code>/<code>bindDecomposition</code>, <code>type: 'decomposition'</code>) stacks the <code>observed</code>/<code>trend</code>/<code>seasonal</code>/<code>residual</code> components on one x axis — the companion to the grid's own time-series shadow columns.</p>
+    <pre data-run="js" data-expect="true | function | function | function | function | function | function" data-covers="export:drawRoc export:bindRoc export:drawFan export:bindFan export:drawDecomposition export:bindDecomposition"><code><span class="kw">const</span> charts = <span class="kw">await</span> import('../packages/modules/charts/index.js');
+<span class="kw">const</span> roc = <span class="kw">await</span> import('../packages/modules/chart-roc/index.js');
+<span class="kw">const</span> fan = <span class="kw">await</span> import('../packages/modules/chart-fan/index.js');
+<span class="kw">const</span> decomp = <span class="kw">await</span> import('../packages/modules/chart-decomposition/index.js');
+
+<span class="kw">const</span> types = charts.registeredChartTypes();
+<span class="kw">return</span> [
+  ['roc', 'fan', 'decomposition'].every((t) =&gt; types.includes(t)),
+  typeof roc.drawRoc, typeof roc.bindRoc,
+  typeof fan.drawFan, typeof fan.bindFan,
+  typeof decomp.drawDecomposition, typeof decomp.bindDecomposition,
+].join(' | ');</code></pre>
+
+    <p>The comparison and ranking family ships the same way. <strong>Slope</strong> (<code>drawSlope</code>, <code>type: 'slope'</code>) connects each series across two periods; <strong>dumbbell</strong> (<code>drawDumbbell</code>/<code>bindDumbbell</code>, <code>type: 'dumbbell'</code>) shows a <code>start</code>/<code>end</code> gap per category; <strong>bump</strong> (<code>drawBump</code>, <code>type: 'bump'</code>) plots rank-over-time; <strong>diverging</strong> (<code>drawDiverging</code>, <code>type: 'diverging'</code>) grows bars from a central zero; <strong>parallel coordinates</strong> (<code>drawParallel</code>/<code>bindParallel</code>, <code>type: 'parallel'</code>) draws one polyline per row across several numeric axes.</p>
+    <pre data-run="js" data-expect="true | function | function | function | function | function | function | function" data-covers="export:drawSlope export:drawDumbbell export:bindDumbbell export:drawBump export:drawDiverging export:drawParallel export:bindParallel"><code><span class="kw">const</span> charts = <span class="kw">await</span> import('../packages/modules/charts/index.js');
+<span class="kw">const</span> slope = <span class="kw">await</span> import('../packages/modules/chart-slope/index.js');
+<span class="kw">const</span> dumbbell = <span class="kw">await</span> import('../packages/modules/chart-dumbbell/index.js');
+<span class="kw">const</span> bump = <span class="kw">await</span> import('../packages/modules/chart-bump/index.js');
+<span class="kw">const</span> diverging = <span class="kw">await</span> import('../packages/modules/chart-diverging/index.js');
+<span class="kw">const</span> parallel = <span class="kw">await</span> import('../packages/modules/chart-parallel/index.js');
+
+<span class="kw">const</span> types = charts.registeredChartTypes();
+<span class="kw">return</span> [
+  ['slope', 'dumbbell', 'bump', 'diverging', 'parallel'].every((t) =&gt; types.includes(t)),
+  typeof slope.drawSlope,
+  typeof dumbbell.drawDumbbell, typeof dumbbell.bindDumbbell,
+  typeof bump.drawBump,
+  typeof diverging.drawDiverging,
+  typeof parallel.drawParallel, typeof parallel.bindParallel,
+].join(' | ');</code></pre>
+
+    <p>The hierarchy, flow and geographic remainder ships the same way — treemap, sunburst, funnel, radar, sankey, chord and network are already built in, so the new opt-in modules are: <strong>icicle</strong> (<code>drawIcicle</code>, <code>type: 'icicle'</code>, drawn from the grid's group tree), <strong>waffle</strong> (<code>drawWaffle</code>, <code>type: 'waffle'</code>), <strong>alluvial</strong> (<code>drawAlluvial</code>/<code>bindAlluvial</code>, <code>type: 'alluvial'</code>), <strong>arc diagram</strong> (<code>drawArc</code>/<code>bindArc</code>, <code>type: 'arc'</code>), <strong>bubble map</strong> (<code>drawBubbleMap</code>/<code>bindBubbleMap</code>, <code>type: 'bubblemap'</code>) and <strong>hexbin map</strong> (<code>drawHexMap</code>/<code>bindHexMap</code>, <code>type: 'hexmap'</code>). The two maps place <code>lon</code>/<code>lat</code> directly, so they need no outline data and fetch nothing.</p>
+    <pre data-run="js" data-expect="true | function | function | function | function | function | function | function | function | function | function" data-covers="export:drawIcicle export:drawWaffle export:drawAlluvial export:bindAlluvial export:drawArc export:bindArc export:drawBubbleMap export:bindBubbleMap export:drawHexMap export:bindHexMap"><code><span class="kw">const</span> charts = <span class="kw">await</span> import('../packages/modules/charts/index.js');
+<span class="kw">const</span> icicle = <span class="kw">await</span> import('../packages/modules/chart-icicle/index.js');
+<span class="kw">const</span> waffle = <span class="kw">await</span> import('../packages/modules/chart-waffle/index.js');
+<span class="kw">const</span> alluvial = <span class="kw">await</span> import('../packages/modules/chart-alluvial/index.js');
+<span class="kw">const</span> arc = <span class="kw">await</span> import('../packages/modules/chart-arc/index.js');
+<span class="kw">const</span> bubblemap = <span class="kw">await</span> import('../packages/modules/chart-bubblemap/index.js');
+<span class="kw">const</span> hexmap = <span class="kw">await</span> import('../packages/modules/chart-hexmap/index.js');
+
+<span class="kw">const</span> types = charts.registeredChartTypes();
+<span class="kw">return</span> [
+  ['icicle', 'waffle', 'alluvial', 'arc', 'bubblemap', 'hexmap'].every((t) =&gt; types.includes(t)),
+  typeof icicle.drawIcicle, typeof waffle.drawWaffle,
+  typeof alluvial.drawAlluvial, typeof alluvial.bindAlluvial,
+  typeof arc.drawArc, typeof arc.bindArc,
+  typeof bubblemap.drawBubbleMap, typeof bubblemap.bindBubbleMap,
+  typeof hexmap.drawHexMap, typeof hexmap.bindHexMap,
+].join(' | ');</code></pre>
+
     <h2 id="datarouter">The data router</h2>
     <p><code>modules/data-router</code> is a host-layer demultiplexer: it takes <strong>one</strong> arriving stream or dataset, splits it by what each record <em>is</em>, and routes each partition to its own grid &mdash; or to a headless grid driving a chart. One round-trip, or one live feed, hydrates a whole screen of grids that each see only their slice. It is optional, imports nothing from the grid, and adds no core hook: every grid is driven through the <strong>public</strong> incremental path, <code>grid.rows.apply({ add, update, remove })</code>.</p>
     <pre><code>import { createDataRouter } from '@toclocoinc/lattice-grid/modules/data-router';
@@ -4131,6 +4218,9 @@ router.apply([{ op: 'upsert', row }, { op: 'delete', row }]); <span class="cmt">
           <tr><td class="sig">flushStream()</td><td class="desc"><strong>v3:</strong> apply the buffered deltas now, coalesced into a single apply (a deterministic point, and for tests).</td></tr>
           <tr><td class="sig">dropped</td><td class="desc"><strong>v3:</strong> how many stale/duplicate deltas the <code>seq</code> dedupe gate has dropped.</td></tr>
           <tr><td class="sig">lastSeq() / checkpoint() / seenThrough(mark)</td><td class="desc"><strong>v3:</strong> the resume point &mdash; the highest applied <code>seq</code>, a per-record checkpoint to persist, and a way to prime it after a reconnect so an early replay is dropped.</td></tr>
+          <tr><td class="sig">subscribe(predicate, handler, opts?)</td><td class="desc"><strong>v5:</strong> route a slice to any non-grid view. <code>handler(change)</code> receives the same keyed diff <code>{ add, update, remove }</code> a grid does &mdash; drive a KPI tile, detail pane, map or form. A peer to <code>attach</code>: same partitioning and the same <code>transform</code>/<code>filter</code>/<code>sort</code>/<code>rollup</code> options; grids and charts are unchanged.</td></tr>
+          <tr><td class="sig">alert(predicate, condition, handler, { filter?, debounce?, rowKey? })</td><td class="desc"><strong>v5:</strong> watch a slice and emit rather than render. <code>condition(rows)</code> is evaluated over the slice on every load and delta; when it first becomes truthy, <code>handler(signal, rows)</code> fires. Edge-triggered (once per crossing, re-arms on release), <code>debounce</code> coalesces a burst, and it never competes for a partition or touches a grid.</td></tr>
+          <tr><td class="sig">configure(spec)</td><td class="desc"><strong>v5:</strong> the whole routing graph as one data spec &mdash; <code>routes</code> (grid/<code>default</code>/<code>subscribe</code>/<code>alert</code> entries), <code>links</code>, <code>relate</code>, <code>buffer</code> &mdash; desugared to the imperative API. Composes with imperative calls and round-trips to identical behaviour. Also accepted as <code>createDataRouter({ config })</code>.</td></tr>
           <tr><td class="sig">detach(grid)</td><td class="desc">Stop routing to a grid and forget its slice; drop any link/edge it is part of (restoring a filtered sibling). The host still owns and destroys the grid.</td></tr>
           <tr><td class="sig">destroy()</td><td class="desc">Detach every grid, drop every link, edge and subscription. <strong>Detaches only</strong> &mdash; the host owns and destroys its grids.</td></tr>
         </tbody>

package/docs/api-detail.html

@@ -437,7 +437,7 @@
 <div class="shell">
   <aside class="rail">
     <p class="rail__brand">Lattice Grid</p>
-    <p class="rail__sub">Developer guide · v1.32.0</p>
+    <p class="rail__sub">Developer guide · v1.33.0</p>
     <nav>
       <div class="rail__group">
         <span class="rail__label">Start here</span>
@@ -6238,12 +6238,13 @@ grid.state.apply(savedView.state);
           <tr><td class="name">canChartRange</td><td class="desc">Whether <code>chartRange</code> would draw something for the grid’s current selection — the question a menu asks before offering the item.</td></tr>
           <tr><td class="name">deriveRangeSpec</td><td class="desc">Decide what a chart of a range should be without drawing it: the type, the category column, the measures, and a spec ready for <code>createChart</code>.</td></tr>
           <tr><td class="name">regressionPlots</td><td class="desc">Turn a fitted regression model into diagnostic chart specs ready for <code>createChart</code>: the fit line with its confidence band, residuals-vs-fitted, a QQ plot of the residuals, and a multicollinearity correlogram with the model’s VIF. The plots that need a per-row or per-coefficient quantity the grid has no column for (scale-location, residuals-vs-leverage, the coefficient forest) are returned as a null spec carrying the reason rather than dropped.</td></tr>
-          <tr><td class="name">createDataRouter</td><td class="desc">Split one arriving stream or dataset across many grids by what each record is — a property or a predicate — driving each grid through the public keyed <code>rows.apply</code> path so a snapshot is a diff, a delta is applied in place, a moved partition moves the row rather than duplicating it, and an unmatched record is counted, sunk and never dropped. v2 adds cross-grid selection filtering: <code>link(source, target, relation)</code> makes a selection in one grid filter what another receives — by a key map or a predicate function, multi-select as an IN set, debounced — re-pushed through the same keyed-diff path so the target stays dumb. Detaches its grids on <code>destroy</code>; the host owns them.</td></tr>
+          <tr><td class="name">createDataRouter</td><td class="desc">Split one arriving stream or dataset across many grids by what each record is — a property or a predicate — driving each grid through the public keyed <code>rows.apply</code> path so a snapshot is a diff, a delta is applied in place, a moved partition moves the row rather than duplicating it, and an unmatched record is counted, sunk and never dropped. v2 adds cross-grid selection filtering: <code>link(source, target, relation)</code> makes a selection in one grid filter what another receives — by a key map or a predicate function, multi-select as an IN set, debounced — re-pushed through the same keyed-diff path so the target stays dumb. v5 adds wedge-conversion primitives: <code>subscribe(value, handler)</code> routes a slice to any non-grid view (KPI tile, detail pane, map, form) as the same keyed diff a grid gets; <code>alert(value, condition, handler)</code> evaluates a condition over a slice and emits (edge-triggered, debounced) rather than rendering; and <code>configure(spec)</code> (or <code>createDataRouter({ config })</code>) takes the whole routing graph as one declarative data spec that desugars to the imperative API and composes with it. Detaches its grids on <code>destroy</code>; the host owns them.</td></tr>
           <tr><td class="name">createDevtools</td><td class="desc">Mount the devtools panel against a grid, including its accessibility checks.</td></tr>
           <tr><td class="name">createLatticeGridElement</td><td class="desc">Build the element class without registering it, for a custom registry.</td></tr>
           <tr><td class="name">createMessages</td><td class="desc">Build a message catalogue. A partial set lays over the built-in British English one.</td></tr>
           <tr><td class="name">defineLatticeGrid</td><td class="desc">Register &amp;lt;lattice-grid&amp;gt;, or your own tag name.</td></tr>
           <tr><td class="name">defineUnit</td><td class="desc">Add one unit to a system, or override one of ours under the same name.</td></tr>
+          <tr><td class="name">registerChartType</td><td class="desc">Register an extension chart type so <code>createChart({ type })</code> can draw it (BACKLOG-0000886). Extension types ship as their own opt-in modules (e.g. <code>modules/chart-ridgeline</code>), so the base charts bundle does not grow for a type a caller never imports — you pay only for the charts you use. <code>registeredChartTypes()</code> lists what is registered.</td></tr>
           <tr><td class="name">registerModules</td><td class="desc">Install optional modules once, for every grid on the page.</td></tr>
           <tr><td class="name">registerScheme</td><td class="desc">Add a colour scheme, or replace one of ours under the same name.</td></tr>
           <tr><td class="name">restoreStateWithin</td><td class="desc">Put it back afterwards.</td></tr>

package/lattice-grid.d.ts

@@ -1,5 +1,5 @@
 /*!
- * Lattice Grid 1.32.0, type declarations
+ * Lattice Grid 1.33.0, type declarations
  * Copyright (c) 2026 TOCLOCO Inc. All rights reserved.
  * https://latticegrid.dev
  */
@@ -5863,9 +5863,244 @@ declare module 'lattice-grid/modules/charts' {
   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.