@oh-my-pi/pi-tui 18.6.3 → 18.7.0

package/CHANGELOG.md

@@ -2,6 +2,31 @@
 
 ## [Unreleased]
 
+## [18.7.0] - 2026-10-06
+
+### Added
+
+- Assistant SVG code blocks now render as inline, theme-colored images on terminals with graphics support, updating as responses stream and adapting to terminal width; SVG that cannot be rendered remains available as code.
+- Numeric tables in assistant responses can now include automatically selected, themed charts based on the table’s structure and units.
+
+### Changed
+
+- The status line now recognizes projects located in the user’s `repos` directory.
+- Model mentions, `/switch` completions, and model-picker search now update immediately while typing, including with large model catalogs.
+
+### Fixed
+
+- Fixed terminal resizing issues that could cause flicker or briefly display an empty frame.
+- Improved `/annotate` handling for long source lines and filenames, preserving indentation and typed note text.
+- Fixed fullscreen inputs that could hide the cursor when hardware-cursor support was enabled.
+- Fixed model picker and mention-list ordering for same-provider `-latest` models so results remain alphabetically stable.
+- Model browser performance metrics now show the correct measurements for each service tier and identify the tier.
+- Fixed plan review keyboard navigation so horizontal options use Left/Right and model-slider adjustments use Shift+Left/Right.
+- Improved the Ask dialog footer so question-switching keyboard shortcuts are clearly labeled.
+- Fixed creating a new agent when its generated system prompt contains a Markdown code fence.
+- Timed-out `glob` scans are now labeled as timed out rather than truncated.
+- Ctrl+Delete now deletes the word after the cursor, matching Ctrl+Backspace behavior.
+
 ## [18.6.3] - 2026-10-06
 
 ### Breaking Changes
@@ -2998,61 +3023,4 @@ Initial release under @oh-my-pi scope. See previous releases at [badlogic/pi-mon
 
 - `Editor.getExpandedText()` method that returns text with paste markers expanded to their actual content ([#444](https://github.com/badlogic/pi-mono/pull/444) by [@aliou](https://github.com/aliou))
 
-## [0.33.0] - 2026-01-04
-
-### Breaking Changes
-
-- **Key detection functions removed**: All `isXxx()` key detection functions (`isEnter()`, `isEscape()`, `isCtrlC()`, etc.) have been removed. Use `matchesKey(data, keyId)` instead (e.g., `matchesKey(data, "enter")`, `matchesKey(data, "ctrl+c")`). This affects hooks and custom tools that use `ctx.ui.custom()` with keyboard input handling. ([#405](https://github.com/badlogic/pi-mono/pull/405))
-
-### Added
-
-- `Editor.insertTextAtCursor(text)` method for programmatic text insertion ([#419](https://github.com/badlogic/pi-mono/issues/419))
-- `EditorKeybindingsManager` for configurable editor keybindings. Components now use `matchesKey()` and keybindings manager instead of individual `isXxx()` functions. ([#405](https://github.com/badlogic/pi-mono/pull/405) by [@hjanuschka](https://github.com/hjanuschka))
-
-### Changed
-
-- Key detection refactored: consolidated `is*()` functions into generic `matchesKey(data, keyId)` function that accepts key identifiers like `"ctrl+c"`, `"shift+enter"`, `"alt+left"`, etc.
-
-## [0.32.2] - 2026-01-03
-
-### Fixed
-
-- Slash command autocomplete now triggers for commands starting with `.`, `-`, or `_` (e.g., `/.land`, `/-foo`) ([#422](https://github.com/badlogic/pi-mono/issues/422))
-
-## [0.32.0] - 2026-01-03
-
-### Changed
-
-- Editor component now uses word wrapping instead of character-level wrapping for better readability ([#382](https://github.com/badlogic/pi-mono/pull/382) by [@nickseelert](https://github.com/nickseelert))
-
-### Fixed
-
-- Shift+Space, Shift+Backspace, and Shift+Delete now work correctly in Kitty-protocol terminals (Kitty, WezTerm, etc.) instead of being silently ignored ([#411](https://github.com/badlogic/pi-mono/pull/411) by [@nathyong](https://github.com/nathyong))
-
-## [0.31.1] - 2026-01-02
-
-### Fixed
-
-- `visibleWidth()` now strips OSC 8 hyperlink sequences, fixing text wrapping for clickable links ([#396](https://github.com/badlogic/pi-mono/pull/396) by [@Cursivez](https://github.com/Cursivez))
-
-## [0.31.0] - 2026-01-02
-
-### Added
-
-- `isShiftCtrlO()` key detection function for Shift+Ctrl+O (Kitty protocol)
-- `isShiftCtrlD()` key detection function for Shift+Ctrl+D (Kitty protocol)
-- `TUI.onDebug` callback for global debug key handling (Shift+Ctrl+D)
-- `wrapTextWithAnsi()` utility now exported (wraps text to width, preserving ANSI codes)
-
-### Changed
-
-- README.md completely rewritten with accurate component documentation, theme interfaces, and examples
-- `visibleWidth()` reimplemented with grapheme-based width calculation, 10x faster on Bun and ~15% faster on Node ([#369](https://github.com/badlogic/pi-mono/pull/369) by [@nathyong](https://github.com/nathyong))
-
-### Fixed
-
-- Markdown component now renders HTML tags as plain text instead of silently dropping them ([#359](https://github.com/badlogic/pi-mono/issues/359))
-- Crash in `visibleWidth()` and grapheme iteration when encountering undefined code points ([#372](https://github.com/badlogic/pi-mono/pull/372) by [@HACKE-RC](https://github.com/HACKE-RC))
-- ZWJ emoji sequences (rainbow flag, family, etc.) now render with correct width instead of being split into multiple characters ([#369](https://github.com/badlogic/pi-mono/pull/369) by [@nathyong](https://github.com/nathyong))
-
-Older entries are archived in [packages/tui/CHANGELOG.md@bac7e83b5b0e](https://github.com/can1357/oh-my-pi/blob/bac7e83b5b0eb86c909c17830a6666efc359578b/packages/tui/CHANGELOG.md).
+Older entries are archived in [packages/tui/CHANGELOG.md@58141d4e5fa8](https://github.com/can1357/oh-my-pi/blob/58141d4e5fa892166024e2168866c45e0baacde3/packages/tui/CHANGELOG.md).

package/dist/types/app-keybindings.d.ts

@@ -119,7 +119,7 @@ export declare const KEYBINDINGS: {
         readonly description: "Delete word backward";
     };
     readonly "tui.editor.deleteWordForward": {
-        readonly defaultKeys: ["alt+delete", "alt+d", "super+alt+delete", "super+alt+d"];
+        readonly defaultKeys: ["alt+delete", "alt+d", "ctrl+delete", "super+alt+delete", "super+alt+d"];
         readonly description: "Delete word forward";
     };
     readonly "tui.editor.deleteToLineStart": {

package/dist/types/autocomplete.d.ts

@@ -77,8 +77,11 @@ export interface AutocompleteProvider {
     };
     /** Get inline hint text to show as dim ghost text after the cursor */
     getInlineHint?(lines: string[], cursorLine: number, cursorCol: number): string | null;
-    /** Synchronously try to complete a slash command at the start of a line (no async I/O). */
-    /** Returns matched items and the full prefix, or null if not applicable. */
+    /**
+     * Synchronously list slash command-name completions for a leading slash token (no async I/O).
+     * Mirrors the command-name branch of {@link getSuggestions}, including the bare `/` listing and
+     * the collapsed `/skill:` namespace row. Returns null outside a command-name token or with no match.
+     */
     trySyncSlashCompletion?(textBeforeCursor: string): {
         items: AutocompleteItem[];
         prefix: string;

package/dist/types/charts/chart-plan.d.ts

@@ -0,0 +1,92 @@
+/**
+ * Which chart a table becomes and the data it plots. {@link planChart} is the
+ * local best guess over a {@link TableAnalysis}: the chart kind, the label
+ * column and the measure columns to draw. A host may substitute its own
+ * {@link ChartPlan} (a model's pick for a multi-series table); either way
+ * {@link buildChart} turns it into the {@link ChartSpec} that
+ * {@link renderChartSvg} draws, and {@link worthCharting} decides whether
+ * the picture says more than the table already does.
+ *
+ * The heuristics were fitted on ~7k tables from real assistant answers: the
+ * label is the first text column (index columns like `#`/`Rank` never are),
+ * table order is kept (most tables are deliberately unsorted), total rows stay
+ * out of the scale, and units never share an axis.
+ */
+import { type Dimension, type TableAnalysis } from "./table-data.js";
+/**
+ * Chart kinds, by the table shapes they fit:
+ * - `bar`: one measure across categories.
+ * - `paired`: two same-unit measures per category (before/after, A vs B), or `a → b` cells.
+ * - `grouped`: three or four same-unit measures per category.
+ * - `line`: measures over an ordered axis (dates, runs, sizes).
+ * - `heatmap`: a matrix of same-unit values.
+ * - `multiples`: measures in different units, each scaled on its own; transposed when each row is its own metric.
+ * - `share`: parts of a whole (percentages summing to 100).
+ * - `diverging`: signed changes around zero.
+ * - `scatter`: two continuous measures per item.
+ */
+export type ChartKind = "bar" | "paired" | "grouped" | "line" | "heatmap" | "multiples" | "share" | "diverging" | "scatter";
+/** What to draw from a table: the kind, the column naming each category, and the columns plotted. */
+export interface ChartPlan {
+    readonly kind: ChartKind;
+    /** Column naming each category (or holding the x values of a line); rows are numbered without one. */
+    readonly label: number | undefined;
+    /** Plotted columns, in order. */
+    readonly series: readonly number[];
+    /** Each data row is its own series (a metric with its own unit) and the plotted columns are the categories. */
+    readonly transpose: boolean;
+}
+/** One plotted value. */
+export interface ChartPoint {
+    /** Value in base units (seconds, bytes, …). */
+    readonly value: number;
+    /** The number as the table wrote it (`~$250`, `12.5 ms`), shown as the value label. */
+    readonly text: string;
+    /** The table bolded the cell. */
+    readonly emphasis: boolean;
+    /** Upper end of a range cell (`24–72 h`). */
+    readonly upper?: number;
+}
+export interface ChartSeries {
+    readonly name: string;
+    readonly dim: Dimension;
+    /** Currency symbol or rate unit the axis prints; empty for other dimensions. */
+    readonly unit: string;
+    /** One per category; `null` where the cell holds no number of this series' dimension. */
+    readonly points: readonly (ChartPoint | null)[];
+    /** Status words standing in for a value (`TIMEOUT`, `OOM`), one per category. */
+    readonly notes: readonly (string | undefined)[];
+}
+/** The data a chart draws, independent of how it is drawn. */
+export interface ChartSpec {
+    readonly kind: ChartKind;
+    readonly categories: readonly string[];
+    readonly series: readonly ChartSeries[];
+    /** Numeric x positions of a line or the x measure of a scatter, one per category. */
+    readonly x?: {
+        readonly name: string;
+        readonly dim: Dimension;
+        readonly unit: string;
+        readonly values: readonly number[];
+    };
+    /** Total/summary rows, printed under the chart instead of skewing its scale. */
+    readonly caption?: string;
+    /** Name of the category axis (the label column's header). */
+    readonly axis: string;
+}
+/** The local best guess at a chart for `table`, or `undefined` when no chart fits. */
+export declare function planChart(table: TableAnalysis): ChartPlan | undefined;
+/**
+ * The data `plan` draws from `table`, or `undefined` when it leaves fewer than
+ * two categories or no series with two values. The kind is fitted to the
+ * series it ends up with ({@link fitKind}), so any plan — a model's pick
+ * included — draws as something the renderer supports.
+ */
+export declare function buildChart(table: TableAnalysis, plan: ChartPlan): ChartSpec | undefined;
+/**
+ * Whether a chart of `spec` reads faster than its table: at least four
+ * categories, and either nine plotted values or a 3× spread within a series.
+ * On a model-judged sample of assistant tables this gate kept 85% of the
+ * tables a chart clearly helped while rejecting most two- and three-row ones.
+ */
+export declare function worthCharting(spec: ChartSpec): boolean;

package/dist/types/charts/chart-svg.d.ts

@@ -0,0 +1,30 @@
+/**
+ * Draws a {@link ChartSpec} as a standalone SVG document colored only with
+ * figure tokens — `var(--fg)`, `var(--muted)`, `var(--border)`,
+ * `var(--accent)`, `var(--surface)`, `var(--c1)`…`var(--c6)` — on a
+ * transparent background — the token vocabulary of assistant ```svg figures —
+ * so the host resolves them against the live theme (`prepareSvg`) for both
+ * the rasterized terminal image and the native TSP blob.
+ *
+ * Geometry follows the terminal: 16 user units per row and a monospace face,
+ * so 13-unit labels land near the terminal's own glyph size. Marks are flat
+ * and square (no rounding, gradients or shadows); bolded table cells draw at
+ * full strength while their neighbours recede.
+ */
+import type { ChartSpec } from "./chart-plan.js";
+import type { Dimension } from "./table-data.js";
+/** A drawn chart: the SVG document and its size in user units. */
+export interface ChartSvg {
+    readonly svg: string;
+    readonly width: number;
+    readonly height: number;
+}
+/** The SVG document for `spec`. */
+export declare function renderChartSvg(spec: ChartSpec): ChartSvg;
+/** One-line description of the chart, for screen readers and terminals that show the alt text. */
+export declare function chartAlt(spec: ChartSpec): string;
+/**
+ * A value in base units as an axis label: durations and sizes in the unit
+ * their magnitude reads best in, counts compacted (`12k`, `3.4M`).
+ */
+export declare function formatValue(value: number, dim: Dimension, unit: string): string;

package/dist/types/charts/table-data.d.ts

@@ -0,0 +1,107 @@
+/**
+ * Numeric reading of GFM table cells and columns, the input to
+ * {@link planChart}: what number a cell holds (in base units, with its
+ * dimension and annotations) and which role each column plays — a measure to
+ * plot, a category label, an ordered x axis, or a row index to ignore.
+ *
+ * Cells are model-written prose, not CSV: `~1,400`, `**4** ✅`, `17 (21.5%)`,
+ * `24–72 h`, `12 → 15`, `5/8`, `1m 56s`, `TIMEOUT`. The reader keeps the first
+ * number and its unit and classifies the rest, so a column of mostly clean
+ * numbers survives a few annotated or sentinel cells.
+ */
+/** What a number measures; values of one dimension share an axis after unit normalization. */
+export type Dimension = "count" | "percent" | "duration" | "bytes" | "currency" | "ratio" | "fraction" | "rate";
+/**
+ * How cleanly a cell reads as its number: bare (`12 ms`), with a short note
+ * (`17 (21.5%)`, `16 pass`), a range (`24–72 h`), a transition (`12 → 15`), a
+ * fraction (`5/8`), or a number leading prose (`~1,400w, nearly ready`).
+ */
+export type CellFit = "pure" | "note" | "range" | "arrow" | "fraction" | "prose";
+/** A cell that reads as a number. */
+export interface NumberCell {
+    readonly kind: "number";
+    /** Value in base units: seconds, bytes, a plain count, percent points. */
+    readonly value: number;
+    readonly dim: Dimension;
+    /** Unit or currency symbol as written (`ms`, `KiB`, `$`, `tok/s`); empty for bare numbers. */
+    readonly unit: string;
+    readonly fit: CellFit;
+    /** Written as an estimate or bound (`~`, `≈`, `<`, `≥`). */
+    readonly approx: boolean;
+    /** Written with an explicit sign (`+12%`, `-3`). */
+    readonly signed: boolean;
+    /** The cell was bolded: models bold the value they want noticed. */
+    readonly emphasis: boolean;
+    /** The cell text without Markdown decoration. */
+    readonly text: string;
+    /** The number as written, with approximation, sign, currency and unit (`~$250`, `12.5 ms`, `24–72 h`). */
+    readonly figure: string;
+    /** `a → b`: `b`, in the same base units. */
+    readonly to?: number;
+    /** `a → b`: `b` as written. */
+    readonly toFigure?: string;
+    /** `a–b`: `b`, in the same base units. */
+    readonly upper?: number;
+    /** `a/b`: `b`. */
+    readonly denominator?: number;
+}
+/** A cell that is not a quantity. */
+export interface OtherCell {
+    readonly kind: "missing" | "date" | "time" | "version" | "id" | "text";
+    readonly text: string;
+    readonly emphasis: boolean;
+}
+export type Cell = NumberCell | OtherCell;
+/**
+ * What a column contributes to a chart: `measure` values to plot, `label`
+ * category names, `temporal` dates or times, `sequence` an ordered step
+ * (`Run`, `Day`, `Workers`), `index` a row number or identifier never plotted.
+ */
+export type ColumnRole = "measure" | "label" | "temporal" | "sequence" | "index";
+export interface TableColumn {
+    readonly index: number;
+    /** Header text without Markdown decoration. */
+    readonly header: string;
+    readonly role: ColumnRole;
+    readonly cells: readonly Cell[];
+    /** Dominant dimension of the numeric cells. */
+    readonly dim: Dimension | undefined;
+    /** Representative unit of the dominant dimension (`$`, `tok/s`); empty when bare. */
+    readonly unit: string;
+    /** Numeric cells disagree on dimension (a metric-per-row table). */
+    readonly mixed: boolean;
+    /** Every numeric data cell holds the same value: an echoed setting, not a measure. */
+    readonly constant: boolean;
+    /** Share of numeric cells written with an explicit sign. */
+    readonly signedShare: number;
+    /** Share of numeric cells written as `a → b`. */
+    readonly arrowShare: number;
+}
+/** A table read for charting. */
+export interface TableAnalysis {
+    readonly columns: readonly TableColumn[];
+    /** Category labels: the first text or temporal column, else a sequence or index column. */
+    readonly label: TableColumn | undefined;
+    /** Plottable measure columns, constant ones excluded. */
+    readonly measures: readonly TableColumn[];
+    /** Data rows, in table order, without total/summary rows. */
+    readonly rows: readonly number[];
+    /** Total/summary rows (`Total`, `Average`, …), kept out of the scale. */
+    readonly totals: readonly number[];
+}
+/**
+ * Strip inline Markdown from a cell: links keep their text; bold, italics,
+ * strikethrough, code spans and `<br>` keep their content.
+ */
+export declare function plainCell(markdown: string): {
+    text: string;
+    emphasis: boolean;
+};
+/** Parse the first number of a (Markdown) cell, or classify why it is not one. */
+export declare function parseCell(markdown: string): Cell;
+/** Read a table's columns and rows for charting. Cells are the raw Markdown of each cell. */
+export declare function analyzeTable(header: readonly string[], rows: readonly (readonly string[])[]): TableAnalysis;
+/** Strictly increasing or strictly decreasing. */
+export declare function isMonotonic(values: readonly number[]): boolean;
+/** Whether `cell` reads as a number. */
+export declare function isNumber(cell: Cell | undefined): cell is NumberCell;

package/dist/types/chat/assistant-message.d.ts

@@ -86,6 +86,8 @@ export declare class AssistantMessageComponent extends Container {
      */
     setExpanded(expanded: boolean): void;
     isTranscriptBlockFinalized(): boolean;
+    /** Whether a figure still waits for the raster of its final source; the transcript holds retirement meanwhile. */
+    isTranscriptBlockPending(): boolean;
     render(width: number): readonly string[];
     /**
      * A `col` (role `omp.assistant`) of `md` nodes keyed by content index, so
@@ -123,6 +125,8 @@ export declare class AssistantMessageComponent extends Container {
     messagePersistenceKey(): string | undefined;
     /** Toggle rendering for assistant-native and tool-result images. */
     setImagesVisible(visible: boolean): void;
+    /** Toggle charts under numeric tables (the main session's transcript only, never a subagent's). */
+    setTableChartsVisible(visible: boolean): void;
     /** Toggle only images produced by tool results; assistant-native images remain governed by setImagesVisible. */
     setToolResultImagesVisible(visible: boolean): void;
     setToolResultImages(toolCallId: string, images: ImageContent[]): void;

package/dist/types/chat/chat-transcript-builder.d.ts

@@ -28,6 +28,8 @@ export interface ChatTranscriptBuilderDeps {
     expandThinkingBlocks?: () => boolean;
     /** Session-scoped resolved destinations for model-authored Markdown links. */
     linkTargets?: ReadonlyMap<string, string>;
+    /** Draw charts under numeric tables; false for transcripts that are not the main session's. Default: true. */
+    tableCharts?: boolean;
     requestRender: () => void;
 }
 export declare class ChatTranscriptBuilder {

package/dist/types/chat/figure-markdown.d.ts

@@ -0,0 +1,42 @@
+import type { ImageBudget } from "../components/image.js";
+import type { Markdown } from "../components/markdown.js";
+import { Container } from "../tui.js";
+export interface FigureMarkdownOptions {
+    /** Markdown for one prose run (and a failed figure's code fallback); FigureMarkdown drives its transience. */
+    markdown: (text: string) => Markdown;
+    /** Draw charts under numeric tables; off for transcripts that are not the main session's. */
+    charts: boolean;
+    /** Shared inline-image budget for the figures. */
+    budget?: ImageBudget;
+    /** A figure's rows changed outside a text update (raster landed, fell back to code). */
+    onChange: () => void;
+}
+/**
+ * Assistant Markdown whose top-level ```svg fences are lifted out of the prose
+ * and drawn as images ({@link SvgFigure}), and whose numeric tables get a chart
+ * drawn under them ({@link TableChartFigure}), with ordinary {@link Markdown}
+ * for the prose between them. Stands in for Markdown on an assistant text
+ * block that holds an svg fence or a chartable table: {@link setText} streams
+ * in place, reusing every part whose kind is unchanged, and
+ * {@link transientRenderCache} marks the block's tail as still streaming — the
+ * last prose run renders transient, the last figure throttles its rasters
+ * until its fence closes, and a table at the tail waits for its last row.
+ */
+export declare class FigureMarkdown extends Container {
+    #private;
+    constructor(text: string, options: FigureMarkdownOptions);
+    /** Replace the source; returns whether it changed. */
+    setText(text: string): boolean;
+    get transientRenderCache(): boolean;
+    set transientRenderCache(value: boolean);
+    /**
+     * The trimmed prose ahead of the first figure, or "" when the block opens
+     * with one. These are the only rows plain Markdown reproduces byte for
+     * byte, so they are all a transcript may publish ahead of the figure.
+     */
+    get leadingProse(): string;
+    /** Whether a figure's final source still waits for its raster, or a chart for its pick or raster. */
+    get pending(): boolean;
+    /** Rebuild the prose runs through the Markdown factory after its theme changed; figures keep their rasters. */
+    restyle(): void;
+}

package/dist/types/chat/svg-figure.d.ts

@@ -0,0 +1,33 @@
+import { type ImageBudget } from "../components/image.js";
+import type { Markdown } from "../components/markdown.js";
+import type { Component } from "../tui.js";
+/** The active theme's color per figure token, for resolving a figure with `prepareSvg`. */
+export declare function svgFigurePalette(): Record<string, string>;
+/** Turn lifting ```svg fences into images on or off (the host's `tui.renderSvg`); the host rebuilds the transcript after. */
+export declare function setSvgFigureRendering(enabled: boolean): void;
+/** Whether assistant ```svg fences render as images where the terminal can show them. */
+export declare function svgFigureRendering(): boolean;
+export interface SvgFigureOptions {
+    /**
+     * Markdown for the fenced-code fallback shown when the final source does not
+     * render. Without it the figure decorates content shown elsewhere (a chart
+     * under its table): it stays blank until drawn, and when it cannot be.
+     */
+    markdown?: (text: string) => Markdown;
+    /** Shared inline-image budget; superseded rasters are released from it. */
+    budget?: ImageBudget;
+    /** The figure's rows changed outside a text update: a raster landed or rendering fell back to code. */
+    onChange: () => void;
+}
+export declare class SvgFigure implements Component {
+    #private;
+    constructor(options: SvgFigureOptions);
+    /** Feed the fence body; `final` once the fence closed or the message stopped streaming. */
+    update(source: string, final: boolean): void;
+    /** Whether the final source still waits for its raster (or for failing to render). */
+    get pending(): boolean;
+    render(width: number): readonly string[];
+    invalidate(): void;
+    dispose(): void;
+    debugState(): Record<string, unknown>;
+}

package/dist/types/chat/svg-source.d.ts

@@ -0,0 +1,49 @@
+/**
+ * Source-level handling of ```svg fences in assistant Markdown: splitting
+ * prose around them ({@link splitSvgFences}), turning a fence that is still
+ * streaming into a document an SVG parser accepts ({@link closePartialSvg}),
+ * and resolving the theme tokens figures color themselves with
+ * ({@link prepareSvg}). `FigureMarkdown` lifts the fences out as `SvgFigure`
+ * images.
+ */
+/** One run of an assistant text block: prose, or the body of a ```svg fence. */
+export type FigureSegment = {
+    readonly kind: "markdown";
+    readonly text: string;
+}
+/** `closed` once the fence's closing line arrived. */
+ | {
+    readonly kind: "svg";
+    readonly source: string;
+    readonly closed: boolean;
+};
+/** Whether `markdown` holds a ```svg fence {@link splitSvgFences} would lift. */
+export declare function hasSvgFence(markdown: string): boolean;
+/**
+ * Split `markdown` into prose and ```svg fence bodies, in order. Only
+ * top-level fences lift; an svg fence nested in another fence, a list's
+ * indented block or a blockquote stays prose. Blank prose runs are dropped.
+ * An svg fence still open at the end is the last segment, `closed: false`.
+ */
+export declare function splitSvgFences(markdown: string): FigureSegment[];
+/**
+ * Turn a possibly truncated SVG source into a well-formed document: cut the
+ * trailing construct still being written (a tag without its `>`, an
+ * unterminated comment, CDATA section, processing instruction or declaration,
+ * a dangling `&entity`) and close every element left open, innermost first.
+ * A complete document passes through unchanged. Returns null until the root
+ * `<svg …>` start tag is complete — before that there is nothing to draw.
+ */
+export declare function closePartialSvg(source: string): string | null;
+/**
+ * Make a figure's source what an SVG rasterizer draws as written, in the
+ * reader's theme. Rasterizers resolve neither CSS custom properties nor an
+ * inherited text color, and reject a root without the SVG namespace, so:
+ * - `var(--name)` / `var(--name, fallback)` become `palette[name]` (an
+ *   unknown name takes its fallback, else `palette.fg`);
+ * - a root `<svg>` lacking them gets `color` = `palette.fg` (so
+ *   `currentColor` follows the theme), a sans-serif `font-family` (instead
+ *   of the rasterizer's Times), `xmlns`, and `xmlns:xlink` when the source
+ *   uses `xlink:` attributes.
+ */
+export declare function prepareSvg(svg: string, palette: Readonly<Record<string, string>>): string;

package/dist/types/chat/table-chart.d.ts

@@ -0,0 +1,88 @@
+import type { Tokens } from "@oh-my-pi/pi-utils/marked";
+import { type ChartPlan } from "../charts/chart-plan.js";
+import { type TableAnalysis } from "../charts/table-data.js";
+import type { ImageBudget } from "../components/image.js";
+import type { NativeNode } from "../native/node.js";
+import type { Component } from "../tui.js";
+/**
+ * `smart`: a model picks the kind and columns of multi-series tables;
+ * `always`: the local best guess charts every table it reads as numeric;
+ * `off`: tables stay tables.
+ */
+export type TableChartMode = "smart" | "always" | "off";
+/** A multi-series table the host's planner picks a chart for. */
+export interface TableChartRequest {
+    /** The table's Markdown source. */
+    readonly markdown: string;
+    readonly table: TableAnalysis;
+    /** The local best guess; the planner may keep it. */
+    readonly guess: ChartPlan;
+}
+/**
+ * Picks the chart for a multi-series table under `smart`: a plan, or `null`
+ * for no chart. A rejection falls back to the local guess.
+ */
+export type TableChartPlanner = (request: TableChartRequest) => Promise<ChartPlan | null>;
+/** A drawn chart, ready to resolve against the theme. */
+export interface TableChart {
+    /** SVG colored with figure tokens (`var(--accent)`, …). */
+    readonly svg: string;
+    readonly alt: string;
+    /** Size in SVG user units. */
+    readonly width: number;
+    readonly height: number;
+}
+/** The chart under a table: drawn, none, or a smart pick on its way (the promise settles once the cache holds it). */
+export type ChartLookup = TableChart | null | Promise<void>;
+/** One run of a Markdown block: prose (ending at a charted table), or the chart drawn after that table. */
+export type ChartSegment = {
+    readonly kind: "markdown";
+    readonly text: string;
+} | {
+    readonly kind: "chart";
+    readonly table: Tokens.Table;
+};
+/** Set how tables become charts (the host's `tui.autoGraph`) and its `smart` planner; the host rebuilds the transcript after. */
+export declare function setTableCharts(mode: TableChartMode, planner?: TableChartPlanner): void;
+/** How assistant tables currently become charts. */
+export declare function tableChartMode(): TableChartMode;
+/** Whether `markdown` may hold a table {@link splitTableCharts} would chart. */
+export declare function hasChartTable(markdown: string): boolean;
+/**
+ * Split `markdown` after each top-level table that has (or may get) a chart.
+ * A table still streaming at the block's tail is left whole: rows may follow.
+ */
+export declare function splitTableCharts(markdown: string, streaming: boolean): ChartSegment[];
+/**
+ * The chart for `table` under the current mode, read once per table source.
+ * Under `smart` the first lookup of a multi-series table asks the planner.
+ */
+export declare function lookupTableChart(table: Tokens.Table): ChartLookup;
+/**
+ * A native `image` node drawing `chart` from its SVG — no raster — resolved
+ * against the active theme; rebuilt when the theme changes.
+ */
+export declare function describeTableChart(chart: TableChart, key: string): NativeNode;
+export interface TableChartFigureOptions {
+    /** Shared inline-image budget. */
+    budget?: ImageBudget;
+    /** The chart's rows changed outside a text update: its pick or raster landed. */
+    onChange: () => void;
+}
+/**
+ * The chart under one table, as a terminal image a blank row below it. Looks
+ * the chart up on first render — a block rebuilt mid-stream never asks for a
+ * pick it drops — and renders nothing until it is drawn, or when the table
+ * gets no chart.
+ */
+export declare class TableChartFigure implements Component {
+    #private;
+    constructor(options: TableChartFigureOptions);
+    /** Point the figure at `table`. */
+    update(table: Tokens.Table): void;
+    /** Whether the chart is still being looked up, picked or drawn. */
+    get pending(): boolean;
+    render(width: number): readonly string[];
+    invalidate(): void;
+    dispose(): void;
+}

package/dist/types/components/editor.d.ts

@@ -285,7 +285,7 @@ export declare class Editor implements Component, Focusable {
      *  Mirrors the transient state the key dispatch tears down before this action so the two
      *  cannot diverge: a pending character jump is cancelled by any other key, and an open
      *  spelling-assist popup is dismissed by anything that is not one of its accept keys (its
-     *  debounced refresh skips assist mode, so a surviving list would hang around forever).
+     *  refresh skips assist mode, so a surviving list would hang around forever).
      *  While Vim owns the buffer (Normal or Visual) the operation is Vim's `x` — deleting the
      *  selection and returning to Normal in Visual mode, the grapheme under the cursor
      *  otherwise. Only Insert mode and Vim-off editors delete straight through. */

package/dist/types/components/image.d.ts

@@ -29,6 +29,8 @@ export interface ImageOptions {
  * synchronously instead of committing its reserved blank rows.
  */
 export declare function renderForScrollback<T>(render: () => T): T;
+/** Widest an {@link Image} rendered at `width` columns draws; callers sizing a raster for it (`SvgFigure`) match it. */
+export declare function imageMaxColumns(width: number): number;
 /** Default count of inline images kept as live graphics before older ones fall back to text. */
 export declare const DEFAULT_MAX_INLINE_IMAGES = 8;
 /**
@@ -73,6 +75,13 @@ export declare class ImageBudget {
      * gets a fresh id every call.
      */
     acquireId(key?: string): number;
+    /**
+     * Retire the graphic held under `key` as soon as no frame shows it, instead
+     * of when the residency sweep reaches it. For an owner that replaced the
+     * image for good — a streaming SVG figure's earlier raster — so superseded
+     * revisions never push older images (scrollback included) out of the store.
+     */
+    release(key: string): void;
     /**
      * Start an alternate-buffer lifecycle. Call once per `?1049h`, before the
      * first pass of the fullscreen overlay or resize borrow that owns the buffer.

package/dist/types/components/markdown.d.ts

@@ -1,3 +1,4 @@
+import { type TokensList } from "@oh-my-pi/pi-utils/marked";
 import type { DescribeContext, NativeNode } from "../native/node.js";
 import type { SymbolTheme } from "../symbols.js";
 import type { Component } from "../tui.js";
@@ -5,6 +6,14 @@ import type { Component } from "../tui.js";
 export declare function fastLineStartHazard(grownLine: string): boolean;
 /** @internal exported for tests — the windowed lexer's first-probe window size. */
 export declare const LEX_WINDOW_BYTES: number;
+/**
+ * Lex a whole document with the renderer's rules (math, custom rules,
+ * strikethrough), windowing anything large enough for the quadratic scan to
+ * bite. `links` holds every reference definition, at any nesting depth. Callers
+ * that split a document along its blocks (table charts) lex through this so
+ * they see the blocks Markdown renders.
+ */
+export declare function lexDocument(text: string): TokensList;
 /** A hyperlink as the renderer sees it: inline `[text](href)`, `<autolink>`, bare GFM URL, or reference link. */
 export interface MarkdownLink {
     /** Flattened visible label with whitespace collapsed to one row; falls back to `href` when empty. */