@north-light/crouter 0.3.170 → 0.3.172

package/dist/clients/attach/render/scroll-animation.js

@@ -0,0 +1,80 @@
+// render/scroll-animation.ts — smooth keyboard scrolling for the transcript.
+//
+// A scroll step follows a short ease-out trajectory rather than teleporting.
+// Each timer opportunity resolves its position from elapsed time, so a delayed
+// render skips stale deltas and still lands at the intended position on time.
+// Repeated presses fold the untravelled distance into a fresh trajectory rather
+// than building a lagging queue.
+import { performance } from 'node:perf_hooks';
+/** Duration of the full ease-out trajectory, including the synchronous start. */
+const BURST_MS = 100;
+/** Leave enough time between visible positions for the terminal to present them. */
+const FRAME_MS = 25;
+/** Fraction of the viewport each press travels — a half page keeps context in view. */
+const PAGE_FRACTION = 0.5;
+/** Start partway through the trajectory so the keypress moves synchronously. */
+const INITIAL_PROGRESS = 0.15;
+function easeOut(t) {
+    return 1 - (1 - t) * (1 - t);
+}
+export function createScrollAnimator(viewport, requestRender) {
+    let timer;
+    let startedAt = 0;
+    let target = 0;
+    let travelled = 0;
+    const stop = () => {
+        if (timer !== undefined)
+            clearTimeout(timer);
+        timer = undefined;
+        target = 0;
+        travelled = 0;
+    };
+    const schedule = (now) => {
+        const remaining = Math.max(0, startedAt + BURST_MS - now);
+        timer = setTimeout(() => {
+            timer = undefined;
+            advance(performance.now(), true);
+        }, Math.min(FRAME_MS, remaining));
+    };
+    const advance = (now, scheduleNext) => {
+        const progress = Math.min(1, (now - startedAt) / BURST_MS);
+        const position = Math.round(target * easeOut(progress));
+        const step = position - travelled;
+        if (step !== 0) {
+            // A clamped scroll (already at an end of the transcript) reports no state
+            // change — no later point on this trajectory can help, so stop early.
+            if (!viewport.scrollBy(step))
+                return stop();
+            travelled = position;
+            requestRender();
+        }
+        if (progress === 1)
+            return stop();
+        if (scheduleNext)
+            schedule(now);
+    };
+    return {
+        page(direction) {
+            const now = performance.now();
+            if (timer !== undefined) {
+                clearTimeout(timer);
+                timer = undefined;
+                // Bring the old trajectory to its current time before carrying only its
+                // untravelled distance into this newly pressed page.
+                advance(now, false);
+            }
+            const pending = target - travelled;
+            const step = Math.max(1, Math.round(viewport.pageRows() * PAGE_FRACTION));
+            const delta = (direction === 'up' ? -1 : 1) * step;
+            target = pending + delta;
+            travelled = 0;
+            if (target === 0)
+                return stop();
+            // The first position is immediately visible to input handling, while its
+            // virtual start keeps every later position on one time-based curve.
+            startedAt = now - BURST_MS * INITIAL_PROGRESS;
+            advance(now, true);
+        },
+        cancel: stop,
+    };
+}

package/dist/clients/attach/render/tool-calls.js

@@ -55,11 +55,11 @@ function lineChangesDisplay(changes, theme) {
         counts.push(theme.fg('toolDiffRemoved', `-${changes.removed}`));
     return counts.length > 0 ? ` ${counts.join(' ')}` : '';
 }
-/** A write has no before/after diff, so report its output size neutrally. */
+/** A write has no before/after diff, so report every output line as added. */
 function lineCountDisplay(lines, theme) {
     if (lines === undefined)
         return '';
-    return ` ${theme.fg('muted', `${lines} ${lines === 1 ? 'line' : 'lines'}`)}`;
+    return ` ${theme.fg('toolDiffAdded', `+${lines}`)}`;
 }
 /** The one-line folded form of a file tool's call: `<icon> <label> <path>`,
  *  optionally followed by its green/red changed-line counts. */
@@ -72,15 +72,15 @@ function shortenPath(path) {
     const home = homedir();
     return path.startsWith(home) ? `~${path.slice(home.length)}` : path;
 }
-/** Accent-colored, OSC-8-linked path — the same affordance pi gives file tools. */
+/** Plain, OSC-8-linked path — the same affordance pi gives file tools. */
 function pathDisplay(rawPath, theme, cwd) {
     if (!rawPath)
         return theme.fg('toolOutput', '...');
-    const styled = theme.fg('accent', shortenPath(rawPath));
+    const path = shortenPath(rawPath);
     if (!getCapabilities().hyperlinks)
-        return styled;
+        return path;
     const absolute = isAbsolute(rawPath) ? rawPath : resolve(cwd, rawPath);
-    return hyperlink(styled, pathToFileURL(absolute).href);
+    return hyperlink(path, pathToFileURL(absolute).href);
 }
 /** `<icon> <label>` — the glyph in accent, the tool name in pi's tool title style. */
 function header(icon, label, theme) {

package/dist/clients/attach/render/transcript-copy.d.ts

@@ -0,0 +1,9 @@
+import type { ChatView } from './chat-view.js';
+import type { ViewportSource } from './measured-container.js';
+import type { TranscriptViewport } from './viewport.js';
+export type CopyTarget = 'message' | 'last-assistant' | 'tool' | 'transcript';
+export interface TranscriptCopy {
+    /** Copy `target`; returns the status-region confirmation to show. */
+    copy(target: CopyTarget): string;
+}
+export declare function createTranscriptCopy(chat: ChatView, viewport: TranscriptViewport, source: ViewportSource): TranscriptCopy;

package/dist/clients/attach/render/transcript-copy.js

@@ -0,0 +1,81 @@
+import { writeClipboardTextEverywhere } from '../../../core/clipboard-text.js';
+function hasText(text) {
+    return text !== undefined && text.trim() !== '';
+}
+function lineCount(text) {
+    return text.split('\n').length;
+}
+function copiedTo(system, tmux) {
+    if (system && tmux)
+        return 'clipboard + tmux buffer';
+    if (system)
+        return 'clipboard';
+    if (tmux)
+        return 'tmux buffer';
+    return undefined;
+}
+/** Resolves the newest copyable block wholly visible before falling back to one
+ * merely intersecting the current viewport. */
+function visibleMessageText(chat, viewport, source) {
+    const { first, last, lastFullyVisible } = viewport.visibleBlocks();
+    const textAt = (index) => {
+        const block = source.blockAt(index);
+        return block ? chat.blockText(block) : undefined;
+    };
+    for (let index = Math.min(last, lastFullyVisible); index >= first; index--) {
+        const text = textAt(index);
+        if (hasText(text))
+            return text;
+    }
+    for (let index = last; index >= first; index--) {
+        const text = textAt(index);
+        if (hasText(text))
+            return text;
+    }
+    return undefined;
+}
+export function createTranscriptCopy(chat, viewport, source) {
+    return {
+        copy(target) {
+            let resolved;
+            let emptyNotice;
+            switch (target) {
+                case 'message': {
+                    const text = visibleMessageText(chat, viewport, source);
+                    if (hasText(text))
+                        resolved = { text, label: 'message' };
+                    emptyNotice = 'Nothing to copy — no visible message';
+                    break;
+                }
+                case 'last-assistant': {
+                    const text = chat.getLastAssistantText();
+                    if (hasText(text))
+                        resolved = { text, label: 'last assistant message' };
+                    emptyNotice = 'Nothing to copy — no assistant message yet';
+                    break;
+                }
+                case 'tool': {
+                    const text = chat.getLastToolOutputText();
+                    if (hasText(text))
+                        resolved = { text, label: 'tool output' };
+                    emptyNotice = 'Nothing to copy — no tool output yet';
+                    break;
+                }
+                case 'transcript': {
+                    const text = chat.getTranscriptPlainText();
+                    if (hasText(text))
+                        resolved = { text, label: 'transcript' };
+                    emptyNotice = 'Nothing to copy — transcript is empty';
+                    break;
+                }
+            }
+            if (!resolved)
+                return emptyNotice;
+            const { system, tmux } = writeClipboardTextEverywhere(resolved.text);
+            const destination = copiedTo(system, tmux);
+            if (!destination)
+                return 'Copy failed — no clipboard tool found';
+            return `Copied ${resolved.label} (${lineCount(resolved.text)} lines) — ${destination}`;
+        },
+    };
+}

package/dist/clients/attach/render/viewport.d.ts

@@ -0,0 +1,29 @@
+import type { ViewportSource } from './measured-container.js';
+/** The flat block range occupied by the most recently rendered viewport. */
+type VisibleBlocks = {
+    first: number;
+    last: number;
+    lastFullyVisible: number;
+};
+/**
+ * A virtualized, identity-anchored transcript viewport. It owns only scroll
+ * state; all measurement and line caching remain with its ViewportSource.
+ */
+export interface TranscriptViewport {
+    /** Exactly `rows` lines, bottom-aligned and top-padded with empty rows. */
+    renderSlice(width: number, rows: number): string[];
+    /** Scroll by `lines` (negative = toward older content). */
+    scrollBy(lines: number): boolean;
+    /** Lines in one page jump — the viewport height less one overlap row. */
+    pageRows(): number;
+    /** Pin back to the live bottom. */
+    goLive(): void;
+    /** True while the viewport is pinned to the bottom. */
+    isLive(): boolean;
+    /** Flat blocks intersecting the visible slice and its last whole block. */
+    visibleBlocks(): VisibleBlocks;
+    /** Forward frame invalidation without exposing the source to the frame. */
+    invalidate(): void;
+}
+export declare function createTranscriptViewport(source: ViewportSource): TranscriptViewport;
+export {};

package/dist/clients/attach/render/viewport.js

@@ -0,0 +1,159 @@
+/** Exactly one line retained for each clipped row of an inline-image block. */
+const CLIPPED_IMAGE_ROW = '\x1b[2m⌸ image — scroll to view\x1b[22m';
+const NO_VISIBLE_BLOCKS = { first: -1, last: -1, lastFullyVisible: -1 };
+function isInlineImageBlock(lines) {
+    return lines.some((line) => line.includes('\x1b_G') || line.includes('\x1b]1337;File='));
+}
+/** The first block whose rendered range extends beyond `line`. */
+function firstBlockAfter(source, line, width) {
+    let low = 0;
+    let high = source.blockCount();
+    while (low < high) {
+        const middle = Math.floor((low + high) / 2);
+        const end = source.blockStart(middle, width) + source.blockHeight(middle, width);
+        if (end > line)
+            high = middle;
+        else
+            low = middle + 1;
+    }
+    return low;
+}
+export function createTranscriptViewport(source) {
+    const state = { follow: true, anchor: undefined };
+    let lastWidth;
+    let lastRows = 0;
+    let cachedVisibleBlocks = NO_VISIBLE_BLOCKS;
+    let cachedVisibleRevision;
+    /** Resolve the identity anchor only against the source's current measurements. */
+    function resolveTop(width, rows, total) {
+        const bottom = Math.max(0, total - rows);
+        if (state.follow)
+            return bottom;
+        if (!state.anchor) {
+            state.follow = true;
+            return bottom;
+        }
+        const anchoredTop = source.anchorLine(state.anchor, width);
+        if (anchoredTop === undefined) {
+            state.follow = true;
+            state.anchor = undefined;
+            return bottom;
+        }
+        return Math.min(Math.max(0, anchoredTop), bottom);
+    }
+    function visibleRange(width, rows, total, top) {
+        const bottom = Math.min(total, top + rows);
+        if (top >= bottom)
+            return { top, bottom, total, blocks: NO_VISIBLE_BLOCKS };
+        const count = source.blockCount();
+        let index = firstBlockAfter(source, top, width);
+        let first = -1;
+        let last = -1;
+        let lastFullyVisible = -1;
+        while (index < count) {
+            const start = source.blockStart(index, width);
+            if (start >= bottom)
+                break;
+            const height = source.blockHeight(index, width);
+            const end = start + height;
+            if (end > top) {
+                if (first === -1)
+                    first = index;
+                last = index;
+                if (start >= top && end <= bottom)
+                    lastFullyVisible = index;
+            }
+            index++;
+        }
+        return { top, bottom, total, blocks: first === -1 ? NO_VISIBLE_BLOCKS : { first, last, lastFullyVisible } };
+    }
+    function currentSlice() {
+        if (lastWidth === undefined || lastRows <= 0)
+            return undefined;
+        const total = source.totalHeight(lastWidth);
+        const top = resolveTop(lastWidth, lastRows, total);
+        return visibleRange(lastWidth, lastRows, total, top);
+    }
+    return {
+        renderSlice(width, rows) {
+            const viewportRows = Math.max(0, rows);
+            lastWidth = width;
+            lastRows = viewportRows;
+            if (viewportRows === 0) {
+                cachedVisibleBlocks = NO_VISIBLE_BLOCKS;
+                cachedVisibleRevision = source.revision();
+                return [];
+            }
+            const total = source.totalHeight(width);
+            const top = resolveTop(width, viewportRows, total);
+            const slice = visibleRange(width, viewportRows, total, top);
+            const content = [];
+            for (let index = slice.blocks.first; index !== -1 && index <= slice.blocks.last; index++) {
+                const start = source.blockStart(index, width);
+                const lines = source.blockLines(index, width);
+                const height = source.blockHeight(index, width);
+                const end = start + height;
+                const visibleStart = Math.max(0, slice.top - start);
+                const visibleEnd = Math.min(height, slice.bottom - start);
+                if (visibleStart >= visibleEnd)
+                    continue;
+                const partiallyClipped = start < slice.top || end > slice.bottom;
+                if (partiallyClipped && isInlineImageBlock(lines)) {
+                    content.push(...Array(visibleEnd - visibleStart).fill(CLIPPED_IMAGE_ROW));
+                }
+                else {
+                    content.push(...lines.slice(visibleStart, visibleEnd));
+                }
+            }
+            const padded = content.length >= viewportRows
+                ? content.slice(0, viewportRows)
+                : [...Array(viewportRows - content.length).fill(''), ...content];
+            cachedVisibleBlocks = slice.blocks;
+            cachedVisibleRevision = source.revision();
+            return padded;
+        },
+        scrollBy(lines) {
+            if (lastWidth === undefined || lastRows <= 0 || lines === 0)
+                return false;
+            const beforeFollow = state.follow;
+            const beforeAnchor = state.anchor;
+            const total = source.totalHeight(lastWidth);
+            const currentTop = resolveTop(lastWidth, lastRows, total);
+            const bottom = Math.max(0, total - lastRows);
+            const newTop = Math.min(Math.max(0, currentTop + lines), bottom);
+            if (newTop >= bottom) {
+                state.follow = true;
+                state.anchor = undefined;
+            }
+            else {
+                state.follow = false;
+                state.anchor = source.anchorAt(newTop, lastWidth);
+                if (!state.anchor)
+                    state.follow = true;
+            }
+            return state.follow !== beforeFollow || state.anchor !== beforeAnchor;
+        },
+        pageRows() {
+            return Math.max(0, lastRows - 1);
+        },
+        goLive() {
+            state.follow = true;
+            state.anchor = undefined;
+        },
+        isLive() {
+            return state.follow;
+        },
+        visibleBlocks() {
+            const revision = source.revision();
+            if (cachedVisibleRevision === revision)
+                return cachedVisibleBlocks;
+            const slice = currentSlice();
+            cachedVisibleBlocks = slice?.blocks ?? NO_VISIBLE_BLOCKS;
+            cachedVisibleRevision = revision;
+            return cachedVisibleBlocks;
+        },
+        invalidate() {
+            source.invalidate();
+        },
+    };
+}

package/dist/clients/attach/session/bindings.d.ts

@@ -1,14 +1,17 @@
-import { type AttachBindingId, type BindingId, type BindingResolution } from '../../../core/keybindings/index.js';
+import { type AttachBindingId, type BindingId, type BindingResolution, type UserKeybindingSettings } from '../../../core/keybindings/index.js';
 export type { AttachBindingId } from '../../../core/keybindings/index.js';
 export type AttachBindings = BindingResolution<BindingId>;
 export type AttachActions = Record<AttachBindingId, () => void>;
+export declare const ATTACH_VIEWPORT_BINDINGS: readonly ["crtr.attach.scroll.up", "crtr.attach.scroll.down", "crtr.attach.scroll.page-up", "crtr.attach.scroll.page-down", "crtr.attach.scroll.live", "crtr.attach.mouse.toggle", "crtr.attach.copy.message"];
+export type AttachViewportBindingId = typeof ATTACH_VIEWPORT_BINDINGS[number];
+export type AttachViewportActions = Record<AttachViewportBindingId, () => void>;
 export { inboxOpenHint } from '../../../core/keybindings/index.js';
-export declare function matchesAttachBinding(bindings: AttachBindings, id: AttachBindingId, data: string): boolean;
+export declare function matchesAttachBinding(bindings: AttachBindings, id: BindingId, data: string): boolean;
 export declare function dispatchAttachAction(id: AttachBindingId, actions: AttachActions): void;
 export declare function dispatchAttachBinding(bindings: AttachBindings, data: string, actions: AttachActions): boolean;
+export declare function dispatchAttachViewportBinding(bindings: AttachBindings, data: string, actions: AttachViewportActions): boolean;
 export declare function detachHint(bindings: AttachBindings): string | undefined;
-/** Re-resolve the user's binding catalog and republish it to every consumer:
- *  the graph overlay's own snapshot and (in tmux) the crouter-owned tmux
- *  bindings. Binding diagnostics must never fail an attach, so an install error
- *  is swallowed. */
-export declare function refreshAttachBindingSnapshot(resolve: () => AttachBindings, setGraphBindings: (bindings: AttachBindings) => void, inTmuxNow: () => boolean, install: (bindings: AttachBindings) => void): AttachBindings;
+/** Re-resolve the user's binding settings once and republish the same snapshot
+ *  to every consumer: attach dispatch, the graph overlay, and tmux. Binding
+ *  diagnostics must never fail an attach, so an install error is swallowed. */
+export declare function refreshAttachBindingSnapshot(resolve: () => UserKeybindingSettings, setGraphBindings: (bindings: AttachBindings) => void, inTmuxNow: () => boolean, install: (bindings: AttachBindings, tmuxPassthrough: readonly BindingId[]) => void): UserKeybindingSettings;

package/dist/clients/attach/session/bindings.js

@@ -6,6 +6,13 @@
 // literals, so a user's rebind is honored by the viewer and tmux alike.
 import { matchesKey } from '@earendil-works/pi-tui';
 import { ATTACH_CONTROL_BINDINGS, formatBinding, matchesPiTuiInput, } from '../../../core/keybindings/index.js';
+export const ATTACH_VIEWPORT_BINDINGS = [
+    'crtr.attach.scroll.up', 'crtr.attach.scroll.down',
+    'crtr.attach.scroll.page-up', 'crtr.attach.scroll.page-down',
+    'crtr.attach.scroll.live',
+    'crtr.attach.mouse.toggle',
+    'crtr.attach.copy.message',
+];
 export { inboxOpenHint } from '../../../core/keybindings/index.js';
 export function matchesAttachBinding(bindings, id, data) {
     return matchesPiTuiInput(bindings, id, data, (input, gesture) => matchesKey(input, gesture));
@@ -22,6 +29,15 @@ export function dispatchAttachBinding(bindings, data, actions) {
     }
     return false;
 }
+export function dispatchAttachViewportBinding(bindings, data, actions) {
+    for (const actionId of ATTACH_VIEWPORT_BINDINGS) {
+        if (matchesAttachBinding(bindings, actionId, data)) {
+            actions[actionId]();
+            return true;
+        }
+    }
+    return false;
+}
 export function detachHint(bindings) {
     for (const id of ['crtr.attach.clear-or-detach', 'crtr.attach.detach']) {
         if (bindings.gestures(id).length > 0)
@@ -29,18 +45,17 @@ export function detachHint(bindings) {
     }
     return undefined;
 }
-/** Re-resolve the user's binding catalog and republish it to every consumer:
- *  the graph overlay's own snapshot and (in tmux) the crouter-owned tmux
- *  bindings. Binding diagnostics must never fail an attach, so an install error
- *  is swallowed. */
+/** Re-resolve the user's binding settings once and republish the same snapshot
+ *  to every consumer: attach dispatch, the graph overlay, and tmux. Binding
+ *  diagnostics must never fail an attach, so an install error is swallowed. */
 export function refreshAttachBindingSnapshot(resolve, setGraphBindings, inTmuxNow, install) {
-    const bindings = resolve();
-    setGraphBindings(bindings);
+    const settings = resolve();
+    setGraphBindings(settings.bindings);
     if (inTmuxNow()) {
         try {
-            install(bindings);
+            install(settings.bindings, settings.tmuxPassthrough);
         }
         catch { /* attaching must not fail on binding diagnostics */ }
     }
-    return bindings;
+    return settings;
 }

package/dist/clients/attach/session/connection.js

@@ -10,7 +10,7 @@
 import { createConnection } from 'node:net';
 import { viewSocketPath } from '../../../core/canvas/paths.js';
 import { BrokerClient, BrokerUnavailableError, RelayTransport } from '../../../core/broker-client/index.js';
-import { resolveRemoteCanvasTarget } from '../../../core/view/remote-canvas-target.js';
+import { resolveRemoteCanvasTarget } from '../../../core/remote-canvas-target.js';
 import { ApiCanvasSource, cliCanvasSource, cliClient, rethrowAsCliError } from '../../../commands/api-client.js';
 import { InputError } from '../../../core/io.js';
 /** The hello handshake's initial role. A REMOTE attach (`--canvas`) is a
@@ -68,10 +68,9 @@ export async function connectToNode(nodeId, canvasName) {
     // not-found guard is wrong for `--canvas`. Build a minimal local `meta`
     // stand-in instead: `meta.cwd` is a legitimately viewer-local concern
     // (theming, this pane's own git status) — not a remote-node concern — so
-    // pointing it at the CLI's own cwd is correct, not a hack. The mode-switch
-    // file and the `getRow`-based reconnect give-up are the other local-canvas
-    // dependencies `--canvas` must skip; both gate on `remote` at their own use
-    // sites, not here.
+    // pointing it at the CLI's own cwd is correct, not a hack. The `getRow`-based
+    // reconnect give-up is the other local-canvas dependency `--canvas` must skip;
+    // it gates on `remote` at its own use site, not here.
     let meta;
     let nodeIdentity;
     let transport;

package/dist/clients/attach/session/context.d.ts

@@ -5,15 +5,17 @@ import type { NodeMeta } from '../../../core/canvas/types.js';
 import type { BrokerClient } from '../../../core/broker-client/index.js';
 import type { AttachPalette } from '../config.js';
 import type { TitledEditor } from '../input/titled-editor.js';
-/** The bottom-anchored chrome stack plus the scrolling chat, in render order.
+/** The pinned cockpit plus transcript/header regions, in frame render order.
  *  Owned by the layout step; every painter writes into exactly one of these. */
 export interface AttachContainers {
-    /** Scrolling transcript — the only container above the chat/chrome divider. */
+    /** Scrolling transcript source, rendered by the virtualized viewport. */
     readonly chat: Container;
-    /** The themed divider itself (suppressed while the recap widget is present). */
-    readonly chrome: Container;
+    /** Pinned recap above the transcript; empty when no recap widget exists. */
+    readonly header: Container;
     /** Extension widgets placed `aboveEditor`, including the inactivity brief. */
     readonly aboveWidgets: Container;
+    /** Live activity loader, fixed at the top of the bottom region. */
+    readonly activity: Container;
     /** Relationship roster / wait rows, below the editor. */
     readonly reports: Container;
     /** Pending steering messages, above the editor. */

package/dist/clients/attach/session/frame.d.ts

@@ -0,0 +1,34 @@
+import { type Component, type Terminal } from '@earendil-works/pi-tui';
+import type { TranscriptViewport } from '../render/viewport.js';
+export declare const MIN_TRANSCRIPT_ROWS = 3;
+export declare const HEADER_MAX_ROWS = 12;
+export declare const EDITOR_MIN_ROWS = 1;
+export declare const STATUS_ROWS = 1;
+export type BottomSlot = 'queued' | 'aboveWidgets' | 'activity' | 'cockpitPadding' | 'editor' | 'pickerPanel' | 'belowWidgets' | 'reports' | 'footer';
+/** Crop `lines` to `alloc` rows, guaranteeing the CURSOR_MARKER row survives
+ * (§2.1). No marker → the tail is kept. */
+export declare function cropAroundCursor(lines: readonly string[], alloc: number): string[];
+export interface ViewerFrameParts {
+    /** Rendered above the transcript; 0 rows when empty. */
+    header: Component;
+    viewport: TranscriptViewport;
+    /** The bottom slots, in VISUAL order, tagged with their allocation identity
+     * so the allocator can apply the §2.1 priority table. */
+    bottom: readonly {
+        slot: BottomSlot;
+        component: Component;
+    }[];
+}
+/** The TUI's ONE child. Renders exactly `terminal.rows` lines, every frame. */
+export declare class ViewerFrame implements Component {
+    private readonly terminal;
+    private readonly parts;
+    private viewportRows;
+    constructor(terminal: Terminal, parts: ViewerFrameParts);
+    render(width: number): string[];
+    invalidate(): void;
+    /** Rows the transcript viewport got in the last frame — the page size. */
+    lastViewportRows(): number;
+    /** Retain exactly one editor marker if the focused editor rendered one. */
+    private ensureCursorMarker;
+}