@linxiraos/pi-tui 1.1.26 → 1.2.0

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

@@ -1,10 +1,11 @@
+import type { AnimationFrame, TranscriptPresentationTarget } from "../chrome/transcript-container.js";
 import { type Component, Container } from "../tui.js";
 import type { ImageContent } from "@linxiraos/pi-ai";
 import type { ReactionTarget } from "./reaction.js";
-import { type NativeNode, type NativeUiEvent } from "../native/node.js";
+import { type DescribeContext, type NativeNode, type NativeUiEvent } from "../native/node.js";
 /** How a user bubble styles its prose and chips (see {@link userBubbleColor}). */
 export interface UserBubbleOptions {
-    /** Materialized `file://` targets per attached image, indexed by chip number. */
+    /** Filesystem paths for attached image chips, indexed by chip number. */
     imageLinks?: readonly (string | undefined)[];
     /** The message's attached images in chip order (`#1` first); a native bubble shows them. */
     images?: readonly ImageContent[];
@@ -30,9 +31,10 @@ export declare function userBubbleColor(options?: UserBubbleOptions, tokenRegex?
  * (see {@link ReactionTarget}) drawn right-aligned in the bubble's top padding row;
  * a live-steered message carries a `*` marker left-aligned in the same row.
  */
-export declare class UserMessageComponent extends Container implements ReactionTarget {
+export declare class UserMessageComponent extends Container implements ReactionTarget, TranscriptPresentationTarget {
     #private;
     constructor(text: string, options?: UserBubbleOptions);
+    releaseRenderCaches(): void;
     setReaction(emoji: string): void;
     /**
      * A head-less user-toned frame with the prompt as markdown under its
@@ -42,9 +44,19 @@ export declare class UserMessageComponent extends Container implements ReactionT
      * agent's reaction are chips at the bottom-right, so a reaction landing
      * later updates the frame in place, even deep in scrollback.
      */
-    describe(): NativeNode;
+    describe(cx?: DescribeContext): NativeNode;
     /** Hover toolbar clicks: zeta's own copy and rewind commands. */
     handleNativeEvent(event: NativeUiEvent): void;
+    /** Apply the transcript allocator's current viewport reservation. */
+    setTranscriptAllocation(rows: number, _frame?: AnimationFrame): void;
+    isTranscriptBlockFinalized(): boolean;
+    /**
+     * Single-row emergency representation for the overflow transcript layout:
+     * renders the first content line instead of the blank top padding row, and
+     * omits OSC 133 shell integration markers so moving live blocks across the
+     * viewport does not leave stale prompt marks on lines it no longer occupies.
+     */
+    renderTranscriptBlockEmergencyRow(width: number): string | undefined;
     render(width: number): readonly string[];
 }
 /**
@@ -75,6 +87,7 @@ export declare class CollapsedSyntheticMessageComponent implements Component {
     handleNativeEvent(event: NativeUiEvent): void;
     setIgnoreTight(ignore: boolean): this;
     invalidate(): void;
+    releaseRenderCaches(): void;
     dispose(): void;
     render(width: number): readonly string[];
 }

package/dist/types/chrome/shared.d.ts

@@ -1,5 +1,14 @@
 import type { TabBarTheme } from "../components/tab-bar.js";
 /** Compact single-line display text for statuses; unlike titles, collapse padding and trim. */
 export declare function sanitizeStatusText(text: string): string;
+/**
+ * Like {@link sanitizeStatusText}, but keeps 7-bit SGR so extensions can colour
+ * `ctx.ui.setStatus` text. Every other escape (OSC links/titles, DCS/PM/APC,
+ * 7- and 8-bit CSI), C0/C1, lone surrogates, newlines and tabs are sanitized at
+ * least as strictly as in `sanitizeStatusText`; space runs collapse and edges
+ * trim (`String#trim` whitespace) by visible text, regardless of SGR placement.
+ * A styled result always ends with `\x1b[0m`.
+ */
+export declare function sanitizeHookStatusText(input: string): string;
 /** Shared tab bar theme used by fullscreen overlays (settings, agent hub). */
 export declare function getTabBarTheme(): TabBarTheme;

package/dist/types/chrome/status-notice.d.ts

@@ -1,14 +1,26 @@
 import type { NativeNode } from "../native/node.js";
 import { Container } from "../tui.js";
+/** How a {@link StatusNotice} shows. */
+export interface StatusNoticeOptions {
+    /** Styles the ANSI line; resolved at render so a theme change re-shapes it. */
+    styleFn?: (text: string) => string;
+    /**
+     * Whether a native terminal toasts it (default). False keeps the notice to
+     * the ANSI transcript: background chatter such as MCP connection progress,
+     * which would otherwise re-toast on every server that connects or fails.
+     */
+    toast?: boolean;
+}
 /**
  * A transient status notice (`showStatus`: "Thinking blocks: hidden", "Copied
  * to clipboard"). The ANSI render appends a blank row and the dim line to the
  * transcript; a native terminal shows it as a toast instead, so notices never
- * pile up in the history. Updating the text re-shows the toast.
+ * pile up in the history. Updating the text re-shows the toast; a notice
+ * with `toast: false` describes nothing natively.
  */
 export declare class StatusNotice extends Container {
     #private;
-    constructor(message: string, styleFn?: (text: string) => string);
-    setMessage(message: string, styleFn?: (text: string) => string): void;
+    constructor(message: string, options?: StatusNoticeOptions);
+    setMessage(message: string, options?: StatusNoticeOptions): void;
     describe(): NativeNode;
 }

package/dist/types/chrome/transcript-container.d.ts

@@ -63,6 +63,12 @@ export interface TranscriptViewportSpan {
 export declare class TranscriptContainer extends Container {
     #private;
     addChild(component: Component): void;
+    /**
+     * `#entries` mirrors `children`; move both together or the next `#syncEntries`
+     * pays a full O(n) rebuild.
+     */
+    insertChildAt(component: Component, index: number): void;
+    /** Removes `component` if {@link canRemoveBlock} allows it; otherwise does nothing. */
     removeChild(component: Component): void;
     clear(): void;
     setToolActivityVisible(visible: boolean): void;

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

@@ -30,6 +30,7 @@ export declare class Box implements Component {
     setBgFn(bgFn?: (text: string) => string): void;
     setBorder(border?: BoxBorder): void;
     invalidate(): void;
+    releaseRenderCaches(): void;
     /**
      * A `card` when the box has a border or background: the background token
      * picks tone/role (user message, tool state, selection), a border colour

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

@@ -36,6 +36,7 @@ export declare class Disclosure implements Component {
     setExpanded(expanded: boolean): void;
     setIgnoreTight(ignore: boolean): this;
     invalidate(): void;
+    releaseRenderCaches(): void;
     dispose(): void;
     debugState(): Record<string, unknown>;
     get debugChildren(): readonly Component[];

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

@@ -1,5 +1,5 @@
 import { type AutocompleteProvider } from "../autocomplete.js";
-import type { TspEditorDecoration, TspTone } from "@linxiraos/pi-wire";
+import type { TspEditorDecoration, TspText, TspTone } from "@linxiraos/pi-wire";
 import { type DescribeContext, type NativeChild, type NativeNode, type NativeTextEdit, type NativeUiEvent } from "../native/node.js";
 import type { SymbolTheme } from "../symbols.js";
 import { type Component, type Focusable } from "../tui.js";
@@ -106,8 +106,11 @@ export declare class Editor implements Component, Focusable {
      * dialog's text field; only the prompt composer claims `zeta.editor`).
      */
     describeLayout: ((input: NativeNode, cx: DescribeContext) => NativeEditorLayout) | undefined;
-    /** TSP placeholder for the empty buffer; natively it replaces the rotating ANSI {@link placeholder} hints. */
-    describePlaceholder: (() => string) | undefined;
+    /**
+     * TSP placeholder for the empty buffer; natively it replaces the rotating ANSI {@link placeholder} hints.
+     * Return a stable value (the same spans array) while it is unchanged: the editor node is reused by identity.
+     */
+    describePlaceholder: (() => TspText) | undefined;
     /** Called with the selected text when Visual mode yanks, so hosts can reach the system
      *  clipboard — `packages/tui` deliberately has no clipboard dependency of its own. */
     onYank?: (text: string) => void;
@@ -138,11 +141,20 @@ export declare class Editor implements Component, Focusable {
     onLargePaste?: (text: string, lineCount: number, options: PasteOptions) => boolean;
     onAutocompleteCancel?: () => void;
     disableSubmit: boolean;
+    /** Base editors accept native edits, not atomic sends. Implementations that
+     *  handle `send` override this readiness check for their submission path. */
+    protected get nativeSendable(): boolean;
     /** Placeholder painted right-aligned on the cursor row while the editor is empty and no
      *  autocomplete is open; hidden when it can't keep {@link PLACEHOLDER_MIN_GAP} cells from the
      *  cursor. The host styles it (ANSI allowed). Re-evaluated on every render, so hosts can derive
      *  it from live state. */
     placeholder?: () => string | undefined;
+    /** Whole-message prediction for the next prompt, painted as ghost text after the cursor while
+     *  the single-line buffer is a strict prefix of it, the cursor sits at its end, and no
+     *  autocomplete is open. A shown prediction replaces the {@link placeholder}; Tab or Right inserts
+     *  the rest without submitting. Must be a single line. Re-evaluated on every render, so hosts can
+     *  derive it from live state. */
+    prediction?: () => string | undefined;
     constructor(theme: EditorTheme);
     /** Return bounded editor content, cursor, and transient child state for debug inspection. */
     debugState(): Record<string, unknown>;
@@ -247,6 +259,8 @@ export declare class Editor implements Component, Focusable {
     get atoms(): ReadonlyMap<string, string>;
     /** Monotonic buffer-content revision for render caches. Cursor-only movement does not advance it. */
     get textRevision(): number;
+    /** Monotonic atom-table revision for render caches: advances whenever {@link atoms} is mutated or replaced. */
+    get atomsRevision(): number;
     /** Whether the buffer text equals `value`, without `getText()`'s full join —
      *  O(1) for the hot per-keystroke probes against short single-line values. */
     textEquals(value: string): boolean;
@@ -282,7 +296,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. */
@@ -296,7 +310,7 @@ export declare class Editor implements Component, Focusable {
     submit(): void;
     /** Insert text at the current cursor position */
     insertText(text: string): void;
-    /** Terminal-side selection edits on the `editor` node (see {@link applyHostEdit}). */
+    /** Terminal-side selection edits and undo on the `editor` node (see {@link applyHostEdit}). */
     handleNativeEvent(event: NativeUiEvent): void;
     /**
      * Apply an edit the terminal made over its own selection (TSP `edit`):
@@ -327,6 +341,10 @@ export declare class Editor implements Component, Focusable {
      *  {@link getExpandedText}). Hosts that intercept large pastes through {@link onLargePaste} use
      *  this to re-insert a (possibly transformed) paste without re-triggering the interception hook. */
     insertPaste(content: string): void;
+    /** Whether a character-jump hotkey is waiting for its target character. */
+    get isJumpPending(): boolean;
+    /** Type literal text through the character-editing pipeline without keybinding dispatch. */
+    typeCharacter(text: string): void;
     /**
      * Whether an autocomplete popup is on screen. An `@` list narrowed to no match
      * while its refresh is pending stays open internally but is hidden, so it does

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

@@ -44,6 +44,7 @@ export declare class FormField implements Component, Focusable, MouseRoutable {
     /** Label, description, details, preview, the control, error, summary, hint and footer as one column. */
     describe(_cx: DescribeContext): NativeNode;
     get focused(): boolean;
+    get hasError(): boolean;
     get debugChildren(): readonly Component[];
     set focused(value: boolean);
     setUseTerminalCursor(useTerminalCursor: boolean): void;

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

@@ -16,7 +16,21 @@ export interface ImageOptions {
      * repaint replaces the placement instead of stacking a duplicate.
      */
     imageKey?: string;
+    /**
+     * Schedules a repaint once this image's off-thread SIXEL encode lands.
+     * Defaults to the budget's repaint; a host without a budget must pass one,
+     * or the image's reserved rows stay blank until an unrelated repaint.
+     */
+    requestRender?: () => void;
 }
+/**
+ * Run `render` for rows bound for native scrollback. Those rows are never
+ * repainted, so an image whose off-thread SIXEL encode has not landed encodes
+ * 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;
 /**
@@ -52,6 +66,8 @@ export declare class ImageBudget {
     get cap(): number;
     get enabled(): boolean;
     setRequestRender(requestRender: () => void): void;
+    /** Ask for a repaint, e.g. once an image's off-thread encode settles. */
+    requestRender(): void;
     setCap(cap: number): void;
     /**
      * Stable graphics id for a logical image. A non-empty `key` maps to the same
@@ -59,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.
@@ -126,50 +149,8 @@ export declare class ImageBudget {
      * the image is purged from the terminal store.
      */
     registerPlacementGeometry(imageId: number, widthPx: number, heightPx: number): void;
-    /**
-     * Record this frame's native-scrollback commit target (the frame-row count
-     * that is committed once the frame's writes land). Called once per rendered
-     * frame — including frames that emit no placements — so an epoch whose rows
-     * commit while its line is never rewritten is still flagged before the next
-     * re-emission.
-     */
-    observeCommitWatermark(committedTo: number): void;
-    /**
-     * End the physical-row coordinate epoch after observing its final commit
-     * watermark. Placement ids and latched archive state survive, but attachment
-     * rows do not: the next placement emit records them in the new-width frame.
-     */
-    beginPlacementCoordinateEpoch(): void;
-    /**
-     * Resolve the placement id and geometry for a direct-placement emit whose
-     * topmost attached cell sits at `attachTopFrameRow` — the first frame row
-     * the placement covers, i.e. the block's first *visible* row, not its
-     * origin (-1 when the writer has no frame-space position: alt-screen,
-     * resize, ConPTY-truncated replays). `committedTo` is this frame's commit
-     * target in the same frame-row space (-1 when unknown).
-     *
-     * Invariant: a placement id may be re-used (Kitty replace strips that id's
-     * cells everywhere, scrollback included) only while none of the cells it
-     * attached have entered native scrollback. The epoch — the `p=` id —
-     * advances exactly when the archived flag says otherwise; rewrites with no
-     * commit progression keep replacing the same id in place.
-     */
-    resolvePlacementEmit(imageId: number, attachTopFrameRow: number, committedTo: number): {
-        placementId: number;
-        widthPx: number;
-        heightPx: number;
-    } | null;
-    /**
-     * Restart every placement epoch after a destructive history clear (`CSI 3 J`
-     * full paint). The clear destroys all placement cells — scrollback rows are
-     * gone and the replay rewrites the viewport — so no archive remains to
-     * protect. Reverting to epoch 1 lets the replay recreate every visible
-     * placement after the terminal-wide cleanup.
-     */
-    resetPlacementEpochs(): ReadonlyArray<{
-        imageId: number;
-        lastEpoch: number;
-    }>;
+    /** Source dimensions used by the frame writer to clip a direct placement. */
+    getPlacementGeometry(imageId: number): ImageDimensions | undefined;
     /**
      * Queue a one-time transmit for `imageId` on the surface the in-flight pass
      * paints. No-op if that surface already holds the data, so a repeated call
@@ -204,6 +185,7 @@ export declare class Image implements Component {
     /** Return source metadata without exposing the encoded image buffer. */
     debugState(): Record<string, unknown>;
     invalidate(): void;
+    releaseRenderCaches(): void;
     /**
      * A native `image` backed by a content-addressed blob; the terminal fits
      * it. Cell caps become `ch`/`lines` bounds. The inline-image budget and

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

@@ -28,6 +28,7 @@ export declare class Input implements Component, Focusable {
     setValue(value: string): void;
     setUseTerminalCursor(useTerminalCursor: boolean): void;
     getUseTerminalCursor(): boolean;
+    capturesInput(data: string): boolean;
     /**
      * Apply one key: the editor's text bindings (motion, deletion, kill ring,
      * undo), pastes and printable text. Returns whether the key was the
@@ -39,7 +40,7 @@ export declare class Input implements Component, Focusable {
     /** Apply terminal paste semantics to text from non-bracketed paste transports
      *  (e.g. kitty's OSC 5522 enhanced clipboard read). Mirrors `Editor.pasteText`. */
     pasteText(text: string): void;
-    /** Terminal-side selection edits on the `input` node (see {@link applyHostEdit}). */
+    /** Terminal-side selection edits and undo on the `input` node (see {@link applyHostEdit}). */
     handleNativeEvent(event: NativeUiEvent): void;
     /**
      * Apply an edit the terminal made over its own selection (TSP `edit`):

package/dist/types/components/key-value-list.d.ts

@@ -21,6 +21,7 @@ export declare class KeyValueList implements Component {
     constructor(rows: readonly KeyValueRow[], options: KeyValueListOptions);
     setRows(rows: readonly KeyValueRow[]): boolean;
     invalidate(): void;
+    releaseRenderCaches(): void;
     /** An aligned `kv` grid; label width and value wrapping are the terminal's. */
     describe(_cx: DescribeContext): NativeNode;
     render(width: number): readonly string[];

package/dist/types/components/layout/row.d.ts

@@ -48,6 +48,7 @@ export declare class Row implements Component, MouseRoutable {
     setDecorations(prefix: LayoutDecoration | undefined, gap: LayoutDecoration | undefined, suffix: LayoutDecoration | undefined): void;
     setIgnoreTight(ignore: boolean): this;
     invalidate(): void;
+    releaseRenderCaches(): void;
     dispose(): void;
     /**
      * A flex `row`: each child sits in a slot carrying its width bounds

package/dist/types/components/layout/stack.d.ts

@@ -43,6 +43,7 @@ export declare class Stack implements Component, MouseRoutable {
     setHeight(height: number | undefined): void;
     setIgnoreTight(ignore: boolean): this;
     invalidate(): void;
+    releaseRenderCaches(): void;
     dispose(): void;
     /**
      * A `col` of slots carrying each child's height bounds (fixed → min = max

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

@@ -1,3 +1,4 @@
+import type { KeyId } from "../keys.js";
 import type { DescribeContext, NativeNode, NativeUiEvent } from "../native/node.js";
 import { type ShimmerPalette } from "../theme/shimmer.js";
 import type { TUI } from "../tui.js";
@@ -23,16 +24,14 @@ export interface WorkingRowSpec {
     readonly variant?: WorkingRowVariant;
     /** Shimmer palette of the label (a session-accented intent). */
     readonly palette?: ShimmerPalette;
-    /** Live tok/s, docked before the stop control. */
-    readonly rate?: number;
     /** Key id that interrupts (`escape`); undefined hides the stop control (Esc would not cancel). */
-    readonly interruptKey?: string;
+    readonly interruptKey?: KeyId;
 }
 /**
  * The dock's working row: `starburst` spinner (or a retry countdown ring),
- * the intent shimmering, `·`, the elapsed time, a grow spacer, then the stop
- * control whose click sends `interrupt`. Compaction adds an indeterminate
- * `progress` before the stop control; a retry says "Cancel".
+ * the elapsed time, the `·` divider, the intent shimmering, a grow spacer,
+ * then the stop control whose click sends `interrupt`. Compaction adds an
+ * indeterminate `progress` before the stop control; a retry says "Cancel".
  */
 export declare function describeWorkingRow(spec: WorkingRowSpec, cx: DescribeContext, now?: number): NativeNode;
 type ColorFn = (str: string) => string;

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

@@ -1,11 +1,27 @@
+import { type TokensList } from "@linxiraos/pi-utils/marked";
 import type { DescribeContext, NativeNode } from "../native/node.js";
 import type { SymbolTheme } from "../symbols.js";
 import type { Component } from "../tui.js";
-/** @internal exported for tests — the grown-line-start block-kind gate. */
+/** @internal exported for tests — the grown-line block-kind gate. */
 export declare function fastLineStartHazard(grownLine: string): boolean;
+/**
+ * Lex a whole document with the renderer's rules (math, custom rules,
+ * strikethrough). 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;
+/**
+ * `source` as a fenced code block in `lang`: the fence is one backtick longer
+ * than any backtick run in the source (at least three), so the block always
+ * closes where intended. `open` leaves it unclosed, the source verbatim, for
+ * a body that is still arriving.
+ */
+export declare function fencedCode(lang: string, source: string, options?: {
+    open?: boolean;
+}): string;
 /** A hyperlink as the renderer sees it: inline `[text](href)`, `<autolink>`, bare GFM URL, or reference link. */
 export interface MarkdownLink {
-    /** Visible link text (equals `href` for autolinks and bare URLs). */
+    /** Flattened visible label with whitespace collapsed to one row; falls back to `href` when empty. */
     text: string;
     /** Destination exactly as marked resolved it (references resolved, no normalization). */
     href: string;
@@ -17,6 +33,17 @@ export interface MarkdownLink {
  * Duplicate hrefs are kept; callers decide how to fold them.
  */
 export declare function extractMarkdownLinks(text: string): MarkdownLink[];
+/**
+ * Rewrite the destinations of inline links and link reference definitions in
+ * `text` to `resolve(href)`, leaving everything else byte-for-byte intact.
+ * Hosts that render the Markdown source themselves (a native terminal's `md`
+ * node) resolve relative destinations against their own idea of the working
+ * directory; handing them the session-resolved target keeps links pointing at
+ * what the author meant. Links inside code, images, autolinks and reference
+ * uses (`[x][ref]`, rewritten through their definition) are untouched; a link
+ * whose source cannot be located exactly is left as written.
+ */
+export declare function rewriteMarkdownLinkDestinations(text: string, resolve: (href: string) => string | undefined): string;
 /** Drop all L2 cache entries. Call on theme change to prevent stale styled output. */
 export declare function clearRenderCache(): void;
 /**
@@ -26,6 +53,13 @@ export declare function clearRenderCache(): void;
 export interface DefaultTextStyle {
     /** Foreground color function */
     color?: (text: string) => string;
+    /**
+     * The `color` foreground is prose-level: semantically-themed markdown spans
+     * (headings, links) keep their own `md*` theme colors instead of being
+     * painted over by it, while plain text runs still use `color`. Unset keeps
+     * the historical behavior where `color` paints every run.
+     */
+    proseFg?: boolean;
     /** Background color function */
     bgColor?: (text: string) => string;
     /** Bold text */
@@ -82,7 +116,12 @@ export interface MarkdownTheme {
      * Return null to fall back to fenced code rendering.
      */
     resolveMermaidAscii?: (source: string, maxWidth?: number) => string | null;
-    symbols: SymbolTheme;
+    /**
+     * Glyphs for quote borders, rules, tables and color swatches. Optional so themes
+     * built to the upstream pi-tui `MarkdownTheme` shape (which has no `symbols`)
+     * still render; omitted symbols fall back to the active theme's set.
+     */
+    symbols?: SymbolTheme;
 }
 export declare class Markdown implements Component {
     #private;
@@ -92,6 +131,7 @@ export declare class Markdown implements Component {
     debugState(): Record<string, unknown>;
     setText(text: string): boolean;
     invalidate(): void;
+    releaseRenderCaches(): void;
     /**
      * The unrendered source as an `md` node, `stream` while the streaming
      * (transient) cache is on. Append-only growth yields a fresh node of the
@@ -101,8 +141,10 @@ export declare class Markdown implements Component {
     describe(_cx: DescribeContext): NativeNode;
     /**
      * Width-independent source prefix of the last render ending at a frozen
-     * Markdown block boundary. Only meaningful while streaming (transient
-     * render cache on); grows monotonically under append-only `setText`.
+     * Markdown block boundary that no append can move: it stops in front of a
+     * display-math opener whose block an append could still close. Only
+     * meaningful while streaming (transient render cache on); grows
+     * monotonically under append-only `setText`.
      */
     getLastRenderStableText(): string;
     get transientRenderCache(): boolean;

package/dist/types/components/scroll-view.d.ts

@@ -92,6 +92,7 @@ export declare class ScrollView implements Component {
     /** Apply Arrow, Shift+Arrow, Page, Home, and End navigation keys. */
     handleScrollKey(data: string): boolean;
     invalidate(): void;
+    releaseRenderCaches(): void;
     /** Permanently release a wrapped child's timers, subscriptions, and other resources. */
     dispose(): void;
     /**

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

@@ -15,6 +15,7 @@ export declare class Section implements Component {
     #private;
     constructor(options: SectionOptions);
     invalidate(): void;
+    releaseRenderCaches(): void;
     dispose(): void;
     /** A `section` headed by the styled title; the rule is the terminal's. */
     describe(_cx: DescribeContext): NativeNode;

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

@@ -29,6 +29,7 @@ export declare class Table implements Component {
     constructor(rows: readonly (readonly TableCell[])[], columns: readonly TableColumn[], options?: TableOptions);
     setRows(rows: readonly (readonly TableCell[])[]): boolean;
     invalidate(): void;
+    releaseRenderCaches(): void;
     /**
      * A native `table`. Column priorities carry over unchanged (lower gives
      * way first); truncating columns truncate at the end, the rest keep

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

@@ -26,6 +26,7 @@ export declare class Text implements Component {
      */
     setStyleFn(styleFn?: (text: string) => string): this;
     invalidate(): void;
+    releaseRenderCaches(): void;
     /**
      * Wrapped text; styling re-derived from the styled source so a theme swap
      * re-resolves tokens. A background fill becomes the node's tone.

package/dist/types/components/tree-view.d.ts

@@ -34,6 +34,13 @@ export interface FlattenTreeOptions<T, K extends TreeKey> {
     rootDepth?: number;
     /** Override the display depth inherited by direct children. */
     getChildDepth?: (item: T, row: TreeRow<T, K>, children: readonly T[]) => number;
+    /**
+     * Reuse the parent ancestor list when a child keeps the same display depth
+     * and the current item has no siblings (`siblingCount === 1`). Otherwise
+     * retain the current item as an ancestor so connector gutters remain
+     * accurate, including when the item has multiple children.
+     */
+    compactSameDepthAncestors?: boolean;
     /** Stop projection after this many structural items. Omit for no traversal cap. */
     maxItems?: number;
 }

package/dist/types/components/truncated-text.d.ts

@@ -9,6 +9,7 @@ export declare class TruncatedText implements Component {
     /** Return bounded source text and the last-known truncation state. */
     debugState(): Record<string, unknown>;
     invalidate(): void;
+    releaseRenderCaches(): void;
     /** First line only, clamped to one visual line with an end ellipsis. */
     describe(_cx: DescribeContext): NativeNode;
     render(width: number): readonly string[];

package/dist/types/fuzzy.d.ts

@@ -16,6 +16,20 @@ export interface FuzzyFilterResult<T> {
     score: number;
 }
 export declare function fuzzyMatch(query: string, text: string): FuzzyMatch;
+/**
+ * A query normalized and tokenized once for matching against many texts.
+ *
+ * `fuzzyMatch(query, text)` re-normalizes `query` (and rebuilds its
+ * alphanumeric-swap variants) on every call; filters that test one query
+ * against every row should build one `FuzzyQuery` per keystroke instead.
+ * `query.match(text)` returns exactly what `fuzzyMatch(query, text)` returns.
+ */
+export declare class FuzzyQuery {
+    #private;
+    constructor(query: string);
+    /** Same result as `fuzzyMatch(query, text)`; `text` may be a prepared {@link FuzzyText}. */
+    match(text: string | FuzzyText): FuzzyMatch;
+}
 /**
  * A text prepared once for repeated fuzzy matching.
  *
@@ -30,7 +44,21 @@ export declare class FuzzyText {
     #private;
     constructor(text: string);
     /** Match `query` (space-separated tokens; all must match) against the prepared text. */
-    match(query: string): FuzzyMatch;
+    match(query: string | FuzzyQuery): FuzzyMatch;
+}
+/**
+ * Items prepared once for repeated {@link fuzzyRank}-equivalent ranking.
+ *
+ * `fuzzyRank` resolves each candidate's search index through the bounded module
+ * cache, which holds at most {@link INDEX_CACHE_MAX} entries; larger candidate
+ * lists (the full model catalog) rebuild the overflow on every query. Hold one
+ * corpus per stable candidate list and call {@link rank} per keystroke instead.
+ */
+export declare class FuzzyCorpus<T> {
+    #private;
+    constructor(items: readonly T[], getText: (item: T) => string);
+    /** Same results as `fuzzyRank(items, query, getText)` for the prepared items. */
+    rank(query: string): FuzzyFilterResult<T>[];
 }
 /**
  * Filter and sort items by fuzzy match quality (best matches first).

package/dist/types/key-hint-format.d.ts

@@ -1,6 +1,6 @@
 /**
  * Key-hint formatting, kept free of the native addon: it imports only types
- * plus the theme symbol mirror, so addon-free CLI paths (`omp --version`,
+ * plus the theme symbol mirror, so addon-free CLI paths (`zetacode --version`,
  * help text in cli/command-help.ts) can format keys without loading
  * `@linxiraos/pi-natives` through the keybindings registry.
  */
@@ -23,6 +23,14 @@ export type KeyName = KeyId | ModifierName;
  * is capitalized. Other keys are capitalized (`f5` → `F5`).
  */
 export declare function formatKeyHint(key: KeyName): string;
+/**
+ * Format one key for a native tooltip (a TSP `title`): unicode keycap glyphs
+ * whatever the theme's symbol preset (`shift+tab` → `⇧⇥`), which Tern's
+ * tooltip splits into keycaps, and `esc` as Tern's own keycaps read. The nerd
+ * preset's icons are missing from Tern's UI font, and its spaced chords would
+ * not parse as keys.
+ */
+export declare function formatTooltipKey(key: KeyName): string;
 /** Format alternative keys as a slash-separated hint (`["f5", "alt+r"]` → `F5/⌥R`). */
 export declare function formatKeyHints(keys: KeyName | readonly KeyName[]): string;
 /** Format a double-tap gesture: `←←` with glyphs, `Left Left` with words. */

package/dist/types/keybinding-matchers.d.ts

@@ -1,3 +1,4 @@
+import type { KeyId } from "./app-keybindings.js";
 /**
  * Match the coding-agent interrupt key.
  *
@@ -18,6 +19,8 @@ export declare function matchesSelectDown(data: string): boolean;
 export declare function matchesSelectPageUp(data: string): boolean;
 /** Match the generic selector page-down keybinding. */
 export declare function matchesSelectPageDown(data: string): boolean;
+/** Effective external-editor key: the first bound key, or Ctrl+G when unbound. */
+export declare function appExternalEditorKey(): KeyId;
 /** Match the external-editor keybinding, falling back to Ctrl+G when unbound. */
 export declare function matchesAppExternalEditor(data: string): boolean;
 /**