@toclocoinc/lattice-grid 1.88.2 → 1.88.3

package/CHANGELOG.md

@@ -9,6 +9,12 @@ and what it means for a grid already in production.
 
 ## [Unreleased]
 
+## [1.88.3] - 2026-10-07
+
+### Added
+
+- **The Gantt split view's table columns, and the table/timeline divider, are now resizable** (BACKLOG-0001924). Each `__colhead` carries a draggable right border with a col-resize cursor; once focused (by pointer or Tab), the arrow keys step it 8px a press, 32px with Shift. `minWidth`/`maxWidth` on a column spec clamp how far it goes, and `resizable: false` omits its border entirely. The table/timeline divider (`gridWidth`) is the same gesture. A settled drag or keystroke on either fires exactly one `columnResize` event (`{ key, width, widths }`, the divider reporting `key: 'grid'`), and every width — the divider's included — round-trips through the controller's `getState`/`setState` via the view's new `getColumnWidths()`/`setColumnWidths()`, so a host can persist a resize across a reload. Rows, bars and the workload/histogram bands stay aligned throughout, since both panels and both bands size off the same column widths the drag is updating. Declared in every framework adapter (React, Vue, Svelte, Angular).
+
 ## [1.88.2] - 2026-10-06
 
 ### Added

package/README.md

@@ -5,7 +5,7 @@ dependencies, no build step required. Optional adapters for React, Vue, Svelte
 and Web Components ship alongside it, and Angular has compiled components of its
 own at `@toclocoinc/lattice-grid/angular` — inside this package, not beside it.
 
-Version 1.88.2 · [latticegrid.dev](https://www.latticegrid.dev) · TOCLOCO Inc
+Version 1.88.3 · [latticegrid.dev](https://www.latticegrid.dev) · TOCLOCO Inc
 
 ---
 

package/angular/fesm2022/toclocoinc-lattice-grid-angular.mjs

@@ -809,7 +809,7 @@ const VIEWER_EVENTS$1 = Object.freeze({
 
     chart: Object.freeze(['click', 'hover', 'leave', 'draw', 'legend']),
 
-    gantt: Object.freeze(['schedule', 'error', 'history']),
+    gantt: Object.freeze(['schedule', 'error', 'history', 'columnResize']),
     layout: Object.freeze([
         'layout:changed', 'window:moved', 'window:resized', 'window:closed',
         'beforeWindowClose', 'windowClose:cancelled',
@@ -2711,6 +2711,8 @@ class LatticeGanttComponent extends LatticeViewerBase {
         this.error = new EventEmitter();
 
         this.history = new EventEmitter();
+
+        this.columnResize = new EventEmitter();
     }
 
     liveProps() {
@@ -2727,7 +2729,7 @@ class LatticeGanttComponent extends LatticeViewerBase {
         return createGantt({ ...config, element });
     }
     static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "22.1.7", ngImport: i0, type: LatticeGanttComponent, deps: null, target: i0.ɵɵFactoryTarget.Component }); }
-    static { this.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "22.1.7", type: LatticeGanttComponent, isStandalone: true, selector: "lattice-gantt", inputs: { config: "config", tasks: "tasks", dependencies: "dependencies" }, outputs: { schedule: "schedule", error: "error", history: "history" }, usesInheritance: true, ngImport: i0, template: '', isInline: true, styles: [":host{display:block}\n"] }); }
+    static { this.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "22.1.7", type: LatticeGanttComponent, isStandalone: true, selector: "lattice-gantt", inputs: { config: "config", tasks: "tasks", dependencies: "dependencies" }, outputs: { schedule: "schedule", error: "error", history: "history", columnResize: "columnResize" }, usesInheritance: true, ngImport: i0, template: '', isInline: true, styles: [":host{display:block}\n"] }); }
 }
 i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "22.1.7", ngImport: i0, type: LatticeGanttComponent, decorators: [{
             type: Component,
@@ -2744,6 +2746,8 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "22.1.7", ngImpor
                 type: Output
             }], history: [{
                 type: Output
+            }], columnResize: [{
+                type: Output
             }] } });
 
 class LatticeLayoutComponent extends LatticeViewerBase {

package/angular/package.json

@@ -1,5 +1,5 @@
 {
-  "version": "1.88.2",
+  "version": "1.88.3",
   "type": "module",
   "sideEffects": false,
   "module": "./fesm2022/toclocoinc-lattice-grid-angular.mjs",

package/angular/types/toclocoinc-lattice-grid-angular.d.ts

@@ -1186,6 +1186,8 @@ declare class LatticeGanttComponent extends LatticeViewerBase<Gantt> {
     readonly error: EventEmitter<any>;
     /** The viewer's `history` event: undo/redo availability after each change (BACKLOG-0001864). */
     readonly history: EventEmitter<any>;
+    /** The split view's `columnResize` event: a column border or the table/timeline divider settled a drag or keyboard resize (BACKLOG-0001924). */
+    readonly columnResize: EventEmitter<any>;
     /**
      * The live inputs, by the names the viewer tables use.
      * @returns the live props that are set
@@ -1200,7 +1202,7 @@ declare class LatticeGanttComponent extends LatticeViewerBase<Gantt> {
      */
     protected mount(element: HTMLElement, config: Props): Gantt;
     static ɵfac: i0.ɵɵFactoryDeclaration<LatticeGanttComponent, never>;
-    static ɵcmp: i0.ɵɵComponentDeclaration<LatticeGanttComponent, "lattice-gantt", never, { "config": { "alias": "config"; "required": false; }; "tasks": { "alias": "tasks"; "required": false; }; "dependencies": { "alias": "dependencies"; "required": false; }; }, { "schedule": "schedule"; "error": "error"; "history": "history"; }, never, never, true, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<LatticeGanttComponent, "lattice-gantt", never, { "config": { "alias": "config"; "required": false; }; "tasks": { "alias": "tasks"; "required": false; }; "dependencies": { "alias": "dependencies"; "required": false; }; }, { "schedule": "schedule"; "error": "error"; "history": "history"; "columnResize": "columnResize"; }, never, never, true, never>;
 }
 
 /**

package/docs/API.html

@@ -382,7 +382,7 @@
 <div class="shell">
   <aside class="rail">
     <p class="rail__brand">Lattice Grid</p>
-    <p class="rail__sub">API reference · v1.88.2</p>
+    <p class="rail__sub">API reference · v1.88.3</p>
     <nav>
       <div class="rail__group">
         <span class="rail__label">Start</span>
@@ -570,7 +570,7 @@
     </header>
 
     <p class="chips">
-      <span class="chip">Version 1.88.2</span>
+      <span class="chip">Version 1.88.3</span>
       <span class="chip">Zero dependencies</span>
       <span class="chip"><a href="api-detail.html">Developer guide &rarr;</a></span>
     </p>
@@ -3150,7 +3150,7 @@ grid.destroy();
       <table>
         <thead><tr><th>Member</th><th>Returns</th><th>Description</th></tr></thead>
         <tbody>
-          <tr><td class="sig">getVersion()</td><td class="type">string</td><td class="desc">The version this grid came from, e.g. <code>'1.88.2'</code>. Also on the module as <code>getVersion()</code>, for when you have no grid to hand.</td></tr>
+          <tr><td class="sig">getVersion()</td><td class="type">string</td><td class="desc">The version this grid came from, e.g. <code>'1.88.3'</code>. Also on the module as <code>getVersion()</code>, for when you have no grid to hand.</td></tr>
           <tr><td class="sig">get(key)</td><td class="type">unknown</td><td class="desc">Read any configuration key.</td></tr>
           <tr><td class="sig">set(key, value)</td><td class="type">void</td><td class="desc">Write one key. Every key is live; nothing needs a rebuild.</td></tr>
           <tr><td class="sig">setAll(values)</td><td class="type">void</td><td class="desc">Write several in one pass. Emits one <code>config:changed</code> for the batch, not one per key.</td></tr>
@@ -11917,6 +11917,46 @@ view.setWorkloadUnit('hours'); // the same toggle the band's own switch drives
 const after = cellText();     // the identical booking, read back as hours: 8
 view.destroy();
 return [before, after].join(' | ');</code></pre>
+    <p id="split-column-resize"><strong>Split view: resizable columns and divider (BACKLOG-0001924).</strong> Every left-table column header (<code>__colhead</code>) carries a draggable right border with a col-resize cursor; once it is focused (by pointer or Tab), the arrow keys step it 8px a press, 32px with Shift. A column's own <code>minWidth</code>/<code>maxWidth</code> clamp how far it goes, and <code>resizable: false</code> omits the border entirely. The table/timeline divider (<code>gridWidth</code>) is the same gesture — a thin strip between the two panels, focusable and keyed the same way. A settled drag or keystroke on either — never mid-drag — fires exactly one <code>columnResize</code> event: <code>{ key, width, widths }</code>, the divider reporting <code>key: 'grid'</code> and <code>widths</code> carrying every column's current width plus the divider's own. The same widths are reachable any time off the view as <code>view.getColumnWidths()</code>, and round-trip through <code>gantt.getState()</code>/<code>setState()</code> — restoring a saved state calls <code>view.setColumnWidths()</code> for you.</p>
+    <pre data-run="js" data-expect="2 | grid | 90px | none | 332 | 90" data-covers="method:gantt.mountSplit"><code>const { createTestDom } = await import('../packages/dom/src/renderer/testdom.js');
+const { createGantt } = await import('../packages/modules/gantt/index.js');
+
+const { root, document } = createTestDom();
+const columns = [
+  { key: 'name', title: 'Task', width: 0, kind: 'name' },
+  { key: 'duration', title: 'Days', width: 60, kind: 'duration', minWidth: 50, maxWidth: 90 },
+  { key: 'locked', title: 'Locked', width: 40, resizable: false },
+];
+const gantt = createGantt({ projectStart: '2027-01-04', tasks: [{ id: 'design', name: 'Design', duration: 5 }] });
+const view = gantt.mountSplit(root, { gridWidth: 300, columns });
+const NS = 'lat-gantt-split';
+
+let events = 0;
+let lastKey = null;
+gantt.on('columnResize', (e) => { events += 1; lastKey = e.key; });
+
+// Drag the "Days" column's border 50px right — past its own 90px maxWidth.
+const handle = root.querySelector('.' + NS + '__colresize[data-resize-key="duration"]');
+handle.dispatchEvent({ type: 'pointerdown', target: handle, clientX: 0, clientY: 0, button: 0, bubbles: true });
+document.documentElement.dispatchEvent({ type: 'pointermove', target: document.documentElement, clientX: 50, clientY: 0 });
+document.documentElement.dispatchEvent({ type: 'pointerup', target: document.documentElement, clientX: 50, clientY: 0 });
+const daysWidth = root.querySelectorAll('.' + NS + '__colhead')[1].style.width;
+
+// `resizable: false` grows no border to drag at all.
+const lockedHandle = root.querySelector('.' + NS + '__colresize[data-resize-key="locked"]');
+
+// Shift+ArrowRight on the focused divider steps it 32px.
+const divider = root.querySelector('.' + NS + '__divider--resize');
+divider.dispatchEvent({ type: 'keydown', target: divider, key: 'ArrowRight', shiftKey: true, bubbles: true });
+
+// Persist the resize, remount fresh, and restore it.
+const saved = gantt.getState();
+gantt.mountSplit(root, { gridWidth: 300, columns });
+gantt.setState(saved);
+const restored = gantt.getState();
+
+view.destroy();
+return [events, lastKey, daysWidth, lockedHandle ? 'handle' : 'none', restored.gridWidth, restored.columnWidths.duration].join(' | ');</code></pre>
     <p><strong>Live data.</strong> The Gantt exposes the same consumer surface as the grid — <code>gantt.rows.apply({ add, update, remove })</code>, keyed by its <code>rowKey</code> (default <code>id</code>) — so a <a href="#datarouter">Data Router</a> attaches to it exactly as it does a grid, a board or a chart. One arriving stream can hydrate and update a whole screen, the Gantt included; each change recomputes the schedule and redraws.</p>
     <pre><code>import { createDataRouter } from '@toclocoinc/lattice-grid/modules/data-router';
 
@@ -23426,6 +23466,19 @@ return `next ${p.mean.toFixed(1)}; r2 ${f.r2.toFixed(1)}; band ${p.upper - p.low
           <tr><td class="name">dependencyCreate:cancelled</td><td class="type"><a href="#type-GanttDependencyCreateCancelledEvent">GanttDependencyCreateCancelledEvent</a></td><td class="desc">The links that were not created, and why.</td></tr>
           <tr><td class="name">taskDelete:cancelled</td><td class="type"><a href="#type-GanttTaskDeleteCancelledEvent">GanttTaskDeleteCancelledEvent</a></td><td class="desc">The task that was not deleted, and why.</td></tr>
           <tr><td class="name">history</td><td class="type"><a href="#type-GanttHistoryEvent">GanttHistoryEvent</a></td><td class="desc">The undo/redo timeline's new state (BACKLOG-0001864).</td></tr>
+          <tr><td class="name">columnResize</td><td class="type"><a href="#type-GanttColumnResizeEvent">GanttColumnResizeEvent</a></td><td class="desc">The settled column/divider width, and a snapshot of every width (BACKLOG-0001924).</td></tr>
+        </tbody>
+      </table>
+    </div>
+    <h4 id="type-GanttColumnResizeEvent">GanttColumnResizeEvent</h4>
+    <p class="section-note">The payload of the `columnResize` event (BACKLOG-0001924), fired once a split-view column-border or table/timeline-divider drag or keyboard resize settles — never mid-drag, so one gesture is exactly one event.</p>
+    <div class="table-wrap">
+      <table>
+        <thead><tr><th>Property</th><th>Type</th><th>Description</th></tr></thead>
+        <tbody>
+          <tr><td class="name">key</td><td class="type">string</td><td class="desc">The column `key` that was resized, or `'grid'` for the table/timeline divider.</td></tr>
+          <tr><td class="name">width</td><td class="type">number</td><td class="desc">The settled width, in pixels, after the column's/divider's own `minWidth`/`maxWidth` clamp.</td></tr>
+          <tr><td class="name">widths</td><td class="type">Record&lt;string, number&gt;</td><td class="desc">Every left-panel column's current rendered width, keyed by its own `key`, plus the divider's own width under `'grid'` — a full snapshot a host can persist directly, e.g. alongside `gantt.getState()`'s own `columnWidths` (which carries the same shape, minus `grid`).</td></tr>
         </tbody>
       </table>
     </div>
@@ -23464,6 +23517,8 @@ return `next ${p.mean.toFixed(1)}; r2 ${f.r2.toFixed(1)}; band ${p.upper - p.low
           <tr><td class="name">toggleResource</td><td class="type">(resource: string): void</td><td class="desc"><code>resource: string</code></td><td class="type"><code>void</code></td><td class="desc">Expand or collapse a resource's per-task sub-rows in the workload band, and redraw.</td></tr>
           <tr><td class="name">getWorkloadUnit</td><td class="type">(): 'hours' | 'percent' | 'cost'</td><td class="desc">&mdash;</td><td class="type"><code>'hours' | 'percent' | 'cost'</code></td><td class="desc">The unit the workload band (and, when mounted, the histogram band) is currently drawing in (BACKLOG-0001879, BACKLOG-0001866).</td></tr>
           <tr><td class="name">setWorkloadUnit</td><td class="type">(unit: 'hours' | 'percent' | 'cost'): void</td><td class="desc"><code>unit: 'hours' | 'percent' | 'cost'</code></td><td class="type"><code>void</code></td><td class="desc">Switch the workload and histogram bands to hours, percent-of-capacity or cost (BACKLOG-0001879, BACKLOG-0001866), redraw, and announce the change in the live region. Round-trips through the controller's `getState`/`setState`. A no-op when neither band is mounted.</td></tr>
+          <tr><td class="name">getColumnWidths</td><td class="type">(): Record&lt;string, number&gt;</td><td class="desc">&mdash;</td><td class="type"><code>Record&lt;string, number&gt;</code></td><td class="desc">Every left-panel column's current rendered width, keyed by column `key` (BACKLOG-0001924) — every column, not merely a resized one, so restoring this exact snapshot reproduces the layout on screen. Round-trips through the controller's `getState`/`setState`.</td></tr>
+          <tr><td class="name">setColumnWidths</td><td class="type">(widths: Record&lt;string, number&gt;): void</td><td class="desc"><code>widths: Record&lt;string, number&gt;</code></td><td class="type"><code>void</code></td><td class="desc">Restore column widths from {@link getColumnWidths} (BACKLOG-0001924). Each is clamped to that column's own `minWidth`/`maxWidth` and skipped for an unknown key or a `resizable: false` column, then the view redraws.</td></tr>
           <tr><td class="name">toSVG</td><td class="type">(svgOpts?: { range?: { from?: number | string | Date; to?: number | string | Date } }): string</td><td class="desc"><code>svgOpts?: { range?: { from?: number | string | Date; to?: number | string | Date } }</code></td><td class="type"><code>string</code></td><td class="desc">Serialise this split view — the left panel, the timeline and whichever bands are mounted — to a standalone SVG string (BACKLOG-0001863), drawn with a fixed palette independent of the mounted theme. `''` before anything has been drawn.</td></tr>
           <tr><td class="name">toPNG</td><td class="type">(pngOpts?: { range?: { from?: number | string | Date; to?: number | string | Date }; scale?: number; background?: string; }): Promise&lt;Blob | null&gt;</td><td class="desc"><code>pngOpts?: { range?: { from?: number | string | Date; to?: number | string | Date }; scale?: number; background?: string; }</code></td><td class="type"><code>Promise&lt;Blob | null&gt;</code></td><td class="desc">This split view as a PNG (BACKLOG-0001863): `toSVG` rasterised through a canvas. Makes no network request. `null` when nothing is drawn or there is no canvas to rasterise with.</td></tr>
           <tr><td class="name">print</td><td class="type">(printOpts?: { paper?: 'A4' | 'Letter' | 'A3'; orientation?: 'landscape' | 'portrait'; fitToWidth?: boolean; scale?: number; title?: string | false; header?: string | ((page: number, pages: number) =&gt; string) | false; footer?: string | ((page: number, pages: number) =&gt; string) | false; }): boolean</td><td class="desc"><code>printOpts?: { paper?: 'A4' | 'Letter' | 'A3'; orientation?: 'landscape' | 'portrait'; fitToWidth?: boolean; scale?: number; title?: string | false; header?: string | ((page: number, pages: number) =&gt; string) | false; footer?: string | ((page: number, pages: number) =&gt; string) | false; }</code></td><td class="type"><code>boolean</code></td><td class="desc">Print this split view — the table, the timeline, and the workload and histogram bands when mounted — paged and scaled (BACKLOG-0001863): the table header and timeline header repeat on every page and no row is split across a page boundary. Opens the browser's own print path over a standalone document; "PDF" is whatever the browser's print dialog offers ("Save as PDF") — no server, no dependency. Always prints in a fixed, print-safe light palette, independent of the mounted theme.</td></tr>
@@ -23520,7 +23575,7 @@ return `next ${p.mean.toFixed(1)}; r2 ${f.r2.toFixed(1)}; band ${p.upper - p.low
           <tr><td class="name">canRedo</td><td class="type">(): boolean</td><td class="desc">&mdash;</td><td class="type"><code>boolean</code></td><td class="desc">Whether there is an edit to redo (BACKLOG-0001864).</td></tr>
           <tr><td class="name">clearHistory</td><td class="type">(): void</td><td class="desc">&mdash;</td><td class="type"><code>void</code></td><td class="desc">Forget the whole undo/redo timeline (BACKLOG-0001864) and emit `history`. History is also cleared by `setTasks`/`setState` and lost on reload; this is the explicit reset after loading a fresh plan through `rows.apply`.</td></tr>
           <tr><td class="name">mount</td><td class="type">(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) =&gt; boolean); label?: GanttBarLabel | ((task: GanttScheduledTask) =&gt; 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?: <a href="#type-GanttZoom">GanttZoom</a> | number; /** Scroll so the today line is in view after drawing. */ scrollToToday?: boolean; /** * The task tooltip (BACKLOG-0001921): a positioned card on hover and * keyboard focus, anchored to the bar. Default true. See {@link <a href="#type-GanttTooltip">GanttTooltip</a>}. */ tooltip?: <a href="#type-GanttTooltip">GanttTooltip</a>; /** Group tasks into swimlanes by a task property name or `fn(task)`. */ groupBy?: string | ((task: <a href="#type-GanttTask">GanttTask</a>) =&gt; unknown); /** Keyboard editing + focusable bars + ARIA announcements (default true). */ keyboard?: boolean; /** Days a keyboard arrow moves/resizes a task (default 1). */ moveStep?: number; }): unknown</td><td class="desc"><code>container: unknown</code><br><code>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) =&gt; boolean); label?: GanttBarLabel | ((task: GanttScheduledTask) =&gt; 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?: <a href="#type-GanttZoom">GanttZoom</a> | number; /** Scroll so the today line is in view after drawing. */ scrollToToday?: boolean; /** * The task tooltip (BACKLOG-0001921): a positioned card on hover and * keyboard focus, anchored to the bar. Default true. See {@link <a href="#type-GanttTooltip">GanttTooltip</a>}. */ tooltip?: <a href="#type-GanttTooltip">GanttTooltip</a>; /** Group tasks into swimlanes by a task property name or `fn(task)`. */ groupBy?: string | ((task: <a href="#type-GanttTask">GanttTask</a>) =&gt; unknown); /** Keyboard editing + focusable bars + ARIA announcements (default true). */ keyboard?: boolean; /** Days a keyboard arrow moves/resizes a task (default 1). */ moveStep?: number; }</code></td><td class="type"><code>unknown</code></td><td class="desc">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.</td></tr>
-          <tr><td class="name">mountSplit</td><td class="type">(container: unknown, options?: { height?: number; rowHeight?: number; headerHeight?: number; gridWidth?: number; indent?: number; zoom?: <a href="#type-GanttZoom">GanttZoom</a> | number; today?: number; nonWorking?: 'weekends' | ((day: number) =&gt; boolean); calendar?: <a href="#type-GanttCalendar">GanttCalendar</a> | null; showArrows?: boolean; showProgress?: boolean; showBaseline?: boolean; barLabel?: <a href="#type-GanttBarLabel">GanttBarLabel</a> | ((task: <a href="#type-GanttScheduledTask">GanttScheduledTask</a>) =&gt; 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 }; /** * The S-curve status-date progress line (BACKLOG-0001867): a vertical line * at the status date that jogs, at each task row, to that task's actual * progress point (start + %complete × duration). `true` uses the today line * (or the project finish); an object sets the status date explicitly. The * same status date drives the `plannedPercentComplete` column. */ progressLine?: boolean | { statusDate?: number | string | Date }; /** * Whether the plan can be edited: pointer drags on the timeline and the * left panel's inline cell editors (default true). Same meaning and * default as `mount`'s. */ editable?: boolean; /** * Keyboard editing + focusable bars + ARIA announcements on the timeline * (default true). Same meaning and default as `mount`'s. */ keyboard?: boolean; /** * Pixels from a bar's right edge that begin a resize rather than a move * (default 6). Same meaning and default as `mount`'s. */ resizeZone?: number; /** * The task tooltip (BACKLOG-0001921): the SAME positioned card `mount` * draws, anchored to the hovered or keyboard-focused bar. Default true. * See {@link <a href="#type-GanttTooltip">GanttTooltip</a>}. */ tooltip?: <a href="#type-GanttTooltip">GanttTooltip</a>; /** * A `{ t(key, params) }` resolver for the view's own text — the live * region's edit announcements. Omit it and a gantt bound to a grid borrows * that grid's catalogue; a standalone plan falls back to English. */ messages?: { t: (key: string, params?: Record&lt;string, unknown&gt;) =&gt; string }; /** * The left panel's columns. `kind` decides what the cell shows and what a * double-click edits: `'name'` the WBS tree (edits the name), `'assignee'` * the avatars, `'progress'` the % ring (edits `percentComplete`), `'evm'` * an earned-value `metric`, and `'start'`/`'end'`/`'duration'` the * scheduled window — an ISO date, an ISO date, and a whole number of days, * each of which edits the plan through the same path a bar drag takes * (BACKLOG-0001280). `'effort'` (hours) and `'units'` (a percentage, 100 = * one full-time resource) are the optional effort-driven columns * (BACKLOG-0001868); each edits through `applyEdit`, so the task * reschedules per its `schedulingMode`. A bare string names a built-in * column, so `['name', 'duration', 'effort', 'units']` is enough. On an * editable plan the assignee cell opens the assignment picker. A column * with no `kind` shows the raw task's `key` and edits it only with * `editable: true`. */ columns?: Array&lt;'name' | 'start' | 'end' | 'duration' | 'assignee' | 'progress' | 'effort' | 'units' | { key: string; title?: string; width?: number; kind?: 'name' | 'assignee' | 'progress' | 'evm' | 'plannedPercentComplete' | 'start' | 'end' | 'duration' | 'effort' | 'units' | 'number'; metric?: 'bac' | 'pv' | 'ev' | 'ac' | 'sv' | 'cv' | 'spi' | 'cpi'; digits?: number; editable?: boolean; editField?: string; render?: (task: GanttScheduledTask, ctx: { rawTask: GanttTask; depth: number }) =&gt; unknown }&gt;; /** * A resource workload band beneath the split view (BACKLOG-0001281): * one row per resource on the left and, on the right, that resource's * hours per time bucket — aligned column-for-column with the timeline's * scale header, scroll-locked to it horizontally (vertically it scrolls * on its own), and redrawn in the same paint as the bars whenever the * plan changes. `true` takes the defaults below; an object overrides * them; omitted, no band is drawn. * * **Editing (BACKLOG-0001282).** A resource row expands (a disclosure * button, `aria-expanded`) into one sub-row per task it carries. The * resource's own cell is the read-only aggregate; a SUB-ROW cell accepts * a typed number of hours on a double-click whenever the view's * `editable` is on. What is typed is written to that task's `work` * contour through the same `applyEdit` choke point (and the same * `beforeTaskEdit` veto) a bar drag uses, so the bar, the table row and * the band all move in one paint — including the span, which follows the * contour: type into a column beyond the bar and the bar grows to reach * it. A bucket containing no working day declines the edit and says so. * * **Where the hours come from.** They are DERIVED from the tasks, never * supplied: a task's own `work` (or `hours`) field when it carries a * finite one, otherwise `working days × hoursPerDay × units`, divided * between the task's assignments in proportion to their units and spread * evenly over the working days the task spans. Working days are the days * this view already shades — pass the `calendar`/`nonWorking` option the * plan is scheduled with. Resources, units and capacities are the gantt's * existing vocabulary (`assignee`/`assignees`/`owner`/`assignments` on a * task; `resources`/`defaultCapacity` on `createGantt`); a task naming no * resource is carried on an "Unassigned" row rather than dropped. An * empty bucket is blank, not `0`, and a bucket over * `capacity × hoursPerDay × the bucket's working days` is marked with a * class and an accessible label. */ workload?: boolean | { /** Hours a full-time (`units: 1`) resource works in a working day; default 8. */ hoursPerDay?: number; /** The band's height in pixels, taken from the view's own `height`; default 160. */ height?: number; /** A band row's height in pixels; default 28. */ rowHeight?: number; /** Maximum decimal places in a cell, trailing zeros dropped; default 1. */ decimals?: number; /** Draw the totals row and totals column; default true. */ totals?: boolean; /** * `'hours'` (default; an existing page is unchanged) draws booked * hours; `'percent'` draws hours as a share of the resource's own * available hours that bucket — `booked ÷ available × 100`, the SAME * available-hours figure the over-capacity highlight already uses * (the per-resource calendar included), falling back to hours for a * resource with no known capacity; a bucket with a KNOWN zero (a * part-timer's non-working day, a week wholly on leave) reads "–", * never `Infinity`/`NaN` (BACKLOG-0001879). An `&lt;button * aria-pressed&gt;` switch in the band's header toggles it (and the * histogram band's, when one is mounted) live; the same switch is * reachable off the view as `setWorkloadUnit`/`getWorkloadUnit`. * Editing in percent mode writes HOURS: typing `50` books half the * resource's available hours in that bucket, through the identical * `applyEdit` path an hours edit uses. `'cost'` draws hours × the * resource's rate in force each day (BACKLOG-0001866), read off the * SAME `computeWorkload` pass, falling back to hours for a resource * with no rate data; cost has no capacity concept, so there is no * over-highlight or capacity line in this unit. */ unit?: 'hours' | 'percent' | 'cost'; }; /** * A resource histogram band beneath the split view, below the workload * band when both are mounted (BACKLOG-0001860): one row per resource, * drawn as bars per time bucket rather than a table of numbers, with a * capacity line and a hover/focus tooltip. `true` takes the defaults * below; an object overrides them; omitted, no band is drawn. * * The bars come from the SAME derivation the workload band uses * (`computeWorkload`, driven off `work`/`hours`/`assignments` exactly as * documented on `workload` above) — this is a second PICTURE of the same * numbers, not a second source of them. The non-stacked bar for a bucket * over capacity carries both the normal fill up to capacity and the * over-allocation fill above it; `stacked: 'task'` additionally splits * the within-capacity portion into one coloured segment per contributing * task, still capped by the one over-allocation segment on top. An * accessible table (resource, period, hours/percent, capacity, * over-allocated) is rebuilt alongside the bars on every redraw. * * Mounted alongside `workload` at a fixed `height`, the two bands share * it rather than squeezing the timeline: the timeline keeps at least * half the view, the bands shrink in proportion when both do not * otherwise fit, and — rather than ever reading as an unreadably thin * sliver of bars — the histogram collapses to its header strip (with a * console warning naming the height it needs) when even its * proportional share would leave too little room for the plot. */ histogram?: boolean | { /** Which resources to draw, and in what order; omitted draws every resource `computeWorkload` finds, Unassigned last. */ resources?: string[]; /** `'hours'` (default) draws raw hours; `'percent'` draws hours as a percentage of capacity, falling back to `'hours'` for a resource with no capacity; `'cost'` draws hours × rate (BACKLOG-0001866), falling back to `'hours'` for a resource with no rate data, with no capacity line in this unit. */ unit?: 'hours' | 'percent' | 'cost'; /** `'task'` stacks one segment per contributing task; `false` (default) draws one solid bar per bucket. */ stacked?: 'task' | false; /** The band's total height in pixels; default 160. */ height?: number; /** A band row's height in pixels; default 48. */ rowHeight?: number; }; }): <a href="#type-GanttSplitView">GanttSplitView</a></td><td class="desc"><code>container: unknown</code><br><code>options?: { height?: number; rowHeight?: number; headerHeight?: number; gridWidth?: number; indent?: number; zoom?: <a href="#type-GanttZoom">GanttZoom</a> | number; today?: number; nonWorking?: 'weekends' | ((day: number) =&gt; boolean); calendar?: <a href="#type-GanttCalendar">GanttCalendar</a> | null; showArrows?: boolean; showProgress?: boolean; showBaseline?: boolean; barLabel?: <a href="#type-GanttBarLabel">GanttBarLabel</a> | ((task: <a href="#type-GanttScheduledTask">GanttScheduledTask</a>) =&gt; 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 }; /** * The S-curve status-date progress line (BACKLOG-0001867): a vertical line * at the status date that jogs, at each task row, to that task's actual * progress point (start + %complete × duration). `true` uses the today line * (or the project finish); an object sets the status date explicitly. The * same status date drives the `plannedPercentComplete` column. */ progressLine?: boolean | { statusDate?: number | string | Date }; /** * Whether the plan can be edited: pointer drags on the timeline and the * left panel's inline cell editors (default true). Same meaning and * default as `mount`'s. */ editable?: boolean; /** * Keyboard editing + focusable bars + ARIA announcements on the timeline * (default true). Same meaning and default as `mount`'s. */ keyboard?: boolean; /** * Pixels from a bar's right edge that begin a resize rather than a move * (default 6). Same meaning and default as `mount`'s. */ resizeZone?: number; /** * The task tooltip (BACKLOG-0001921): the SAME positioned card `mount` * draws, anchored to the hovered or keyboard-focused bar. Default true. * See {@link <a href="#type-GanttTooltip">GanttTooltip</a>}. */ tooltip?: <a href="#type-GanttTooltip">GanttTooltip</a>; /** * A `{ t(key, params) }` resolver for the view's own text — the live * region's edit announcements. Omit it and a gantt bound to a grid borrows * that grid's catalogue; a standalone plan falls back to English. */ messages?: { t: (key: string, params?: Record&lt;string, unknown&gt;) =&gt; string }; /** * The left panel's columns. `kind` decides what the cell shows and what a * double-click edits: `'name'` the WBS tree (edits the name), `'assignee'` * the avatars, `'progress'` the % ring (edits `percentComplete`), `'evm'` * an earned-value `metric`, and `'start'`/`'end'`/`'duration'` the * scheduled window — an ISO date, an ISO date, and a whole number of days, * each of which edits the plan through the same path a bar drag takes * (BACKLOG-0001280). `'effort'` (hours) and `'units'` (a percentage, 100 = * one full-time resource) are the optional effort-driven columns * (BACKLOG-0001868); each edits through `applyEdit`, so the task * reschedules per its `schedulingMode`. A bare string names a built-in * column, so `['name', 'duration', 'effort', 'units']` is enough. On an * editable plan the assignee cell opens the assignment picker. A column * with no `kind` shows the raw task's `key` and edits it only with * `editable: true`. */ columns?: Array&lt;'name' | 'start' | 'end' | 'duration' | 'assignee' | 'progress' | 'effort' | 'units' | { key: string; title?: string; width?: number; kind?: 'name' | 'assignee' | 'progress' | 'evm' | 'plannedPercentComplete' | 'start' | 'end' | 'duration' | 'effort' | 'units' | 'number'; metric?: 'bac' | 'pv' | 'ev' | 'ac' | 'sv' | 'cv' | 'spi' | 'cpi'; digits?: number; editable?: boolean; editField?: string; render?: (task: GanttScheduledTask, ctx: { rawTask: GanttTask; depth: number }) =&gt; unknown }&gt;; /** * A resource workload band beneath the split view (BACKLOG-0001281): * one row per resource on the left and, on the right, that resource's * hours per time bucket — aligned column-for-column with the timeline's * scale header, scroll-locked to it horizontally (vertically it scrolls * on its own), and redrawn in the same paint as the bars whenever the * plan changes. `true` takes the defaults below; an object overrides * them; omitted, no band is drawn. * * **Editing (BACKLOG-0001282).** A resource row expands (a disclosure * button, `aria-expanded`) into one sub-row per task it carries. The * resource's own cell is the read-only aggregate; a SUB-ROW cell accepts * a typed number of hours on a double-click whenever the view's * `editable` is on. What is typed is written to that task's `work` * contour through the same `applyEdit` choke point (and the same * `beforeTaskEdit` veto) a bar drag uses, so the bar, the table row and * the band all move in one paint — including the span, which follows the * contour: type into a column beyond the bar and the bar grows to reach * it. A bucket containing no working day declines the edit and says so. * * **Where the hours come from.** They are DERIVED from the tasks, never * supplied: a task's own `work` (or `hours`) field when it carries a * finite one, otherwise `working days × hoursPerDay × units`, divided * between the task's assignments in proportion to their units and spread * evenly over the working days the task spans. Working days are the days * this view already shades — pass the `calendar`/`nonWorking` option the * plan is scheduled with. Resources, units and capacities are the gantt's * existing vocabulary (`assignee`/`assignees`/`owner`/`assignments` on a * task; `resources`/`defaultCapacity` on `createGantt`); a task naming no * resource is carried on an "Unassigned" row rather than dropped. An * empty bucket is blank, not `0`, and a bucket over * `capacity × hoursPerDay × the bucket's working days` is marked with a * class and an accessible label. */ workload?: boolean | { /** Hours a full-time (`units: 1`) resource works in a working day; default 8. */ hoursPerDay?: number; /** The band's height in pixels, taken from the view's own `height`; default 160. */ height?: number; /** A band row's height in pixels; default 28. */ rowHeight?: number; /** Maximum decimal places in a cell, trailing zeros dropped; default 1. */ decimals?: number; /** Draw the totals row and totals column; default true. */ totals?: boolean; /** * `'hours'` (default; an existing page is unchanged) draws booked * hours; `'percent'` draws hours as a share of the resource's own * available hours that bucket — `booked ÷ available × 100`, the SAME * available-hours figure the over-capacity highlight already uses * (the per-resource calendar included), falling back to hours for a * resource with no known capacity; a bucket with a KNOWN zero (a * part-timer's non-working day, a week wholly on leave) reads "–", * never `Infinity`/`NaN` (BACKLOG-0001879). An `&lt;button * aria-pressed&gt;` switch in the band's header toggles it (and the * histogram band's, when one is mounted) live; the same switch is * reachable off the view as `setWorkloadUnit`/`getWorkloadUnit`. * Editing in percent mode writes HOURS: typing `50` books half the * resource's available hours in that bucket, through the identical * `applyEdit` path an hours edit uses. `'cost'` draws hours × the * resource's rate in force each day (BACKLOG-0001866), read off the * SAME `computeWorkload` pass, falling back to hours for a resource * with no rate data; cost has no capacity concept, so there is no * over-highlight or capacity line in this unit. */ unit?: 'hours' | 'percent' | 'cost'; }; /** * A resource histogram band beneath the split view, below the workload * band when both are mounted (BACKLOG-0001860): one row per resource, * drawn as bars per time bucket rather than a table of numbers, with a * capacity line and a hover/focus tooltip. `true` takes the defaults * below; an object overrides them; omitted, no band is drawn. * * The bars come from the SAME derivation the workload band uses * (`computeWorkload`, driven off `work`/`hours`/`assignments` exactly as * documented on `workload` above) — this is a second PICTURE of the same * numbers, not a second source of them. The non-stacked bar for a bucket * over capacity carries both the normal fill up to capacity and the * over-allocation fill above it; `stacked: 'task'` additionally splits * the within-capacity portion into one coloured segment per contributing * task, still capped by the one over-allocation segment on top. An * accessible table (resource, period, hours/percent, capacity, * over-allocated) is rebuilt alongside the bars on every redraw. * * Mounted alongside `workload` at a fixed `height`, the two bands share * it rather than squeezing the timeline: the timeline keeps at least * half the view, the bands shrink in proportion when both do not * otherwise fit, and — rather than ever reading as an unreadably thin * sliver of bars — the histogram collapses to its header strip (with a * console warning naming the height it needs) when even its * proportional share would leave too little room for the plot. */ histogram?: boolean | { /** Which resources to draw, and in what order; omitted draws every resource `computeWorkload` finds, Unassigned last. */ resources?: string[]; /** `'hours'` (default) draws raw hours; `'percent'` draws hours as a percentage of capacity, falling back to `'hours'` for a resource with no capacity; `'cost'` draws hours × rate (BACKLOG-0001866), falling back to `'hours'` for a resource with no rate data, with no capacity line in this unit. */ unit?: 'hours' | 'percent' | 'cost'; /** `'task'` stacks one segment per contributing task; `false` (default) draws one solid bar per bucket. */ stacked?: 'task' | false; /** The band's total height in pixels; default 160. */ height?: number; /** A band row's height in pixels; default 48. */ rowHeight?: number; }; }</code></td><td class="type"><code><a href="#type-GanttSplitView">GanttSplitView</a></code></td><td class="desc">Mount the JOINED split view (BACKLOG-0000938): one continuous, row-aligned surface with a left task-grid panel — by default the Task Name tree with expand/collapse, start, finish, duration, assignee avatars and a circular % ring (BACKLOG-0001285), 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. The plan is editable from BOTH panes (BACKLOG-0001280): every gesture `mount` has — pointer drag to move, drag on the right edge to resize, arrow-key move, Shift+arrow resize, `l` to link, Delete — works on the timeline here, and a `start`/`end`/`duration`/`progress`/`name` column in the left panel is inline-editable on a double-click. Both routes commit through the same `applyEdit` choke point, so `beforeTaskMove`, `beforeTaskResize`, `beforeProgressChange` and `beforeTaskEdit` stay the single veto whichever pane the edit came from. The three switches that govern it carry the same meaning and the same defaults as `mount`'s: `editable` (default true) turns every edit on or off, both panes at once; `keyboard` (default true) turns off the focusable bars, the arrow-key gestures and the ARIA announcements while leaving pointer editing alone; and `resizeZone` (default 6) is how many pixels in from a bar's right edge begin a resize rather than a move. `workload` adds the resource band beneath the plan (BACKLOG-0001281), which is display-only — it reports hours, it does not accept them.</td></tr>
+          <tr><td class="name">mountSplit</td><td class="type">(container: unknown, options?: { height?: number; rowHeight?: number; headerHeight?: number; gridWidth?: number; indent?: number; zoom?: <a href="#type-GanttZoom">GanttZoom</a> | number; today?: number; nonWorking?: 'weekends' | ((day: number) =&gt; boolean); calendar?: <a href="#type-GanttCalendar">GanttCalendar</a> | null; showArrows?: boolean; showProgress?: boolean; showBaseline?: boolean; barLabel?: <a href="#type-GanttBarLabel">GanttBarLabel</a> | ((task: <a href="#type-GanttScheduledTask">GanttScheduledTask</a>) =&gt; 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 }; /** * The S-curve status-date progress line (BACKLOG-0001867): a vertical line * at the status date that jogs, at each task row, to that task's actual * progress point (start + %complete × duration). `true` uses the today line * (or the project finish); an object sets the status date explicitly. The * same status date drives the `plannedPercentComplete` column. */ progressLine?: boolean | { statusDate?: number | string | Date }; /** * Whether the plan can be edited: pointer drags on the timeline and the * left panel's inline cell editors (default true). Same meaning and * default as `mount`'s. */ editable?: boolean; /** * Keyboard editing + focusable bars + ARIA announcements on the timeline * (default true). Same meaning and default as `mount`'s. */ keyboard?: boolean; /** * Pixels from a bar's right edge that begin a resize rather than a move * (default 6). Same meaning and default as `mount`'s. */ resizeZone?: number; /** * The task tooltip (BACKLOG-0001921): the SAME positioned card `mount` * draws, anchored to the hovered or keyboard-focused bar. Default true. * See {@link <a href="#type-GanttTooltip">GanttTooltip</a>}. */ tooltip?: <a href="#type-GanttTooltip">GanttTooltip</a>; /** * A `{ t(key, params) }` resolver for the view's own text — the live * region's edit announcements. Omit it and a gantt bound to a grid borrows * that grid's catalogue; a standalone plan falls back to English. */ messages?: { t: (key: string, params?: Record&lt;string, unknown&gt;) =&gt; string }; /** * The left panel's columns. `kind` decides what the cell shows and what a * double-click edits: `'name'` the WBS tree (edits the name), `'assignee'` * the avatars, `'progress'` the % ring (edits `percentComplete`), `'evm'` * an earned-value `metric`, and `'start'`/`'end'`/`'duration'` the * scheduled window — an ISO date, an ISO date, and a whole number of days, * each of which edits the plan through the same path a bar drag takes * (BACKLOG-0001280). `'effort'` (hours) and `'units'` (a percentage, 100 = * one full-time resource) are the optional effort-driven columns * (BACKLOG-0001868); each edits through `applyEdit`, so the task * reschedules per its `schedulingMode`. A bare string names a built-in * column, so `['name', 'duration', 'effort', 'units']` is enough. On an * editable plan the assignee cell opens the assignment picker. A column * with no `kind` shows the raw task's `key` and edits it only with * `editable: true`. * * Every column header carries a draggable right border with a * col-resize cursor (BACKLOG-0001924): a pointer drag, or arrow keys * once the border itself is focused (8px a press, 32px with Shift). * `minWidth`/`maxWidth` clamp how far it goes; `resizable: false` omits * the border entirely. The table/timeline divider (`gridWidth`) is the * same gesture; a settled drag or keystroke on either fires exactly one * `columnResize`, and every width — the divider's included, under the * key `'grid'` — round-trips through `getState`/`setState`. */ columns?: Array&lt;'name' | 'start' | 'end' | 'duration' | 'assignee' | 'progress' | 'effort' | 'units' | { key: string; title?: string; width?: number; kind?: 'name' | 'assignee' | 'progress' | 'evm' | 'plannedPercentComplete' | 'start' | 'end' | 'duration' | 'effort' | 'units' | 'number'; metric?: 'bac' | 'pv' | 'ev' | 'ac' | 'sv' | 'cv' | 'spi' | 'cpi'; digits?: number; editable?: boolean; editField?: string; /** The narrowest this column can be dragged/keyed to (BACKLOG-0001924); default 80 for `kind: 'name'`, 40 otherwise. */ minWidth?: number; /** The widest this column can be dragged/keyed to (BACKLOG-0001924); default unbounded. */ maxWidth?: number; /** `false` omits the resize border on this column's header (BACKLOG-0001924); default true. */ resizable?: boolean; render?: (task: GanttScheduledTask, ctx: { rawTask: GanttTask; depth: number }) =&gt; unknown; }&gt;; /** * A resource workload band beneath the split view (BACKLOG-0001281): * one row per resource on the left and, on the right, that resource's * hours per time bucket — aligned column-for-column with the timeline's * scale header, scroll-locked to it horizontally (vertically it scrolls * on its own), and redrawn in the same paint as the bars whenever the * plan changes. `true` takes the defaults below; an object overrides * them; omitted, no band is drawn. * * **Editing (BACKLOG-0001282).** A resource row expands (a disclosure * button, `aria-expanded`) into one sub-row per task it carries. The * resource's own cell is the read-only aggregate; a SUB-ROW cell accepts * a typed number of hours on a double-click whenever the view's * `editable` is on. What is typed is written to that task's `work` * contour through the same `applyEdit` choke point (and the same * `beforeTaskEdit` veto) a bar drag uses, so the bar, the table row and * the band all move in one paint — including the span, which follows the * contour: type into a column beyond the bar and the bar grows to reach * it. A bucket containing no working day declines the edit and says so. * * **Where the hours come from.** They are DERIVED from the tasks, never * supplied: a task's own `work` (or `hours`) field when it carries a * finite one, otherwise `working days × hoursPerDay × units`, divided * between the task's assignments in proportion to their units and spread * evenly over the working days the task spans. Working days are the days * this view already shades — pass the `calendar`/`nonWorking` option the * plan is scheduled with. Resources, units and capacities are the gantt's * existing vocabulary (`assignee`/`assignees`/`owner`/`assignments` on a * task; `resources`/`defaultCapacity` on `createGantt`); a task naming no * resource is carried on an "Unassigned" row rather than dropped. An * empty bucket is blank, not `0`, and a bucket over * `capacity × hoursPerDay × the bucket's working days` is marked with a * class and an accessible label. */ workload?: boolean | { /** Hours a full-time (`units: 1`) resource works in a working day; default 8. */ hoursPerDay?: number; /** The band's height in pixels, taken from the view's own `height`; default 160. */ height?: number; /** A band row's height in pixels; default 28. */ rowHeight?: number; /** Maximum decimal places in a cell, trailing zeros dropped; default 1. */ decimals?: number; /** Draw the totals row and totals column; default true. */ totals?: boolean; /** * `'hours'` (default; an existing page is unchanged) draws booked * hours; `'percent'` draws hours as a share of the resource's own * available hours that bucket — `booked ÷ available × 100`, the SAME * available-hours figure the over-capacity highlight already uses * (the per-resource calendar included), falling back to hours for a * resource with no known capacity; a bucket with a KNOWN zero (a * part-timer's non-working day, a week wholly on leave) reads "–", * never `Infinity`/`NaN` (BACKLOG-0001879). An `&lt;button * aria-pressed&gt;` switch in the band's header toggles it (and the * histogram band's, when one is mounted) live; the same switch is * reachable off the view as `setWorkloadUnit`/`getWorkloadUnit`. * Editing in percent mode writes HOURS: typing `50` books half the * resource's available hours in that bucket, through the identical * `applyEdit` path an hours edit uses. `'cost'` draws hours × the * resource's rate in force each day (BACKLOG-0001866), read off the * SAME `computeWorkload` pass, falling back to hours for a resource * with no rate data; cost has no capacity concept, so there is no * over-highlight or capacity line in this unit. */ unit?: 'hours' | 'percent' | 'cost'; }; /** * A resource histogram band beneath the split view, below the workload * band when both are mounted (BACKLOG-0001860): one row per resource, * drawn as bars per time bucket rather than a table of numbers, with a * capacity line and a hover/focus tooltip. `true` takes the defaults * below; an object overrides them; omitted, no band is drawn. * * The bars come from the SAME derivation the workload band uses * (`computeWorkload`, driven off `work`/`hours`/`assignments` exactly as * documented on `workload` above) — this is a second PICTURE of the same * numbers, not a second source of them. The non-stacked bar for a bucket * over capacity carries both the normal fill up to capacity and the * over-allocation fill above it; `stacked: 'task'` additionally splits * the within-capacity portion into one coloured segment per contributing * task, still capped by the one over-allocation segment on top. An * accessible table (resource, period, hours/percent, capacity, * over-allocated) is rebuilt alongside the bars on every redraw. * * Mounted alongside `workload` at a fixed `height`, the two bands share * it rather than squeezing the timeline: the timeline keeps at least * half the view, the bands shrink in proportion when both do not * otherwise fit, and — rather than ever reading as an unreadably thin * sliver of bars — the histogram collapses to its header strip (with a * console warning naming the height it needs) when even its * proportional share would leave too little room for the plot. */ histogram?: boolean | { /** Which resources to draw, and in what order; omitted draws every resource `computeWorkload` finds, Unassigned last. */ resources?: string[]; /** `'hours'` (default) draws raw hours; `'percent'` draws hours as a percentage of capacity, falling back to `'hours'` for a resource with no capacity; `'cost'` draws hours × rate (BACKLOG-0001866), falling back to `'hours'` for a resource with no rate data, with no capacity line in this unit. */ unit?: 'hours' | 'percent' | 'cost'; /** `'task'` stacks one segment per contributing task; `false` (default) draws one solid bar per bucket. */ stacked?: 'task' | false; /** The band's total height in pixels; default 160. */ height?: number; /** A band row's height in pixels; default 48. */ rowHeight?: number; }; }): <a href="#type-GanttSplitView">GanttSplitView</a></td><td class="desc"><code>container: unknown</code><br><code>options?: { height?: number; rowHeight?: number; headerHeight?: number; gridWidth?: number; indent?: number; zoom?: <a href="#type-GanttZoom">GanttZoom</a> | number; today?: number; nonWorking?: 'weekends' | ((day: number) =&gt; boolean); calendar?: <a href="#type-GanttCalendar">GanttCalendar</a> | null; showArrows?: boolean; showProgress?: boolean; showBaseline?: boolean; barLabel?: <a href="#type-GanttBarLabel">GanttBarLabel</a> | ((task: <a href="#type-GanttScheduledTask">GanttScheduledTask</a>) =&gt; 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 }; /** * The S-curve status-date progress line (BACKLOG-0001867): a vertical line * at the status date that jogs, at each task row, to that task's actual * progress point (start + %complete × duration). `true` uses the today line * (or the project finish); an object sets the status date explicitly. The * same status date drives the `plannedPercentComplete` column. */ progressLine?: boolean | { statusDate?: number | string | Date }; /** * Whether the plan can be edited: pointer drags on the timeline and the * left panel's inline cell editors (default true). Same meaning and * default as `mount`'s. */ editable?: boolean; /** * Keyboard editing + focusable bars + ARIA announcements on the timeline * (default true). Same meaning and default as `mount`'s. */ keyboard?: boolean; /** * Pixels from a bar's right edge that begin a resize rather than a move * (default 6). Same meaning and default as `mount`'s. */ resizeZone?: number; /** * The task tooltip (BACKLOG-0001921): the SAME positioned card `mount` * draws, anchored to the hovered or keyboard-focused bar. Default true. * See {@link <a href="#type-GanttTooltip">GanttTooltip</a>}. */ tooltip?: <a href="#type-GanttTooltip">GanttTooltip</a>; /** * A `{ t(key, params) }` resolver for the view's own text — the live * region's edit announcements. Omit it and a gantt bound to a grid borrows * that grid's catalogue; a standalone plan falls back to English. */ messages?: { t: (key: string, params?: Record&lt;string, unknown&gt;) =&gt; string }; /** * The left panel's columns. `kind` decides what the cell shows and what a * double-click edits: `'name'` the WBS tree (edits the name), `'assignee'` * the avatars, `'progress'` the % ring (edits `percentComplete`), `'evm'` * an earned-value `metric`, and `'start'`/`'end'`/`'duration'` the * scheduled window — an ISO date, an ISO date, and a whole number of days, * each of which edits the plan through the same path a bar drag takes * (BACKLOG-0001280). `'effort'` (hours) and `'units'` (a percentage, 100 = * one full-time resource) are the optional effort-driven columns * (BACKLOG-0001868); each edits through `applyEdit`, so the task * reschedules per its `schedulingMode`. A bare string names a built-in * column, so `['name', 'duration', 'effort', 'units']` is enough. On an * editable plan the assignee cell opens the assignment picker. A column * with no `kind` shows the raw task's `key` and edits it only with * `editable: true`. * * Every column header carries a draggable right border with a * col-resize cursor (BACKLOG-0001924): a pointer drag, or arrow keys * once the border itself is focused (8px a press, 32px with Shift). * `minWidth`/`maxWidth` clamp how far it goes; `resizable: false` omits * the border entirely. The table/timeline divider (`gridWidth`) is the * same gesture; a settled drag or keystroke on either fires exactly one * `columnResize`, and every width — the divider's included, under the * key `'grid'` — round-trips through `getState`/`setState`. */ columns?: Array&lt;'name' | 'start' | 'end' | 'duration' | 'assignee' | 'progress' | 'effort' | 'units' | { key: string; title?: string; width?: number; kind?: 'name' | 'assignee' | 'progress' | 'evm' | 'plannedPercentComplete' | 'start' | 'end' | 'duration' | 'effort' | 'units' | 'number'; metric?: 'bac' | 'pv' | 'ev' | 'ac' | 'sv' | 'cv' | 'spi' | 'cpi'; digits?: number; editable?: boolean; editField?: string; /** The narrowest this column can be dragged/keyed to (BACKLOG-0001924); default 80 for `kind: 'name'`</code><br><code>40 otherwise. */ minWidth?: number; /** The widest this column can be dragged/keyed to (BACKLOG-0001924); default unbounded. */ maxWidth?: number; /** `false` omits the resize border on this column's header (BACKLOG-0001924); default true. */ resizable?: boolean; render?: (task: GanttScheduledTask, ctx: { rawTask: GanttTask; depth: number }) =&gt; unknown; }&gt;; /** * A resource workload band beneath the split view (BACKLOG-0001281): * one row per resource on the left and, on the right, that resource's * hours per time bucket — aligned column-for-column with the timeline's * scale header, scroll-locked to it horizontally (vertically it scrolls * on its own), and redrawn in the same paint as the bars whenever the * plan changes. `true` takes the defaults below; an object overrides * them; omitted, no band is drawn. * * **Editing (BACKLOG-0001282).** A resource row expands (a disclosure * button, `aria-expanded`) into one sub-row per task it carries. The * resource's own cell is the read-only aggregate; a SUB-ROW cell accepts * a typed number of hours on a double-click whenever the view's * `editable` is on. What is typed is written to that task's `work` * contour through the same `applyEdit` choke point (and the same * `beforeTaskEdit` veto) a bar drag uses, so the bar, the table row and * the band all move in one paint — including the span, which follows the * contour: type into a column beyond the bar and the bar grows to reach * it. A bucket containing no working day declines the edit and says so. * * **Where the hours come from.** They are DERIVED from the tasks, never * supplied: a task's own `work` (or `hours`) field when it carries a * finite one, otherwise `working days × hoursPerDay × units`, divided * between the task's assignments in proportion to their units and spread * evenly over the working days the task spans. Working days are the days * this view already shades — pass the `calendar`/`nonWorking` option the * plan is scheduled with. Resources, units and capacities are the gantt's * existing vocabulary (`assignee`/`assignees`/`owner`/`assignments` on a * task; `resources`/`defaultCapacity` on `createGantt`); a task naming no * resource is carried on an "Unassigned" row rather than dropped. An * empty bucket is blank, not `0`, and a bucket over * `capacity × hoursPerDay × the bucket's working days` is marked with a * class and an accessible label. */ workload?: boolean | { /** Hours a full-time (`units: 1`) resource works in a working day; default 8. */ hoursPerDay?: number; /** The band's height in pixels, taken from the view's own `height`; default 160. */ height?: number; /** A band row's height in pixels; default 28. */ rowHeight?: number; /** Maximum decimal places in a cell, trailing zeros dropped; default 1. */ decimals?: number; /** Draw the totals row and totals column; default true. */ totals?: boolean; /** * `'hours'` (default; an existing page is unchanged) draws booked * hours; `'percent'` draws hours as a share of the resource's own * available hours that bucket — `booked ÷ available × 100`, the SAME * available-hours figure the over-capacity highlight already uses * (the per-resource calendar included), falling back to hours for a * resource with no known capacity; a bucket with a KNOWN zero (a * part-timer's non-working day, a week wholly on leave) reads "–", * never `Infinity`/`NaN` (BACKLOG-0001879). An `&lt;button * aria-pressed&gt;` switch in the band's header toggles it (and the * histogram band's, when one is mounted) live; the same switch is * reachable off the view as `setWorkloadUnit`/`getWorkloadUnit`. * Editing in percent mode writes HOURS: typing `50` books half the * resource's available hours in that bucket, through the identical * `applyEdit` path an hours edit uses. `'cost'` draws hours × the * resource's rate in force each day (BACKLOG-0001866), read off the * SAME `computeWorkload` pass, falling back to hours for a resource * with no rate data; cost has no capacity concept, so there is no * over-highlight or capacity line in this unit. */ unit?: 'hours' | 'percent' | 'cost'; }; /** * A resource histogram band beneath the split view, below the workload * band when both are mounted (BACKLOG-0001860): one row per resource, * drawn as bars per time bucket rather than a table of numbers, with a * capacity line and a hover/focus tooltip. `true` takes the defaults * below; an object overrides them; omitted, no band is drawn. * * The bars come from the SAME derivation the workload band uses * (`computeWorkload`, driven off `work`/`hours`/`assignments` exactly as * documented on `workload` above) — this is a second PICTURE of the same * numbers, not a second source of them. The non-stacked bar for a bucket * over capacity carries both the normal fill up to capacity and the * over-allocation fill above it; `stacked: 'task'` additionally splits * the within-capacity portion into one coloured segment per contributing * task, still capped by the one over-allocation segment on top. An * accessible table (resource, period, hours/percent, capacity, * over-allocated) is rebuilt alongside the bars on every redraw. * * Mounted alongside `workload` at a fixed `height`, the two bands share * it rather than squeezing the timeline: the timeline keeps at least * half the view, the bands shrink in proportion when both do not * otherwise fit, and — rather than ever reading as an unreadably thin * sliver of bars — the histogram collapses to its header strip (with a * console warning naming the height it needs) when even its * proportional share would leave too little room for the plot. */ histogram?: boolean | { /** Which resources to draw, and in what order; omitted draws every resource `computeWorkload` finds, Unassigned last. */ resources?: string[]; /** `'hours'` (default) draws raw hours; `'percent'` draws hours as a percentage of capacity, falling back to `'hours'` for a resource with no capacity; `'cost'` draws hours × rate (BACKLOG-0001866), falling back to `'hours'` for a resource with no rate data, with no capacity line in this unit. */ unit?: 'hours' | 'percent' | 'cost'; /** `'task'` stacks one segment per contributing task; `false` (default) draws one solid bar per bucket. */ stacked?: 'task' | false; /** The band's total height in pixels; default 160. */ height?: number; /** A band row's height in pixels; default 48. */ rowHeight?: number; }; }</code></td><td class="type"><code><a href="#type-GanttSplitView">GanttSplitView</a></code></td><td class="desc">Mount the JOINED split view (BACKLOG-0000938): one continuous, row-aligned surface with a left task-grid panel — by default the Task Name tree with expand/collapse, start, finish, duration, assignee avatars and a circular % ring (BACKLOG-0001285), 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. The plan is editable from BOTH panes (BACKLOG-0001280): every gesture `mount` has — pointer drag to move, drag on the right edge to resize, arrow-key move, Shift+arrow resize, `l` to link, Delete — works on the timeline here, and a `start`/`end`/`duration`/`progress`/`name` column in the left panel is inline-editable on a double-click. Both routes commit through the same `applyEdit` choke point, so `beforeTaskMove`, `beforeTaskResize`, `beforeProgressChange` and `beforeTaskEdit` stay the single veto whichever pane the edit came from. The three switches that govern it carry the same meaning and the same defaults as `mount`'s: `editable` (default true) turns every edit on or off, both panes at once; `keyboard` (default true) turns off the focusable bars, the arrow-key gestures and the ARIA announcements while leaving pointer editing alone; and `resizeZone` (default 6) is how many pixels in from a bar's right edge begin a resize rather than a move. `workload` adds the resource band beneath the plan (BACKLOG-0001281), which is display-only — it reports hours, it does not accept them.</td></tr>
           <tr><td class="name">captureBaseline</td><td class="type">(): Array&lt;{ id: string; baselineStart: number; baselineEnd: number; baselineDuration: number }&gt;</td><td class="desc">&mdash;</td><td class="type"><code>Array&lt;{ id: string; baselineStart: number; baselineEnd: number; baselineDuration: number }&gt;</code></td><td class="desc">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.</td></tr>
           <tr><td class="name">earnedValue</td><td class="type">(evmOpts?: { statusDate?: number | string | Date; costField?: string; actualCostField?: string }): <a href="#type-GanttEarnedValue">GanttEarnedValue</a></td><td class="desc"><code>evmOpts?: { statusDate?: number | string | Date; costField?: string; actualCostField?: string }</code></td><td class="type"><code><a href="#type-GanttEarnedValue">GanttEarnedValue</a></code></td><td class="desc">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`.</td></tr>
           <tr><td class="name">sCurve</td><td class="type">(scurveOpts?: { statusDate?: number | string | Date; bucket?: 'day' | 'week' | 'month'; costField?: string; actualCostField?: string }): <a href="#type-GanttSCurvePoint">GanttSCurvePoint</a>[]</td><td class="desc"><code>scurveOpts?: { statusDate?: number | string | Date; bucket?: 'day' | 'week' | 'month'; costField?: string; actualCostField?: string }</code></td><td class="type"><code><a href="#type-GanttSCurvePoint">GanttSCurvePoint</a>[]</code></td><td class="desc">Compute the cumulative S-curve for the current plan (BACKLOG-0001867) — one `{ date, pv, ev, ac }` point per time bucket from the project start to the project finish. The same arithmetic `earnedValue` performs, evaluated over time: PV climbs to the total budget at the finish, EV and AC stop at the status date.</td></tr>
@@ -23552,6 +23607,7 @@ return `next ${p.mean.toFixed(1)}; r2 ${f.r2.toFixed(1)}; band ${p.upper - p.low
           <tr><td class="name">dependencyCreate:cancelled</td><td class="desc">A `beforeDependencyCreate` handler refused the links.</td><td class="type"><a href="#type-GanttDependencyCreateCancelledEvent">GanttDependencyCreateCancelledEvent</a></td><td class="desc">no</td></tr>
           <tr><td class="name">taskDelete:cancelled</td><td class="desc">A `beforeTaskDelete` handler refused the delete.</td><td class="type"><a href="#type-GanttTaskDeleteCancelledEvent">GanttTaskDeleteCancelledEvent</a></td><td class="desc">no</td></tr>
           <tr><td class="name">history</td><td class="desc">The undo/redo timeline changed — an edit was recorded, undone, redone or cleared (BACKLOG-0001864).</td><td class="type"><a href="#type-GanttHistoryEvent">GanttHistoryEvent</a></td><td class="desc">no</td></tr>
+          <tr><td class="name">columnResize</td><td class="desc">A split-view column border or the table/timeline divider finished a drag or keyboard resize (BACKLOG-0001924). Fired once per gesture, never mid-drag.</td><td class="type"><a href="#type-GanttColumnResizeEvent">GanttColumnResizeEvent</a></td><td class="desc">no</td></tr>
         </tbody>
       </table>
     </div>
@@ -27941,7 +27997,7 @@ return `next ${p.mean.toFixed(1)}; r2 ${f.r2.toFixed(1)}; band ${p.upper - p.low
     <p class="section-note"><small>Declared in <code>lattice-grid/modules/gantt</code>.</small></p>
     <h4 id="type-GanttEventName">GanttEventName</h4>
     <p class="section-note">The events a Gantt controller raises. The controller's own, not a grid's: `grid.on` takes {@link EventName} and knows nothing about these, and a grid-bound Gantt follows the grid's events itself rather than re-publishing them. `on()` takes a name and a listener and warns about nothing, so a misspelt name is a subscription that never fires. The seven `before…` events are cancellable ({@link GanttBeforeEvent}); each has a matching `&lt;action&gt;:cancelled` that fires when a handler refuses, carrying the same context plus the reason. `schedule` and `error` are the recompute's own pair and are raised on every recompute, whatever caused it.</p>
-    <p class="type-def"><code>type GanttEventName = 'schedule' | 'error' | 'beforeTaskEdit' | 'beforeTaskMove' | 'beforeTaskResize' | 'beforeProgressChange' | 'beforeMilestoneMove' | 'beforeDependencyCreate' | 'beforeTaskDelete' | 'taskEdit:cancelled' | 'taskMove:cancelled' | 'taskResize:cancelled' | 'progressChange:cancelled' | 'milestoneMove:cancelled' | 'dependencyCreate:cancelled' | 'taskDelete:cancelled' | 'history'</code></p>
+    <p class="type-def"><code>type GanttEventName = 'schedule' | 'error' | 'beforeTaskEdit' | 'beforeTaskMove' | 'beforeTaskResize' | 'beforeProgressChange' | 'beforeMilestoneMove' | 'beforeDependencyCreate' | 'beforeTaskDelete' | 'taskEdit:cancelled' | 'taskMove:cancelled' | 'taskResize:cancelled' | 'progressChange:cancelled' | 'milestoneMove:cancelled' | 'dependencyCreate:cancelled' | 'taskDelete:cancelled' | 'history' | 'columnResize'</code></p>
     <p class="section-note"><small>Declared in <code>lattice-grid/modules/gantt</code>.</small></p>
     <h4 id="type-GanttLinkType">GanttLinkType</h4>
     <p class="section-note">One of the four dependency link types (finish-to-start, start-to-start, finish-to-finish, start-to-finish).</p>
@@ -28543,7 +28599,7 @@ return `next ${p.mean.toFixed(1)}; r2 ${f.r2.toFixed(1)}; band ${p.upper - p.low
 <!-- END GENERATED TYPE REFERENCE -->
 
     <footer>
-      Lattice Grid 1.88.2 · Copyright © 2026 TOCLOCO Inc. All rights reserved.
+      Lattice Grid 1.88.3 · Copyright © 2026 TOCLOCO Inc. All rights reserved.
       This document describes the behaviour of the shipped library. Where this guide and the code
       disagree, the code wins: please <a href="https://www.latticegrid.dev">tell us</a>.
     </footer>

package/docs/api/adapters.html

@@ -13,7 +13,7 @@
   Self-contained: no stylesheet, script or font is fetched, so this opens from disk, from
   a file share or from behind a firewall with nothing else present.
 -->
-<title>Adapters API Reference — Lattice Grid 1.88.2</title>
+<title>Adapters API Reference — Lattice Grid 1.88.3</title>
 <style>
   /* ---------------------------------------------------------------
      Palette lifted from the grid's own theme, so the reference reads as an

package/docs/api/ai.html

@@ -13,7 +13,7 @@
   Self-contained: no stylesheet, script or font is fetched, so this opens from disk, from
   a file share or from behind a firewall with nothing else present.
 -->
-<title>AI API Reference — Lattice Grid 1.88.2</title>
+<title>AI API Reference — Lattice Grid 1.88.3</title>
 <style>
   /* ---------------------------------------------------------------
      Palette lifted from the grid's own theme, so the reference reads as an

package/docs/api/alarms.html

@@ -13,7 +13,7 @@
   Self-contained: no stylesheet, script or font is fetched, so this opens from disk, from
   a file share or from behind a firewall with nothing else present.
 -->
-<title>Alarms API Reference — Lattice Grid 1.88.2</title>
+<title>Alarms API Reference — Lattice Grid 1.88.3</title>
 <style>
   /* ---------------------------------------------------------------
      Palette lifted from the grid's own theme, so the reference reads as an

package/docs/api/calendar.html

@@ -13,7 +13,7 @@
   Self-contained: no stylesheet, script or font is fetched, so this opens from disk, from
   a file share or from behind a firewall with nothing else present.
 -->
-<title>Calendar API Reference — Lattice Grid 1.88.2</title>
+<title>Calendar API Reference — Lattice Grid 1.88.3</title>
 <style>
   /* ---------------------------------------------------------------
      Palette lifted from the grid's own theme, so the reference reads as an

package/docs/api/charts.html

@@ -13,7 +13,7 @@
   Self-contained: no stylesheet, script or font is fetched, so this opens from disk, from
   a file share or from behind a firewall with nothing else present.
 -->
-<title>Charts API Reference — Lattice Grid 1.88.2</title>
+<title>Charts API Reference — Lattice Grid 1.88.3</title>
 <style>
   /* ---------------------------------------------------------------
      Palette lifted from the grid's own theme, so the reference reads as an

package/docs/api/dashboard.html

@@ -13,7 +13,7 @@
   Self-contained: no stylesheet, script or font is fetched, so this opens from disk, from
   a file share or from behind a firewall with nothing else present.
 -->
-<title>Dashboard API Reference — Lattice Grid 1.88.2</title>
+<title>Dashboard API Reference — Lattice Grid 1.88.3</title>
 <style>
   /* ---------------------------------------------------------------
      Palette lifted from the grid's own theme, so the reference reads as an

package/docs/api/data-router.html

@@ -13,7 +13,7 @@
   Self-contained: no stylesheet, script or font is fetched, so this opens from disk, from
   a file share or from behind a firewall with nothing else present.
 -->
-<title>Data router API Reference — Lattice Grid 1.88.2</title>
+<title>Data router API Reference — Lattice Grid 1.88.3</title>
 <style>
   /* ---------------------------------------------------------------
      Palette lifted from the grid's own theme, so the reference reads as an

package/docs/api/deckgl.html

@@ -13,7 +13,7 @@
   Self-contained: no stylesheet, script or font is fetched, so this opens from disk, from
   a file share or from behind a firewall with nothing else present.
 -->
-<title>deck.gl API Reference — Lattice Grid 1.88.2</title>
+<title>deck.gl API Reference — Lattice Grid 1.88.3</title>
 <style>
   /* ---------------------------------------------------------------
      Palette lifted from the grid's own theme, so the reference reads as an