@aragon-agent/cli 0.6.29 → 0.6.31

package/dist/ui/scrollback/drain.js

@@ -0,0 +1,64 @@
+/**
+ * Static-row feed — the queue between the promotion pipeline (which decides an
+ * entry is final) and the scrollback writer (which prints it)
+ * (tui-native-terminal-scroll §4.3 "feed").
+ *
+ * FIFO, bounded. When the writer falls behind and the queue overflows, the OLDEST
+ * pending entries are folded into one ASCII marker and counted: a visible, counted
+ * omission, never a silent one (I-S2). Entries are taken as whole blocks and never
+ * split, so a batch boundary can never land inside one entry's rows.
+ */
+import { SCROLLBACK_LIMITS } from './limits.js';
+export function overflowMarker(count) {
+    return `[${count} earlier ${count === 1 ? 'entry' : 'entries'} not printed - scrollback feed overflow]`;
+}
+export function createScrollbackDrain(options = {}) {
+    const capacity = Math.max(1, options.capacity ?? SCROLLBACK_LIMITS.feedCapacity);
+    const queue = [];
+    /** Entries folded since the marker was last printed. */
+    let foldedPending = 0;
+    let foldedTotal = 0;
+    const markerRows = () => (foldedPending > 0 ? 1 : 0);
+    const takeWhile = (fits) => {
+        const out = [];
+        if (foldedPending > 0) {
+            out.push(overflowMarker(foldedPending));
+            foldedPending = 0;
+        }
+        while (queue.length > 0) {
+            const next = queue[0];
+            // Always take the first entry, however tall: a block taller than the cap
+            // still has to print, and the writer splits at ENTRY boundaries only.
+            if (out.length > 0 && !fits(out.length, next.rows.length))
+                break;
+            queue.shift();
+            for (const row of next.rows)
+                out.push(row);
+        }
+        return out;
+    };
+    const drained = (taken) => {
+        if (taken.length > 0)
+            drain.onDrained?.();
+        return taken;
+    };
+    const drain = {
+        onEnqueue: null,
+        onDrained: null,
+        enqueue(rows, meta) {
+            queue.push({ id: meta.id, kind: meta.kind, rows });
+            while (queue.length > capacity) {
+                queue.shift();
+                foldedPending += 1;
+                foldedTotal += 1;
+            }
+            drain.onEnqueue?.();
+        },
+        takeAll: () => drained(takeWhile(() => true)),
+        takeUpTo: (maxRows) => drained(takeWhile((taken, next) => taken + next <= maxRows)),
+        pending: () => queue.reduce((sum, entry) => sum + entry.rows.length, markerRows()),
+        pendingEntries: () => queue.length,
+        elided: () => foldedTotal,
+    };
+    return drain;
+}

package/dist/ui/scrollback/exit-summary.d.ts

@@ -0,0 +1,23 @@
+/**
+ * Exit summary for native-scroll mode (tui-native-terminal-scroll §4.8 / D9).
+ *
+ * The conversation is already in the terminal's scrollback, so exit does NOT replay
+ * it (that would print every message twice). It prints at most four short lines and
+ * leaves the cursor on a fresh line.
+ *
+ * PURE and ASCII-safe: glyphs come from `pickGlyphs`, and the figures come from the
+ * same `formatSessionStats` the full-screen replay uses.
+ */
+import type { Entry, UsageTotal } from '../../agent/reducer.js';
+import type { Glyphs } from '../glyphs.js';
+export interface ExitSummaryInput {
+    entries: readonly Entry[];
+    usageTotal: UsageTotal;
+    provider: string;
+    model: string;
+    elapsedMs: number;
+    /** The session id, when this process has one worth resuming. */
+    sessionId?: string;
+    glyphs: Pick<Glyphs, 'midDot' | 'arrowUp' | 'arrowDown'>;
+}
+export declare function buildExitSummary(input: ExitSummaryInput): string[];

package/dist/ui/scrollback/exit-summary.js

@@ -0,0 +1,25 @@
+/**
+ * Exit summary for native-scroll mode (tui-native-terminal-scroll §4.8 / D9).
+ *
+ * The conversation is already in the terminal's scrollback, so exit does NOT replay
+ * it (that would print every message twice). It prints at most four short lines and
+ * leaves the cursor on a fresh line.
+ *
+ * PURE and ASCII-safe: glyphs come from `pickGlyphs`, and the figures come from the
+ * same `formatSessionStats` the full-screen replay uses.
+ */
+import { formatDuration } from '../../agent/usage.js';
+import { formatSessionStats } from '../transcript-text.js';
+import { SCROLLBACK_LIMITS } from './limits.js';
+export function buildExitSummary(input) {
+    const { glyphs: g } = input;
+    const stats = formatSessionStats(input.entries, input.usageTotal, g);
+    const rows = [
+        ['Session ended', `${input.provider}:${input.model}`, formatDuration(Math.max(0, input.elapsedMs))]
+            .join(` ${g.midDot} `),
+        [stats.turns, stats.tokens, stats.cost].join(` ${g.midDot} `),
+    ];
+    if (input.sessionId)
+        rows.push(`Resume: aragon --resume ${input.sessionId}`);
+    return rows.slice(0, SCROLLBACK_LIMITS.exitSummaryMaxRows);
+}

package/dist/ui/scrollback/limits.d.ts

@@ -0,0 +1,25 @@
+/**
+ * Structural limits of native-scroll mode (tui-native-terminal-scroll §4.3-§4.6).
+ *
+ * Structural caps live here; tunable policy lives in `config/schema.ts`. None of
+ * these is a user preference: each one bounds a failure (a runaway write, a live
+ * region that eats the screen) rather than expressing a taste.
+ */
+export declare const SCROLLBACK_LIMITS: {
+    /** Pending static entries the drain holds before folding the oldest into a marker. */
+    readonly feedCapacity: 32;
+    /** Rows one entry may print; the rest is replaced by one ASCII notice row. */
+    readonly maxRowsPerEntry: 400;
+    /** Static rows per `stdout.write`; larger feeds are split into consecutive batches. */
+    readonly maxRowsPerBatch: 2000;
+    /** tall-frame swallows within this window after a resize are expected and uncounted. */
+    readonly guardResizeGraceMs: 250;
+    /** Consecutive out-of-resize tall frames that degrade the app to the placeholder. */
+    readonly guardTripCount: 3;
+    /** Session summary rows printed on exit. */
+    readonly exitSummaryMaxRows: 4;
+    /** Streaming preview rows, absolute cap. */
+    readonly maxLiveTailRows: 12;
+    /** ... and as a share of the terminal height. */
+    readonly liveTailRowShare: 0.4;
+};

package/dist/ui/scrollback/limits.js

@@ -0,0 +1,25 @@
+/**
+ * Structural limits of native-scroll mode (tui-native-terminal-scroll §4.3-§4.6).
+ *
+ * Structural caps live here; tunable policy lives in `config/schema.ts`. None of
+ * these is a user preference: each one bounds a failure (a runaway write, a live
+ * region that eats the screen) rather than expressing a taste.
+ */
+export const SCROLLBACK_LIMITS = {
+    /** Pending static entries the drain holds before folding the oldest into a marker. */
+    feedCapacity: 32,
+    /** Rows one entry may print; the rest is replaced by one ASCII notice row. */
+    maxRowsPerEntry: 400,
+    /** Static rows per `stdout.write`; larger feeds are split into consecutive batches. */
+    maxRowsPerBatch: 2000,
+    /** tall-frame swallows within this window after a resize are expected and uncounted. */
+    guardResizeGraceMs: 250,
+    /** Consecutive out-of-resize tall frames that degrade the app to the placeholder. */
+    guardTripCount: 3,
+    /** Session summary rows printed on exit. */
+    exitSummaryMaxRows: 4,
+    /** Streaming preview rows, absolute cap. */
+    maxLiveTailRows: 12,
+    /** ... and as a share of the terminal height. */
+    liveTailRowShare: 0.4,
+};

package/dist/ui/scrollback/live-preview.d.ts

@@ -0,0 +1,26 @@
+/**
+ * Streaming preview rows for the native-scroll live region
+ * (tui-native-terminal-scroll §4.6).
+ *
+ * Entries that are not yet final cannot be printed, but the user must still see the
+ * answer arrive. This builds a few PLAIN-TEXT rows from the unsettled tail of the
+ * transcript; the shell colours them uniformly (`theme.muted`). The preview is a
+ * visual buffer only: when an entry settles it is printed in its real, formatted
+ * shape and the preview rows disappear (the "settle jump", documented in the README).
+ *
+ * PURE: no Ink, no theme, no I/O. Every returned row fits `cols` display columns.
+ */
+import type { Entry } from '../../agent/reducer.js';
+export interface LivePreviewInput {
+    /** `entries.slice(settledCount)` — may include excluded entries; they are skipped. */
+    unsettled: readonly Entry[];
+    /** Content width (`cols - 1`). */
+    cols: number;
+    /** Rows granted by the budget. */
+    rows: number;
+    thinkingVisible: boolean;
+}
+/** The last `rows` preview rows, oldest first. `[]` when `rows <= 0`. */
+export declare function buildLivePreview(input: LivePreviewInput): string[];
+/** How many preview rows the unsettled entries would like, before budget clamping. */
+export declare function wantedPreviewRows(input: Omit<LivePreviewInput, 'rows'>, cap: number): number;

package/dist/ui/scrollback/live-preview.js

@@ -0,0 +1,106 @@
+/**
+ * Streaming preview rows for the native-scroll live region
+ * (tui-native-terminal-scroll §4.6).
+ *
+ * Entries that are not yet final cannot be printed, but the user must still see the
+ * answer arrive. This builds a few PLAIN-TEXT rows from the unsettled tail of the
+ * transcript; the shell colours them uniformly (`theme.muted`). The preview is a
+ * visual buffer only: when an entry settles it is printed in its real, formatted
+ * shape and the preview rows disappear (the "settle jump", documented in the README).
+ *
+ * PURE: no Ink, no theme, no I/O. Every returned row fits `cols` display columns.
+ */
+import { clampLiveText } from '../live-clamp.js';
+import { wrapToRows } from '../layout/wrap-rows.js';
+import { isExcluded } from './settled-boundary.js';
+import { clipLine } from './writer-shapes.js';
+const MAX_TEAM_RUN_ROWS = 3;
+const TOOL_LIVE_ROWS = 6;
+function firstLine(text) {
+    const line = text.split('\n').find((candidate) => candidate.trim().length > 0);
+    return (line ?? '').trim();
+}
+function fit(text, cols) {
+    return clipLine(text, Math.max(1, cols)).text;
+}
+function assistantRows(entry, cols, rows, thinkingVisible) {
+    const out = [];
+    const thinking = (entry.thinking ?? '').trim();
+    if (entry.text.trim().length === 0) {
+        if (thinking.length > 0 && thinkingVisible) {
+            const last = thinking.split('\n').filter((line) => line.trim().length > 0).pop() ?? '';
+            out.push(fit(`thinking: ${last.trim()}`, cols));
+        }
+        else if (entry.streaming) {
+            out.push('thinking...');
+        }
+        return out;
+    }
+    const clamped = clampLiveText(entry.text, rows * 2);
+    out.push(...wrapToRows(clamped.text, cols).map((row) => fit(row, cols)));
+    return out;
+}
+function toolRows(entry, cols) {
+    const head = entry.label && entry.label.length > 0 ? entry.label : entry.name;
+    const out = [fit(`${entry.status === 'running' ? '>' : '.'} ${head}`, cols)];
+    const live = (entry.live ?? []).slice(-TOOL_LIVE_ROWS);
+    for (const row of live)
+        out.push(fit(`  ${row}`, cols));
+    return out;
+}
+function teamRows(entry, cols) {
+    const running = entry.runs.filter((run) => !['queued', 'done', 'failed', 'aborted'].includes(run.phase)).length;
+    const out = [fit(`Team: ${running}/${entry.runs.length} running`, cols)];
+    for (const run of entry.runs.slice(0, MAX_TEAM_RUN_ROWS)) {
+        out.push(fit(`  ${run.label} ${run.phase}`, cols));
+    }
+    return out;
+}
+function entryRows(entry, input) {
+    const { cols, rows, thinkingVisible } = input;
+    switch (entry.kind) {
+        case 'assistant':
+            return assistantRows(entry, cols, rows, thinkingVisible);
+        case 'tool':
+            return toolRows(entry, cols);
+        case 'team':
+            return teamRows(entry, cols);
+        case 'todo':
+            return [fit(`Todo: ${entry.doneCount}/${entry.total}`, cols)];
+        case 'compaction':
+            return [fit(`Compacting context...`, cols)];
+        case 'retry':
+            return [fit(`Retrying (${entry.attempt}/${entry.maxRetries})...`, cols)];
+        case 'fast':
+            return [fit(`Fast review ${entry.reviewIndex}...`, cols)];
+        case 'queued':
+            return [fit(`Queued: ${firstLine(entry.text)}`, cols)];
+        case 'user':
+            return [fit(`> ${firstLine(entry.text)}`, cols)];
+        case 'notice':
+            return [fit(firstLine(entry.text), cols)];
+        case 'service':
+            return [];
+        default: {
+            const exhaustive = entry;
+            return exhaustive;
+        }
+    }
+}
+/** The last `rows` preview rows, oldest first. `[]` when `rows <= 0`. */
+export function buildLivePreview(input) {
+    const rows = Math.floor(input.rows);
+    if (rows <= 0)
+        return [];
+    const all = [];
+    for (const entry of input.unsettled) {
+        if (isExcluded(entry))
+            continue;
+        all.push(...entryRows(entry, input));
+    }
+    return all.slice(-rows);
+}
+/** How many preview rows the unsettled entries would like, before budget clamping. */
+export function wantedPreviewRows(input, cap) {
+    return buildLivePreview({ ...input, rows: cap }).length;
+}

package/dist/ui/scrollback/renderer.d.ts

@@ -0,0 +1,38 @@
+/**
+ * Offscreen entry renderer (tui-native-terminal-scroll §4.5 / D4).
+ *
+ * Settled entries are rendered ONCE, to ANSI text, by a resident Ink instance that
+ * writes to a fake stdout (`debug: true`: Ink then emits the complete layout in one
+ * write per render and never touches log-update). The resulting rows go to the feed
+ * and are printed; they are never mounted in the live React tree, so the per-frame
+ * render cost stays proportional to what is on screen, not to the session length.
+ *
+ * Failure isolation (I-S12): one entry that throws while rendering degrades to a
+ * single placeholder row. It must never block the queue or take the session down.
+ */
+import React from 'react';
+import type { Entry } from '../../agent/reducer.js';
+import type { TermCapabilities } from '../capabilities.js';
+import type { DensityMode } from '../density.js';
+import type { Theme } from '../theme.js';
+export interface EntryRenderOptions {
+    theme: Theme;
+    caps: TermCapabilities;
+    density: DensityMode;
+    thinkingVisible: boolean;
+    reducedMotion: boolean;
+}
+export interface EntryRenderer {
+    /** Rows for one entry at `cols` columns; `[]` when it renders as nothing. */
+    renderEntry(entry: Entry, prev: Entry | undefined, cols: number, expanded?: boolean): string[];
+    /** Rows for an arbitrary node (the startup header and opener). */
+    renderNode(node: React.ReactNode, cols: number): string[];
+    /** Options for LATER renders; already printed rows never change. */
+    setOptions(partial: Partial<EntryRenderOptions>): void;
+    stats(): {
+        elidedRows: number;
+        failures: number;
+    };
+    dispose(): void;
+}
+export declare function createEntryRenderer(initial: EntryRenderOptions): EntryRenderer;

package/dist/ui/scrollback/renderer.js

@@ -0,0 +1,158 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+/**
+ * Offscreen entry renderer (tui-native-terminal-scroll §4.5 / D4).
+ *
+ * Settled entries are rendered ONCE, to ANSI text, by a resident Ink instance that
+ * writes to a fake stdout (`debug: true`: Ink then emits the complete layout in one
+ * write per render and never touches log-update). The resulting rows go to the feed
+ * and are printed; they are never mounted in the live React tree, so the per-frame
+ * render cost stays proportional to what is on screen, not to the session length.
+ *
+ * Failure isolation (I-S12): one entry that throws while rendering degrades to a
+ * single placeholder row. It must never block the queue or take the session down.
+ */
+import React from 'react';
+import { EventEmitter } from 'node:events';
+import { Box, render } from 'ink';
+import { EntryView } from '../Transcript.js';
+import { getLogger } from '../../logging/logger.js';
+import { SCROLLBACK_LIMITS } from './limits.js';
+/**
+ * Catches a throwing entry INSIDE the offscreen tree.
+ *
+ * Without it Ink's own boundary would print an error overview into the frame (which
+ * would then be printed into the user's scrollback, forever) and unmount the
+ * instance, so every later entry would fail too. With it the failure is a flag the
+ * caller reads synchronously and the instance stays healthy (I-S12).
+ */
+class RenderGuard extends React.Component {
+    state = { failed: false };
+    static getDerivedStateFromError() {
+        return { failed: true };
+    }
+    componentDidCatch(error) {
+        this.props.failure.error = error;
+    }
+    render() {
+        return this.state.failed ? null : this.props.children;
+    }
+}
+const NO_FAILURE = Symbol('no-failure');
+function createOffscreen(cols) {
+    const last = { value: null };
+    const stdout = Object.assign(new EventEmitter(), {
+        columns: cols,
+        rows: 1000,
+        isTTY: false,
+        write(chunk) {
+            last.value = chunk;
+            return true;
+        },
+    });
+    const stdin = Object.assign(new EventEmitter(), {
+        isTTY: false,
+        setEncoding() { },
+        resume() { },
+        pause() { },
+        ref() { },
+        unref() { },
+    });
+    const instance = render(null, {
+        stdout, stdin, stderr: stdout, debug: true, exitOnCtrlC: false, patchConsole: false,
+    });
+    // A rejected exit promise nobody awaits is an unhandled rejection.
+    void instance.waitUntilExit().catch(() => undefined);
+    return { cols, stdout, stdin, instance, last, failure: { error: NO_FAILURE } };
+}
+/** A function, so the compiler does not narrow the mutable `last` box to `null`. */
+function readFrame(target) {
+    return target.last.value;
+}
+function trimTrailingBlank(rows) {
+    let end = rows.length;
+    while (end > 0 && rows[end - 1].trim().length === 0)
+        end -= 1;
+    return end === rows.length ? rows : rows.slice(0, end);
+}
+export function createEntryRenderer(initial) {
+    let options = initial;
+    let offscreen = null;
+    let elidedRows = 0;
+    let failures = 0;
+    let guardKey = 0;
+    const dispose = () => {
+        if (!offscreen)
+            return;
+        const current = offscreen;
+        offscreen = null;
+        try {
+            current.instance.unmount();
+            current.instance.cleanup();
+        }
+        catch {
+            // Tearing down a fake stream must never throw into an exit path.
+        }
+    };
+    /** Ink reads `columns` once, at creation, so a width change rebuilds the instance. */
+    const ensure = (cols) => {
+        if (offscreen && offscreen.cols === cols)
+            return offscreen;
+        dispose();
+        offscreen = createOffscreen(cols);
+        return offscreen;
+    };
+    const capRows = (rows) => {
+        const cap = SCROLLBACK_LIMITS.maxRowsPerEntry;
+        if (rows.length <= cap)
+            return rows;
+        const hidden = rows.length - (cap - 1);
+        elidedRows += hidden;
+        return [...rows.slice(0, cap - 1), `[+${hidden} rows not printed - scrollback entry cap]`];
+    };
+    const renderNode = (node, cols) => {
+        const target = ensure(Math.max(1, Math.floor(cols)));
+        target.last.value = null;
+        target.failure.error = NO_FAILURE;
+        guardKey += 1;
+        target.instance.rerender(_jsx(Box, { flexDirection: "column", width: target.cols, children: _jsx(RenderGuard, { failure: target.failure, children: node }, guardKey) }));
+        const frame = readFrame(target);
+        const failure = target.failure.error;
+        target.instance.rerender(null);
+        if (failure !== NO_FAILURE)
+            throw failure;
+        if (frame === null)
+            throw new Error('offscreen Ink instance produced no frame');
+        return capRows(trimTrailingBlank(frame.split('\n')));
+    };
+    const failureRow = (label) => {
+        failures += 1;
+        return [`[aragon] ${label} could not be rendered`];
+    };
+    return {
+        renderEntry(entry, prev, cols, expanded = false) {
+            try {
+                return renderNode(_jsx(EntryView, { entry: entry, prev: prev, expanded: expanded, thinkingVisible: options.thinkingVisible, reducedMotion: options.reducedMotion, density: options.density, theme: options.theme, caps: options.caps }), cols);
+            }
+            catch (error) {
+                getLogger().warn('cli', 'entry_render_failed', {
+                    id: entry.id, kind: entry.kind, error: String(error),
+                });
+                return failureRow(`entry ${entry.id} (${entry.kind})`);
+            }
+        },
+        renderNode(node, cols) {
+            try {
+                return renderNode(node, cols);
+            }
+            catch (error) {
+                getLogger().warn('cli', 'node_render_failed', { error: String(error) });
+                return failureRow('startup banner');
+            }
+        },
+        setOptions(partial) {
+            options = { ...options, ...partial };
+        },
+        stats: () => ({ elidedRows, failures }),
+        dispose,
+    };
+}

package/dist/ui/scrollback/scrollback-writer.d.ts

@@ -0,0 +1,74 @@
+/**
+ * ScrollbackWriter — the byte contract of native-scroll mode
+ * (tui-native-terminal-scroll §4.3).
+ *
+ * It implements `FrameDiffer`, so `stdout-frame-writer.ts::wrapStdoutForFrames`
+ * binds it to a real stream exactly as it binds the full-screen differ. What it
+ * does differently: the screen is NOT the app's. Settled conversation rows are
+ * printed into the host terminal's own scrollback, and Ink's frame is only a small
+ * LIVE REGION parked directly under the last printed row.
+ *
+ * GEOMETRY IS RELATIVE (D2). A batch is `CUU(H0)` to the top of the previous
+ * region, erase down, print static rows, print the new region, park one row below
+ * it. Nothing in that sequence depends on the terminal's absolute row count, so a
+ * terminal that scrolls underneath it cannot misplace anything.
+ *
+ * THE INVARIANTS THAT FAIL SILENTLY IF DROPPED:
+ *  - I-S4 · every batch parks the cursor at (regionBottom + 1, column 0), the same
+ *    place Ink's `previousLineCount = H + 1` expects, so falling back to a raw Ink
+ *    write is still correct.
+ *  - I-S8 · geometry in doubt (foreign write, unparseable chunk) => `prev = null`
+ *    => next batch is a SEED. Never keep erasing on a stale `H0`.
+ *  - I-S14 · after `finalize` EVERY Ink write is swallowed. Ink's unmount renders
+ *    once more (and a 32 ms trailing throttle call can follow); passed through,
+ *    its `eraseLines(H + 1)` would erase the summary and the end of the
+ *    conversation. With an unknown or sub-2-row terminal the frame is still
+ *    parsed so `prev`/`H0` track Ink's own `previousLineCount`.
+ *  - I-S13 · no emitted row is wider than `cols - 1` (clipped, counted).
+ */
+import type { FrameDiffer } from '../frame-differ.js';
+import type { ScrollbackDrain } from './drain.js';
+export interface ScrollbackWriterOptions {
+    rows: () => number | undefined;
+    cols: () => number | undefined;
+    /** DEC 2026 envelope around each batch. */
+    sync: boolean;
+    /** `diffRender: false` — every batch rewrites the whole region. */
+    fullEveryFrame: boolean;
+    drain: ScrollbackDrain;
+    /** Raised once on the first foreign / unparseable write. */
+    onFirstFallback?: () => void;
+    /** Raised when out-of-resize tall frames repeat; the App degrades to a placeholder. */
+    onGuardTrip?: () => void;
+    /**
+     * Ask the host to call `repaint()` soon (coalesced here). Used when static rows
+     * arrive without a new Ink frame, and to flush the rest of an oversized feed.
+     */
+    requestRepaint?: () => void;
+    /** Injected clock for the resize grace window. */
+    now?: () => number;
+}
+export interface ScrollbackWriterStats {
+    framesSeed: number;
+    framesDiff: number;
+    framesFull: number;
+    staticRowsWritten: number;
+    bytesWritten: number;
+    fallbacks: number;
+    /** Tall frames swallowed (the scrollback-erasing `ESC[3J` path), resize or not. */
+    guardHits: number;
+    /** The subset NOT explained by a recent resize: the real defect signal. */
+    guardHitsOutsideResize: number;
+    clippedRows: number;
+    elidedEntries: number;
+    resizes: number;
+    repaints: number;
+}
+export interface ScrollbackWriter extends FrameDiffer {
+    /** Idempotent. Returns the exit bytes; afterwards every Ink write is swallowed. */
+    finalize(summary: readonly string[]): string;
+    /** Rows of the live region as last parked. */
+    regionRows(): number;
+    scrollbackStats(): ScrollbackWriterStats;
+}
+export declare function createScrollbackWriter(o: ScrollbackWriterOptions): ScrollbackWriter;