@askalf/dario 3.38.5 → 4.0.0

package/dist/tui/proxy-client.d.ts

@@ -0,0 +1,60 @@
+/**
+ * Proxy HTTP client for the TUI.
+ *
+ * The TUI runs as its own process (`dario` with no args). It talks to
+ * a separately-running `dario proxy` over HTTP on localhost. This
+ * module is the thin client layer: JSON fetch + Server-Sent Events
+ * subscription + a `/health` reachability probe.
+ *
+ * Why not use fetch(): Node 22's global fetch works fine for one-shot
+ * JSON, but SSE streaming through it is awkward (the response.body
+ * is a WHATWG ReadableStream that needs an extra Node-stream adapter
+ * to handle line splitting cleanly across chunks). Using `node:http`
+ * directly keeps the SSE flow simple and matches the streaming hot-
+ * path the proxy itself uses.
+ *
+ * Zero deps as ever.
+ */
+export interface ProxyClientOpts {
+    /** Base URL of the running proxy, e.g. `http://127.0.0.1:3456`. */
+    baseUrl: string;
+    /** Optional API key — sent as `x-api-key` header. */
+    apiKey?: string;
+    /** Timeout for one-shot requests (ms). SSE subscriptions ignore this. */
+    timeoutMs?: number;
+}
+export declare class ProxyClient {
+    private baseUrl;
+    private apiKey?;
+    private timeoutMs;
+    constructor(opts: ProxyClientOpts);
+    /**
+     * GET a JSON endpoint. Rejects on non-2xx, network failure, JSON
+     * parse error, or timeout.
+     */
+    getJson<T = unknown>(path: string): Promise<T>;
+    /**
+     * Reachability probe — GET /health, returns parsed payload on
+     * success or null on any failure. Never throws; callers use the
+     * null as "proxy not running / unreachable".
+     */
+    health(): Promise<HealthResponse | null>;
+    /**
+     * Subscribe to /analytics/stream SSE. Calls `onMessage` for each
+     * data frame (parsed as JSON). Returns a `close()` function that
+     * unsubscribes — the caller MUST call this on unmount or the
+     * underlying socket leaks.
+     *
+     * Auto-reconnect is intentionally NOT included. The Hits tab decides
+     * when to retry (and how often) — pushing that policy into here would
+     * couple the client to UI semantics.
+     */
+    subscribeAnalyticsStream<T = unknown>(onMessage: (msg: T) => void, onError?: (err: Error) => void): () => void;
+    private headers;
+}
+export interface HealthResponse {
+    status: string;
+    oauth: string;
+    expiresIn?: string;
+    requests?: number;
+}

package/dist/tui/proxy-client.js

@@ -0,0 +1,166 @@
+/**
+ * Proxy HTTP client for the TUI.
+ *
+ * The TUI runs as its own process (`dario` with no args). It talks to
+ * a separately-running `dario proxy` over HTTP on localhost. This
+ * module is the thin client layer: JSON fetch + Server-Sent Events
+ * subscription + a `/health` reachability probe.
+ *
+ * Why not use fetch(): Node 22's global fetch works fine for one-shot
+ * JSON, but SSE streaming through it is awkward (the response.body
+ * is a WHATWG ReadableStream that needs an extra Node-stream adapter
+ * to handle line splitting cleanly across chunks). Using `node:http`
+ * directly keeps the SSE flow simple and matches the streaming hot-
+ * path the proxy itself uses.
+ *
+ * Zero deps as ever.
+ */
+import { request as httpRequest } from 'node:http';
+import { URL } from 'node:url';
+export class ProxyClient {
+    baseUrl;
+    apiKey;
+    timeoutMs;
+    constructor(opts) {
+        this.baseUrl = opts.baseUrl.replace(/\/$/, '');
+        this.apiKey = opts.apiKey;
+        this.timeoutMs = opts.timeoutMs ?? 3000;
+    }
+    /**
+     * GET a JSON endpoint. Rejects on non-2xx, network failure, JSON
+     * parse error, or timeout.
+     */
+    async getJson(path) {
+        const url = new URL(this.baseUrl + path);
+        return new Promise((resolve, reject) => {
+            const req = httpRequest({
+                hostname: url.hostname,
+                port: url.port || 80,
+                path: url.pathname + url.search,
+                method: 'GET',
+                headers: this.headers(),
+            }, (res) => {
+                const chunks = [];
+                res.on('data', (c) => chunks.push(c));
+                res.on('end', () => {
+                    const body = Buffer.concat(chunks).toString('utf-8');
+                    if (!res.statusCode || res.statusCode < 200 || res.statusCode >= 300) {
+                        reject(new Error(`HTTP ${res.statusCode}: ${body.slice(0, 200)}`));
+                        return;
+                    }
+                    try {
+                        resolve(JSON.parse(body));
+                    }
+                    catch (e) {
+                        reject(new Error(`JSON parse: ${e.message}`));
+                    }
+                });
+                res.on('error', reject);
+            });
+            req.on('error', reject);
+            req.setTimeout(this.timeoutMs, () => {
+                req.destroy(new Error(`timeout after ${this.timeoutMs}ms`));
+            });
+            req.end();
+        });
+    }
+    /**
+     * Reachability probe — GET /health, returns parsed payload on
+     * success or null on any failure. Never throws; callers use the
+     * null as "proxy not running / unreachable".
+     */
+    async health() {
+        try {
+            return await this.getJson('/health');
+        }
+        catch {
+            return null;
+        }
+    }
+    /**
+     * Subscribe to /analytics/stream SSE. Calls `onMessage` for each
+     * data frame (parsed as JSON). Returns a `close()` function that
+     * unsubscribes — the caller MUST call this on unmount or the
+     * underlying socket leaks.
+     *
+     * Auto-reconnect is intentionally NOT included. The Hits tab decides
+     * when to retry (and how often) — pushing that policy into here would
+     * couple the client to UI semantics.
+     */
+    subscribeAnalyticsStream(onMessage, onError) {
+        const url = new URL(this.baseUrl + '/analytics/stream');
+        let closed = false;
+        let res = null;
+        const req = httpRequest({
+            hostname: url.hostname,
+            port: url.port || 80,
+            path: url.pathname + url.search,
+            method: 'GET',
+            headers: { ...this.headers(), 'Accept': 'text/event-stream' },
+        }, (response) => {
+            if (closed) {
+                response.destroy();
+                return;
+            }
+            res = response;
+            if (!response.statusCode || response.statusCode < 200 || response.statusCode >= 300) {
+                onError?.(new Error(`HTTP ${response.statusCode}`));
+                response.destroy();
+                return;
+            }
+            response.setEncoding('utf-8');
+            let buf = '';
+            response.on('data', (chunk) => {
+                if (closed)
+                    return;
+                buf += chunk;
+                // SSE frames are separated by a blank line. Each frame can
+                // have a `data:` field (possibly across multiple `data:` lines
+                // — we concatenate them with \n per the SSE spec).
+                let idx;
+                while ((idx = buf.indexOf('\n\n')) >= 0) {
+                    const frame = buf.slice(0, idx);
+                    buf = buf.slice(idx + 2);
+                    const dataLines = frame.split('\n')
+                        .filter(l => l.startsWith('data:'))
+                        .map(l => l.slice(5).replace(/^ /, ''));
+                    if (dataLines.length === 0)
+                        continue;
+                    const payload = dataLines.join('\n');
+                    try {
+                        const parsed = JSON.parse(payload);
+                        onMessage(parsed);
+                    }
+                    catch (e) {
+                        onError?.(new Error(`SSE parse: ${e.message}`));
+                    }
+                }
+            });
+            response.on('error', (e) => { if (!closed)
+                onError?.(e); });
+            response.on('end', () => { if (!closed)
+                onError?.(new Error('stream ended')); });
+        });
+        req.on('error', (e) => { if (!closed)
+            onError?.(e); });
+        // No timeout on SSE — the heartbeat keeps the connection alive.
+        req.end();
+        return () => {
+            closed = true;
+            try {
+                req.destroy();
+            }
+            catch { /* ignored */ }
+            try {
+                res?.destroy();
+            }
+            catch { /* ignored */ }
+        };
+    }
+    headers() {
+        const h = {};
+        if (this.apiKey)
+            h['x-api-key'] = this.apiKey;
+        return h;
+    }
+}

package/dist/tui/render.d.ts

@@ -0,0 +1,178 @@
+/**
+ * TUI rendering primitives — pure ANSI escape sequence helpers.
+ *
+ * Every function in this module is a pure string-returning helper. No
+ * side effects, no console writes. The App's render() loop accumulates
+ * these strings into a single buffer, then flushes once to stdout. This
+ * keeps render testable (assert string equality against fixtures) and
+ * keeps flicker minimal (single write call per frame).
+ *
+ * Color set: a deliberate 16-color subset of the ANSI palette plus a
+ * handful of 256-color brand accents. Reasoning: 16-color is universal,
+ * the brand greens (#00ff88-ish) are used sparingly for the dario
+ * accent and degrade gracefully on terminals that can't render them.
+ *
+ * What this module deliberately does NOT do:
+ *   - Track cursor position (callers pass row/col explicitly)
+ *   - Diff frames (full-screen redraw per frame is fast enough at
+ *     ~3000 cells; complexity not worth it)
+ *   - Handle terminal capabilities probing (use ANSI + assume modern)
+ */
+/**
+ * Move the cursor to (row, col). 1-indexed, matching the ANSI spec —
+ * row=1 is the top line, col=1 is the leftmost column.
+ */
+export declare function moveTo(row: number, col: number): string;
+/** Hide the blinking cursor (TUI doesn't need it). */
+export declare const hideCursor = "\u001B[?25l";
+/** Restore the cursor. ALWAYS run on exit to leave the terminal sane. */
+export declare const showCursor = "\u001B[?25h";
+/** Enter the alternate screen buffer — TUI lives here so quit restores prior shell content. */
+export declare const enterAltScreen = "\u001B[?1049h";
+/** Leave the alternate screen buffer. Pair with enterAltScreen on exit. */
+export declare const leaveAltScreen = "\u001B[?1049l";
+/** Clear the entire screen and move cursor to home. */
+export declare const clearScreen = "\u001B[2J\u001B[H";
+/** Clear from cursor to end of line. */
+export declare const clearLineRight = "\u001B[K";
+/** Reset all SGR (color + style) attributes. */
+export declare const reset = "\u001B[0m";
+/**
+ * Foreground color names mapped to ANSI codes. `default` resets to
+ * the terminal's default foreground.
+ */
+export declare const FG: {
+    readonly default: 39;
+    readonly black: 30;
+    readonly red: 31;
+    readonly green: 32;
+    readonly yellow: 33;
+    readonly blue: 34;
+    readonly magenta: 35;
+    readonly cyan: 36;
+    readonly white: 37;
+    readonly brightBlack: 90;
+    readonly brightRed: 91;
+    readonly brightGreen: 92;
+    readonly brightYellow: 93;
+    readonly brightBlue: 94;
+    readonly brightMagenta: 95;
+    readonly brightCyan: 96;
+    readonly brightWhite: 97;
+};
+/** Background color names mapped to ANSI codes. */
+export declare const BG: {
+    readonly default: 49;
+    readonly black: 40;
+    readonly red: 41;
+    readonly green: 42;
+    readonly yellow: 43;
+    readonly blue: 44;
+    readonly magenta: 45;
+    readonly cyan: 46;
+    readonly white: 47;
+    readonly brightBlack: 100;
+    readonly brightRed: 101;
+    readonly brightGreen: 102;
+    readonly brightYellow: 103;
+    readonly brightBlue: 104;
+    readonly brightMagenta: 105;
+    readonly brightCyan: 106;
+    readonly brightWhite: 107;
+};
+export type FgColor = keyof typeof FG;
+export type BgColor = keyof typeof BG;
+/**
+ * Wrap text in foreground-color SGR codes. Resets to default fg at
+ * the end so subsequent uncolored text isn't accidentally colored.
+ *
+ * Example: `fg('green', 'OK')` → `\x1b[32mOK\x1b[39m`
+ */
+export declare function fg(color: FgColor, text: string): string;
+export declare function bg(color: BgColor, text: string): string;
+export declare function bold(text: string): string;
+export declare function dim(text: string): string;
+export declare function inverse(text: string): string;
+export declare function underline(text: string): string;
+/**
+ * Brand accent — the askalf green (#00ff88-ish) via the 256-color
+ * palette index 48. Falls back gracefully on terminals that don't
+ * render 256-color (they show as bright green).
+ */
+export declare function brand(text: string): string;
+/**
+ * Visible-width of a string. ANSI escape sequences and zero-width
+ * sequences contribute 0. Tabs count as 1 (terminals vary; better
+ * to under- than over-estimate). Multi-byte characters (CJK, emoji)
+ * are NOT special-cased in v4.0 — the TUI's content is ASCII-dominant
+ * (model names, numbers, labels). A future revision can add a
+ * `string-width`-style lookup if non-ASCII becomes common.
+ */
+export declare function visibleWidth(s: string): number;
+/**
+ * Truncate `text` to at most `maxWidth` visible chars, appending `…`
+ * if anything was clipped. ANSI sequences within the truncated portion
+ * are preserved verbatim; truncation only counts visible characters.
+ *
+ * Example: truncate('hello world', 8) → 'hello w…'
+ */
+export declare function truncate(text: string, maxWidth: number, ellipsis?: string): string;
+/** Pad `text` (right-aligned by default 'left' fills right side) to `width`. */
+export declare function pad(text: string, width: number, align?: 'left' | 'right' | 'center'): string;
+/**
+ * Render a horizontal progress bar.
+ *
+ *   value:   0..1 (clamped)
+ *   width:   total cell count of the bar
+ *
+ * Uses the full-block ▓ / shade ░ characters; passes through as plain
+ * ASCII on terminals that don't render the box-drawing set (they look
+ * like `?` but the layout still works).
+ */
+export declare function progressBar(value: number, width: number, opts?: {
+    filled?: string;
+    empty?: string;
+}): string;
+/**
+ * Box-drawing characters for borders. Set picked to render well on
+ * most terminals (Unicode box-drawing). Override via `customChars` if
+ * a terminal renders these badly — but the default targets the
+ * 99%-of-users case.
+ */
+export declare const BOX: {
+    readonly topLeft: "┌";
+    readonly topRight: "┐";
+    readonly bottomLeft: "└";
+    readonly bottomRight: "┘";
+    readonly horizontal: "─";
+    readonly vertical: "│";
+    readonly cross: "┼";
+    readonly tLeft: "├";
+    readonly tRight: "┤";
+    readonly tTop: "┬";
+    readonly tBottom: "┴";
+};
+/**
+ * Render a box at (row, col) with the given width and height. Returns
+ * the full ANSI string (positioned writes + box characters). The
+ * interior is NOT cleared — callers paint inside the box separately.
+ */
+export declare function drawBox(row: number, col: number, width: number, height: number): string;
+/**
+ * Frame builder. The App's render() collects strings into one of these
+ * then calls `flush(stdout)` for a single write. Single-write rendering
+ * eliminates flicker on most terminals.
+ */
+export declare class Frame {
+    private chunks;
+    /** Append a string. No positioning — caller is responsible. */
+    write(s: string): void;
+    /** Append a positioned write at (row, col). */
+    writeAt(row: number, col: number, s: string): void;
+    /** Return the accumulated frame as a single string. */
+    toString(): string;
+    /** Number of accumulated chunks (debugging aid). */
+    get length(): number;
+    /** Drop everything. Reuses the array allocation. */
+    clear(): void;
+}

package/dist/tui/render.js

@@ -0,0 +1,246 @@
+/**
+ * TUI rendering primitives — pure ANSI escape sequence helpers.
+ *
+ * Every function in this module is a pure string-returning helper. No
+ * side effects, no console writes. The App's render() loop accumulates
+ * these strings into a single buffer, then flushes once to stdout. This
+ * keeps render testable (assert string equality against fixtures) and
+ * keeps flicker minimal (single write call per frame).
+ *
+ * Color set: a deliberate 16-color subset of the ANSI palette plus a
+ * handful of 256-color brand accents. Reasoning: 16-color is universal,
+ * the brand greens (#00ff88-ish) are used sparingly for the dario
+ * accent and degrade gracefully on terminals that can't render them.
+ *
+ * What this module deliberately does NOT do:
+ *   - Track cursor position (callers pass row/col explicitly)
+ *   - Diff frames (full-screen redraw per frame is fast enough at
+ *     ~3000 cells; complexity not worth it)
+ *   - Handle terminal capabilities probing (use ANSI + assume modern)
+ */
+// ── Escape sequences ────────────────────────────────────────────────
+/** Control Sequence Introducer. */
+const ESC = '\x1b[';
+/**
+ * Move the cursor to (row, col). 1-indexed, matching the ANSI spec —
+ * row=1 is the top line, col=1 is the leftmost column.
+ */
+export function moveTo(row, col) {
+    return `${ESC}${row};${col}H`;
+}
+/** Hide the blinking cursor (TUI doesn't need it). */
+export const hideCursor = `${ESC}?25l`;
+/** Restore the cursor. ALWAYS run on exit to leave the terminal sane. */
+export const showCursor = `${ESC}?25h`;
+/** Enter the alternate screen buffer — TUI lives here so quit restores prior shell content. */
+export const enterAltScreen = `${ESC}?1049h`;
+/** Leave the alternate screen buffer. Pair with enterAltScreen on exit. */
+export const leaveAltScreen = `${ESC}?1049l`;
+/** Clear the entire screen and move cursor to home. */
+export const clearScreen = `${ESC}2J${ESC}H`;
+/** Clear from cursor to end of line. */
+export const clearLineRight = `${ESC}K`;
+/** Reset all SGR (color + style) attributes. */
+export const reset = `${ESC}0m`;
+// ── Colors (16-color ANSI + brand accent) ──────────────────────────
+/**
+ * Foreground color names mapped to ANSI codes. `default` resets to
+ * the terminal's default foreground.
+ */
+export const FG = {
+    default: 39,
+    black: 30, red: 31, green: 32, yellow: 33,
+    blue: 34, magenta: 35, cyan: 36, white: 37,
+    brightBlack: 90, brightRed: 91, brightGreen: 92, brightYellow: 93,
+    brightBlue: 94, brightMagenta: 95, brightCyan: 96, brightWhite: 97,
+};
+/** Background color names mapped to ANSI codes. */
+export const BG = {
+    default: 49,
+    black: 40, red: 41, green: 42, yellow: 43,
+    blue: 44, magenta: 45, cyan: 46, white: 47,
+    brightBlack: 100, brightRed: 101, brightGreen: 102, brightYellow: 103,
+    brightBlue: 104, brightMagenta: 105, brightCyan: 106, brightWhite: 107,
+};
+/**
+ * Wrap text in foreground-color SGR codes. Resets to default fg at
+ * the end so subsequent uncolored text isn't accidentally colored.
+ *
+ * Example: `fg('green', 'OK')` → `\x1b[32mOK\x1b[39m`
+ */
+export function fg(color, text) {
+    return `${ESC}${FG[color]}m${text}${ESC}${FG.default}m`;
+}
+export function bg(color, text) {
+    return `${ESC}${BG[color]}m${text}${ESC}${BG.default}m`;
+}
+export function bold(text) {
+    return `${ESC}1m${text}${ESC}22m`;
+}
+export function dim(text) {
+    return `${ESC}2m${text}${ESC}22m`;
+}
+export function inverse(text) {
+    return `${ESC}7m${text}${ESC}27m`;
+}
+export function underline(text) {
+    return `${ESC}4m${text}${ESC}24m`;
+}
+/**
+ * Brand accent — the askalf green (#00ff88-ish) via the 256-color
+ * palette index 48. Falls back gracefully on terminals that don't
+ * render 256-color (they show as bright green).
+ */
+export function brand(text) {
+    return `${ESC}38;5;48m${text}${ESC}${FG.default}m`;
+}
+// ── String helpers ─────────────────────────────────────────────────
+/**
+ * Visible-width of a string. ANSI escape sequences and zero-width
+ * sequences contribute 0. Tabs count as 1 (terminals vary; better
+ * to under- than over-estimate). Multi-byte characters (CJK, emoji)
+ * are NOT special-cased in v4.0 — the TUI's content is ASCII-dominant
+ * (model names, numbers, labels). A future revision can add a
+ * `string-width`-style lookup if non-ASCII becomes common.
+ */
+export function visibleWidth(s) {
+    // Strip ANSI escape sequences (CSI + everything up to terminating byte).
+    const stripped = s.replace(/\x1b\[[\x30-\x3f]*[\x20-\x2f]*[\x40-\x7e]/g, '');
+    return stripped.length;
+}
+/**
+ * Truncate `text` to at most `maxWidth` visible chars, appending `…`
+ * if anything was clipped. ANSI sequences within the truncated portion
+ * are preserved verbatim; truncation only counts visible characters.
+ *
+ * Example: truncate('hello world', 8) → 'hello w…'
+ */
+export function truncate(text, maxWidth, ellipsis = '…') {
+    if (maxWidth <= 0)
+        return '';
+    if (visibleWidth(text) <= maxWidth)
+        return text;
+    const ellipsisWidth = visibleWidth(ellipsis);
+    if (maxWidth <= ellipsisWidth)
+        return ellipsis.slice(0, maxWidth);
+    // Walk the string, counting visible chars, stop when we'd exceed
+    // maxWidth - ellipsisWidth so we have room to append.
+    const target = maxWidth - ellipsisWidth;
+    let out = '';
+    let visible = 0;
+    let i = 0;
+    while (i < text.length && visible < target) {
+        if (text[i] === '\x1b' && text[i + 1] === '[') {
+            // Copy the full escape sequence
+            const m = text.slice(i).match(/^\x1b\[[\x30-\x3f]*[\x20-\x2f]*[\x40-\x7e]/);
+            if (m) {
+                out += m[0];
+                i += m[0].length;
+                continue;
+            }
+        }
+        out += text[i];
+        visible++;
+        i++;
+    }
+    return out + ellipsis;
+}
+/** Pad `text` (right-aligned by default 'left' fills right side) to `width`. */
+export function pad(text, width, align = 'left') {
+    const w = visibleWidth(text);
+    if (w >= width)
+        return truncate(text, width);
+    const gap = width - w;
+    if (align === 'right')
+        return ' '.repeat(gap) + text;
+    if (align === 'center') {
+        const left = Math.floor(gap / 2);
+        const right = gap - left;
+        return ' '.repeat(left) + text + ' '.repeat(right);
+    }
+    return text + ' '.repeat(gap);
+}
+/**
+ * Render a horizontal progress bar.
+ *
+ *   value:   0..1 (clamped)
+ *   width:   total cell count of the bar
+ *
+ * Uses the full-block ▓ / shade ░ characters; passes through as plain
+ * ASCII on terminals that don't render the box-drawing set (they look
+ * like `?` but the layout still works).
+ */
+export function progressBar(value, width, opts = {}) {
+    const filled = opts.filled ?? '█';
+    const empty = opts.empty ?? '░';
+    const clamped = Math.max(0, Math.min(1, value));
+    const cells = Math.round(clamped * width);
+    return filled.repeat(cells) + empty.repeat(width - cells);
+}
+/**
+ * Box-drawing characters for borders. Set picked to render well on
+ * most terminals (Unicode box-drawing). Override via `customChars` if
+ * a terminal renders these badly — but the default targets the
+ * 99%-of-users case.
+ */
+export const BOX = {
+    topLeft: '┌', topRight: '┐',
+    bottomLeft: '└', bottomRight: '┘',
+    horizontal: '─', vertical: '│',
+    cross: '┼', tLeft: '├', tRight: '┤',
+    tTop: '┬', tBottom: '┴',
+};
+/**
+ * Render a box at (row, col) with the given width and height. Returns
+ * the full ANSI string (positioned writes + box characters). The
+ * interior is NOT cleared — callers paint inside the box separately.
+ */
+export function drawBox(row, col, width, height) {
+    if (width < 2 || height < 2)
+        return '';
+    const out = [];
+    // Top border
+    out.push(moveTo(row, col));
+    out.push(BOX.topLeft + BOX.horizontal.repeat(width - 2) + BOX.topRight);
+    // Sides
+    for (let r = 1; r < height - 1; r++) {
+        out.push(moveTo(row + r, col));
+        out.push(BOX.vertical);
+        out.push(moveTo(row + r, col + width - 1));
+        out.push(BOX.vertical);
+    }
+    // Bottom border
+    out.push(moveTo(row + height - 1, col));
+    out.push(BOX.bottomLeft + BOX.horizontal.repeat(width - 2) + BOX.bottomRight);
+    return out.join('');
+}
+// ── Frame buffer ───────────────────────────────────────────────────
+/**
+ * Frame builder. The App's render() collects strings into one of these
+ * then calls `flush(stdout)` for a single write. Single-write rendering
+ * eliminates flicker on most terminals.
+ */
+export class Frame {
+    chunks = [];
+    /** Append a string. No positioning — caller is responsible. */
+    write(s) {
+        this.chunks.push(s);
+    }
+    /** Append a positioned write at (row, col). */
+    writeAt(row, col, s) {
+        this.chunks.push(moveTo(row, col));
+        this.chunks.push(s);
+    }
+    /** Return the accumulated frame as a single string. */
+    toString() {
+        return this.chunks.join('');
+    }
+    /** Number of accumulated chunks (debugging aid). */
+    get length() {
+        return this.chunks.length;
+    }
+    /** Drop everything. Reuses the array allocation. */
+    clear() {
+        this.chunks.length = 0;
+    }
+}