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

package/CHANGELOG.md

@@ -2,6 +2,51 @@
 
 ## [Unreleased]
 
+## [18.8.0] - 2026-10-07
+
+### Added
+
+- SVG and Mermaid files now render as images or diagrams beneath their file cards, with SVG previews updating while the file streams and Mermaid previews appearing when the file is complete.
+- Native tool cards can open expanded regardless of the transcript’s expansion state; the todo checklist uses this behavior.
+
+### Changed
+
+- TSP composer placeholders now appear as the composer title in italicized curly quotes, with “What are we cooking?” used when no title is provided.
+- TSP image transfers are more efficient across reconnects and multiple surfaces: images are sent once per connection, existing terminal blobs are detected before upload, and images in the Tern blob cache can be reused without crossing the terminal pty.
+- Improved performance and responsiveness across the TUI, including large TSP messages and Markdown documents, streaming output, tool-result cards, debug logs, raw SSE and Git diff views, path and model searches, session and settings lists, plan review, agent transcripts, status updates, assistant links, Kitty images, and large prompt or evaluation content.
+- Large debug logs and plan-review histories now retain bounded history to keep the interface responsive, while preserving the newest log entries.
+
+### Fixed
+
+- Fixed slow Markdown processing for certain LaTeX environments and incomplete delimiters.
+- Fixed excessive slowdown when formatting long semicolon-free JavaScript evaluations.
+- Fixed prompt-editor lag in large drafts containing magic keywords.
+
+## [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
@@ -2947,112 +2992,4 @@ Initial release under @oh-my-pi scope. See previous releases at [badlogic/pi-mon
 
 - **Experimental:** Overlay compositing for `ctx.ui.custom()` with `{ overlay: true }` option ([#558](https://github.com/badlogic/pi-mono/pull/558) by [@nicobailon](https://github.com/nicobailon))
 
-## [0.38.0] - 2026-01-08
-
-### Added
-
-- `EditorComponent` interface for custom editor implementations
-- `StdinBuffer` class to split batched stdin into individual sequences (adapted from [OpenTUI](https://github.com/anomalyco/opentui), MIT license)
-
-### Fixed
-
-- Key presses no longer dropped when batched with other events over SSH ([#538](https://github.com/badlogic/pi-mono/pull/538))
-
-## [0.37.8] - 2026-01-07
-
-### Added
-
-- `Component.wantsKeyRelease` property to opt-in to key release events (default false)
-
-### Fixed
-
-- TUI now filters out key release events by default, preventing double-processing of keys in editors and other components
-
-## [0.37.7] - 2026-01-07
-
-### Fixed
-
-- `matchesKey()` now correctly matches Kitty protocol sequences for unmodified letter keys (needed for key release events)
-
-## [0.37.6] - 2026-01-06
-
-### Added
-
-- Kitty keyboard protocol flag 2 support for key release events. New exports: `isKeyRelease(data)`, `isKeyRepeat(data)`, `KeyEventType` type. Terminals supporting Kitty protocol (Kitty, Ghostty, WezTerm) now send proper key-up events.
-
-## [0.37.0] - 2026-01-05
-
-### Fixed
-
-- Crash when pasting text with trailing whitespace exceeding terminal width through Markdown rendering ([#457](https://github.com/badlogic/pi-mono/pull/457) by [@robinwander](https://github.com/robinwander))
-
-## [0.34.1] - 2026-01-04
-
-### Added
-
-- Symbol key support in keybinding system: `SymbolKey` type with 32 symbol keys, `Key` constants (e.g., `Key.backtick`, `Key.comma`), updated `matchesKey()` and `parseKey()` to handle symbol input ([#450](https://github.com/badlogic/pi-mono/pull/450) by [@kaofelix](https://github.com/kaofelix))
-
-## [0.34.0] - 2026-01-04
-
-### Added
-
-- `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@fa14205f838f](https://github.com/can1357/oh-my-pi/blob/fa14205f838f282fcea048c64fca74026789a492/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/apps/debug/log-viewer.d.ts

@@ -15,6 +15,8 @@ type DebugLogViewerModelOptions = {
     processPid?: number;
     hasOlderLogs?: () => boolean;
     loadOlderLogs?: (limitDays?: number) => Promise<string>;
+    /** Most entries kept; older history beyond it is not loaded. Defaults to {@link MAX_LOG_ENTRIES}. */
+    maxLogEntries?: number;
 };
 type ViewerRow = {
     kind: "warning";
@@ -33,6 +35,8 @@ export declare class DebugLogViewerModel {
     #private;
     constructor(logText: string, options?: DebugLogViewerModelOptions);
     get logCount(): number;
+    /** True once the entry cap is reached, so older history no longer loads. */
+    get historyLimitReached(): boolean;
     get visibleLogCount(): number;
     get rows(): readonly ViewerRow[];
     get cursorRowIndex(): number | undefined;

package/dist/types/apps/debug/raw-sse-buffer.d.ts

@@ -41,6 +41,8 @@ export declare function rawSseRecordLines(record: RawSseDebugRecord): string[];
 /** Bounded, observable capture of raw provider responses and SSE frames. */
 export declare class RawSseDebugBuffer {
     #private;
+    /** Bumped on every change to the captured window (append, eviction, clear); equal revisions mean equal snapshots. */
+    get revision(): number;
     subscribe(listener: () => void): () => void;
     recordResponse(response: ProviderResponseMetadata, model?: Model): void;
     recordEvent(event: RawSseEvent, model?: Model): void;

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/fence-figure.d.ts

@@ -0,0 +1,42 @@
+/**
+ * A tool call's {@link ToolFigure} drawn under its card, the way assistant
+ * Markdown draws that fence: ```svg as an inline image ({@link SvgFigure}),
+ * redrawn as the body streams; ```mermaid as ASCII art once the body is
+ * final. The card already shows the source, so unlike the assistant's fence
+ * it never falls back to code: {@link FenceFigure.draws} turns down fences
+ * this terminal shows as code, and an svg that does not rasterize stays blank.
+ */
+import type { ImageBudget } from "../components/image.js";
+import type { ToolFigure } from "../tools/renderer.js";
+import type { Component } from "../tui.js";
+/** Fence languages a {@link FenceFigure} draws. */
+export type FenceFigureLang = "svg" | "mermaid";
+export interface FenceFigureOptions {
+    /** Shared inline-image budget for an svg's rasters. */
+    budget?: ImageBudget;
+    /** The figure's rows changed outside a render: a raster landed. */
+    onChange: () => void;
+}
+export declare class FenceFigure implements Component {
+    #private;
+    /**
+     * Whether this terminal draws `figure` now: an svg where inline images show
+     * (`showImages` and a graphics protocol), a closed mermaid fence when
+     * diagram rendering is on and the source renders.
+     */
+    static draws(figure: ToolFigure, options: {
+        showImages: boolean;
+    }): figure is ToolFigure & {
+        readonly lang: FenceFigureLang;
+    };
+    readonly lang: FenceFigureLang;
+    constructor(lang: FenceFigureLang, options: FenceFigureOptions);
+    /** Feed the fence as it stands; its `lang` is this figure's. */
+    update(figure: ToolFigure): void;
+    /** Whether a closed svg's raster is still on its way. */
+    get pending(): boolean;
+    /** The drawing; no rows while an svg draws, or when it does not. */
+    render(width: number): readonly string[];
+    invalidate(): void;
+    dispose(): void;
+}

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;