@linxiraos/pi-tui 1.1.26 → 1.2.0

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

@@ -0,0 +1,59 @@
+/**
+ * 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.
+ *
+ * Styled after Apple's charts and Tern's UI: a UI sans (Geist where Tern
+ * provides it), muted labels, hairline gridlines that recede behind the
+ * marks, bars and cells with rounded corners, smooth lines (over a soft area
+ * fill where the axis starts at zero), dot legends, one hue across small
+ * multiples' columns with gray for context. 13-unit labels land near the terminal's own glyph size
+ * at 16 user units per row; bolded table cells draw at full strength while
+ * their neighbours recede. Grouped categories ({@link ChartSpec.groups}) name
+ * each group once beside its members, the groups parted by a gap; a name too
+ * long for its column wraps to two lines ({@link categoryLabels}). A few
+ * outliers far above the rest break a bar axis instead of flattening it
+ * ({@link outlierTier}); reference rows ({@link ChartSpec.reference}) draw a
+ * dashed rule through their group.
+ *
+ * Every chart opens with a header ({@link drawHeader}): the semibold title a
+ * planner set ({@link ChartSpec.title}, the one fact worth stating; its key
+ * figure in the accent), a muted
+ * note on how the data is encoded, and the series key right-aligned on the
+ * title's line when it fits. Marks size to
+ * the row count ({@link barMetrics}); strong heat cells and share segments
+ * print their figures in a theme-adaptive dark {@link ink}. Reusable
+ * annotation primitives — {@link band}, {@link referenceRule},
+ * {@link callout} — draw the {@link ChartSpec.annotations} a planner lays on.
+ *
+ * Axes tick on round steps in one unit (`0, 2, 4` for counts, `50s, 100s`,
+ * `25 GiB` where the table wrote binary sizes, thousands separated). Meaning
+ * layers on top: each contest's best value carries a quiet `best` tag (an
+ * outline in a heatmap), estimates (`~15`) among measured figures draw as
+ * dashed, faint bars ({@link barRect}), moves of a measure with a polarity read in `success`
+ * or `error` (transitions, factors, signed deltas), and status cells badge
+ * their row's name with a colored dot keyed under the chart.
+ */
+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,
+ * counts compacted under the suffix (`12k`, `3.4M`), that `magnitude` reads
+ * best in — the value's own size by default, an axis' largest tick to keep
+ * its labels in one unit. Sizes read in decimal units (`20 GB`), or binary
+ * ones (`16 GiB`) when `unit` is `iB`.
+ */
+export declare function formatValue(value: number, dim: Dimension, unit: string, magnitude?: number): string;

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

@@ -0,0 +1,175 @@
+/**
+ * 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`. {@link analyzeTable} reads a score (`12/12`, `154/160`, a mean
+     * like `0.6/4`) as the percent of `b` reached, unless its column also holds a
+     * plain fraction; a pair (`85 / 147` under `Edit / read calls`) keeps `a`.
+     */
+    readonly denominator?: number;
+    /**
+     * `a ± e` (`3.67s ± 0.69`, `~404ms ± 60`, `$0.72 (±0.16)`): `e`, in the same base units — the
+     * spread the table states around the value; {@link figure} then writes both (`3.67s ± 0.69`).
+     */
+    readonly error?: number;
+    /**
+     * A slash list of measurements in one unit (`79 / 124 µs`, `1,864 ms /
+     * 2,678 ms`, `**675ms** / 680ms`): every listed value, the first included,
+     * in base units, 2–4 of them. `value` is the first.
+     */
+    readonly values?: readonly 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;
+    /** Numeric cells are mostly scores out of a total (`12/12`), read as percent of it. */
+    readonly scores: boolean;
+    /**
+     * Per row, the status its cell leads with ({@link cellStatus}), when most
+     * of the column's cells lead with one: a pass/fail or progress column.
+     */
+    readonly statuses?: readonly (Status | undefined)[];
+    /** 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;
+    /**
+     * Index of the measure column this one restates, read from the values: a
+     * proportional copy (`pass` 33/38 beside `pass%` 87%, `Samples` beside `% of
+     * Total`, `Leverage vs $200` beside the cost) or a running total of it
+     * (`Offset` summing `Verts`). Such a column is never a measure of its own.
+     */
+    readonly restates?: number;
+}
+/**
+ * Measure columns that add up, read from the values: leaf `parts` summing to
+ * `whole` in every row (`Cached + Uncached input = Input`, `Input + Output =
+ * Total` → parts Cached, Uncached input, Output of Total), or — when not
+ * `exact` — parts falling within a `Total` column, the rest unlisted (`New +
+ * Edited ≤ Prose total`).
+ */
+export interface Composition {
+    /** Column the parts make up; absent when only a judge says the parts form a whole. */
+    readonly whole: number | undefined;
+    /** Leaf part columns, in table order. */
+    readonly parts: readonly number[];
+    /** The parts sum to the whole within the written precision in every row. */
+    readonly exact: boolean;
+}
+/** A table read for charting. */
+export interface TableAnalysis {
+    readonly columns: readonly TableColumn[];
+    /**
+     * Category labels: the first text or temporal column not made only of codes
+     * (`#2233`, `00`), else the first text 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[];
+    /** Measure columns adding up to a whole, when the values show it. */
+    readonly composition?: Composition;
+}
+/**
+ * What a status cell (`ok`, `FAIL`, `pending`, ✅) says about its row: `good`
+ * passed or landed, `bad` failed or broke, `warn` partly or flaky, `pending`
+ * not settled yet.
+ */
+export type Status = "good" | "bad" | "warn" | "pending";
+/**
+ * The status a cell's text leads with (`FAIL`, `✓ via mmdc`, `**pending**`,
+ * `1 ok`), or `undefined` for any other text. A count before the word
+ * (`3 ok`) still reads as the word's status.
+ */
+export declare function cellStatus(text: string): Status | undefined;
+/**
+ * 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;
+/**
+ * Half the last written digit of `cell`, in base units (`6,313k` → 500,
+ * `38.5%` → 0.05): how far its value may sit from the exact quantity it
+ * rounds. A score (`33/38` read as percent) and a whole count written in full
+ * (`46`, `1,980`) are exact.
+ */
+export declare function writtenSlack(cell: NumberCell): number;
+/** 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

@@ -38,7 +38,7 @@ export declare class AssistantMessageComponent extends Container {
      * for lack of a target is re-rendered with its reaction stripped.
      */
     pickReactionTarget(transcript: readonly Component[]): void;
-    constructor(message?: AssistantMessage, hideThinkingBlock?: boolean, onImageUpdate?: () => void, thinkingRenderers?: readonly AssistantThinkingRenderer[], imageBudget?: ImageBudget, proseOnlyThinking?: boolean, linkTargets?: ReadonlyMap<string, string>);
+    constructor(message?: AssistantMessage, hideThinkingBlock?: boolean, onImageUpdate?: () => void, thinkingRenderers?: readonly AssistantThinkingRenderer[], imageBudget?: ImageBudget, proseOnlyThinking?: boolean, linkTargets?: ReadonlyMap<string, string>, expandThinkingBlocks?: boolean);
     /**
      * Show or clear the trailing cache-invalidation divider. Set at `message_end`
      * (live) or during rebuild, once the turn's usage is known and compared
@@ -54,6 +54,7 @@ export declare class AssistantMessageComponent extends Container {
      */
     setServedModelMismatch(info: ServedModelMismatch | undefined): void;
     invalidate(): void;
+    releaseRenderCaches(): void;
     setHideThinkingBlock(hide: boolean): void;
     /**
      * Allow or withhold retiring finished lines into native scrollback while the
@@ -65,6 +66,11 @@ export declare class AssistantMessageComponent extends Container {
      */
     setMidStreamPublication(allowed: boolean): void;
     setProseOnlyThinking(proseOnly: boolean): void;
+    /**
+     * Keep finished thinking sections expanded instead of folding them to "Thought for 12s".
+     * Sections the user folded or unfolded by hand keep that choice.
+     */
+    setExpandThinkingBlocks(expand: boolean): void;
     dispose(): void;
     /**
      * Toggle suppression of the inline `Error: …` line while the same error is
@@ -81,6 +87,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 `zeta.assistant`) of `md` nodes keyed by content index, so
@@ -118,6 +126,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

@@ -25,8 +25,11 @@ export interface ChatTranscriptBuilderDeps {
     cwd: string;
     hideThinkingBlock?: () => boolean;
     proseOnlyThinking?: () => boolean;
+    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/compaction-summary-message.d.ts

@@ -31,6 +31,7 @@ declare class SummaryMessageComponent implements Component {
     handleNativeEvent(event: NativeUiEvent): void;
     setIgnoreTight(ignore: boolean): this;
     invalidate(): void;
+    releaseRenderCaches(): void;
     dispose(): void;
     render(width: number): readonly string[];
 }

package/dist/types/chat/execution-shared.d.ts

@@ -78,7 +78,7 @@ export interface ExecutionToolInput {
     /** Tool name for the head icon (`bash`, `eval`). */
     readonly name: string;
     readonly title: string;
-    /** The command / cell source, shown once in the head. */
+    /** The command / cell source: the run box's input and the head's Copy command. */
     readonly command: string;
     readonly lang: string;
     /** Excluded from context (`!!`/`$$`). */
@@ -96,10 +96,11 @@ export interface ExecutionToolInput {
     readonly artifactError?: OutputArtifactError;
 }
 /**
- * A user `!`/`$` run as the agent's `tool` frame (§6.6): the command in the
- * head with a `you` badge (plus `not sent` when excluded from context), the
- * timer, exit chip and cancelled note; the body is the output as an `ansi`
- * mini terminal following its tail, then one quiet truncation line.
+ * A user `!`/`$` run as the agent's `tool` frame (§6.6): a head with a `you`
+ * badge (plus `not sent` when excluded from context) and the command for Copy
+ * command; the body is one run box — the source, the output as an `ansi` mini
+ * terminal following its tail, and the foot (state, time, truncation) — with
+ * any images below it. Timer, exit chip and cancelled note stay head data.
  */
 export declare function describeExecutionTool(input: ExecutionToolInput): NativeNode;
 /**

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

@@ -64,7 +64,7 @@ export interface SkillPromptDetails {
  *  `ui-helpers.addMessageToChat` (renderers), `AgentHubOverlayComponent
  *  #buildTranscriptLines`, `runPrintMode`, and `AcpAgent#replayAssistantMessage`
  *  (fallback error emission) read it via `isSilentAbort`. */
-export declare const SILENT_ABORT_MARKER = "__omp.silent_abort__";
+export declare const SILENT_ABORT_MARKER = "__zeta.silent_abort__";
 /** Type-guard for silent aborts. Renderers MUST call this helper so structured
  *  `errorId` and legacy persisted marker messages stay in lockstep. */
 export declare function isSilentAbort(message: Pick<AssistantMessage, "errorId" | "errorMessage">): boolean;

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,89 @@
+import type { Tokens } from "@linxiraos/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 refines the local guess where meaning decides (kind,
+ * columns, row names, ordering, polarity, focus, title; see {@link shouldJudge});
+ * `always`: the local best guess charts every table it reads as numeric;
+ * `off`: tables stay tables.
+ */
+export type TableChartMode = "smart" | "always" | "off";
+/** A table the host's planner picks a chart for ({@link shouldJudge}). */
+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/chat/tool-execution.d.ts

@@ -90,6 +90,8 @@ export declare class ToolExecutionComponent extends Container {
      * component-scoped so the TUI reuses every other root subtree (issue #4377).
      */
     tickSpinner(frame: number): void;
+    /** Whether the result's figure still waits for its raster; the transcript holds retirement meanwhile. */
+    isTranscriptBlockPending(): boolean;
     /**
      * Whether this block is ready to retire as immutable history. Partial
      * results, including detached background tasks, remain active and mutable