@timurproko/a1 0.1.8-dev.136 → 0.1.8-dev.139

package/dist/ui/components/scrollbar.d.ts

@@ -19,6 +19,30 @@ export interface ScrollbarInput {
     readonly scroll: number;
     readonly trackHeight: number;
 }
+export type ScrollbarAppearance = "always" | "hover" | "hidden";
+export type ScrollbarStyle = "thin" | "thick";
+export type ScrollbarSpeed = "normal" | "fast" | "high";
+/** Wheel distance: normal (3), fast (6), high as normal + fast (9). */
+export declare function scrollbarWheelRows(speed: ScrollbarSpeed): number;
+/** Selection edge distance at each fixed 30ms tick. */
+export declare function scrollbarSelectionRows(speed: ScrollbarSpeed): number;
+export interface ScrollbarPresentationInput {
+    readonly geometry: ScrollbarGeometry | null;
+    readonly appearance: ScrollbarAppearance;
+    readonly style: ScrollbarStyle;
+    readonly hovered: boolean;
+    readonly dragging: boolean;
+    readonly activeUntil: number;
+    readonly now: number;
+}
+export interface ScrollbarPresentation {
+    readonly visible: boolean;
+    readonly reservesSpace: boolean;
+    readonly trackGlyph: "│" | "┃";
+    readonly thumbGlyph: "│" | "┃";
+}
+/** Pure appearance decision; activity time is supplied so tests own the clock. */
+export declare function scrollbarPresentation(input: ScrollbarPresentationInput): ScrollbarPresentation;
 /** Null when the content fits: no scrollbar is drawn and no width is reserved. */
 export declare function scrollbarGeometry(input: ScrollbarInput): ScrollbarGeometry | null;
 export declare function scrollbarReservesSpace(geometry: ScrollbarGeometry | null): boolean;
@@ -48,6 +72,8 @@ export interface RailPointer {
  */
 export declare class ScrollbarRails {
     #private;
+    noteActivity(key: string, now: number, lingerMs?: number): void;
+    isRecentlyActive(key: string, now: number): boolean;
     isHovered(key: string): boolean;
     isDragging(key: string): boolean;
     get draggingKey(): string | null;

package/dist/ui/components/scrollbar.js

@@ -3,6 +3,33 @@
  * rail rather than to a global, because two scrollable surfaces can be visible
  * at once and a shared flag lights up the wrong one.
  */
+/** Wheel distance: normal (3), fast (6), high as normal + fast (9). */
+export function scrollbarWheelRows(speed) {
+    return speed === "high" ? 9 : speed === "fast" ? 6 : 3;
+}
+/** Selection edge distance at each fixed 30ms tick. */
+export function scrollbarSelectionRows(speed) {
+    return speed === "high" ? 3 : speed === "fast" ? 2 : 1;
+}
+/** Pure appearance decision; activity time is supplied so tests own the clock. */
+export function scrollbarPresentation(input) {
+    const overflowing = input.geometry !== null;
+    // As in v2, always/hover reserve the final rail cell even while content fits.
+    // The blank gutter prevents prompt timestamps from touching the terminal edge
+    // and keeps later scrollbar appearance from reflowing the transcript.
+    const reservesSpace = input.appearance !== "hidden";
+    const visible = overflowing && reservesSpace && (input.appearance === "always"
+        || input.hovered
+        || input.dragging
+        || (input.activeUntil > 0 && input.now <= input.activeUntil));
+    const thick = input.style === "thick";
+    return {
+        visible,
+        reservesSpace,
+        trackGlyph: thick ? "┃" : "│",
+        thumbGlyph: thick || input.hovered || input.dragging ? "┃" : "│",
+    };
+}
 /** Null when the content fits: no scrollbar is drawn and no width is reserved. */
 export function scrollbarGeometry(input) {
     const { contentLength, viewportHeight, trackHeight } = input;
@@ -51,7 +78,14 @@ export function scrollForTrackPage(geometry, trackRow, scroll, viewportHeight) {
  */
 export class ScrollbarRails {
     #hovered = new Set();
+    #activeUntil = new Map();
     #dragging;
+    noteActivity(key, now, lingerMs = 900) {
+        this.#activeUntil.set(key, Math.max(this.#activeUntil.get(key) ?? 0, now + Math.max(0, lingerMs)));
+    }
+    isRecentlyActive(key, now) {
+        return now <= (this.#activeUntil.get(key) ?? 0);
+    }
     isHovered(key) {
         return this.#hovered.has(key);
     }
@@ -97,6 +131,7 @@ export class ScrollbarRails {
     }
     clear() {
         this.#hovered.clear();
+        this.#activeUntil.clear();
         this.#dragging = undefined;
     }
 }

package/dist/ui/components/spans.d.ts

@@ -5,3 +5,9 @@
  * replaced by spaces rather than split.
  */
 export declare function overlaySpan(line: string, from: number, to: number, span: string): string;
+/**
+ * Paints only a background over [from,to), preserving every glyph and its
+ * foreground, bold, underline, and hyperlink styling. Embedded resets reapply
+ * the selection background, while leaving the span restores the row's styles.
+ */
+export declare function backgroundSgrSpan(line: string, from: number, to: number, on?: string, off?: string): string;

package/dist/ui/components/spans.js

@@ -9,6 +9,7 @@ const ANSI_SEQUENCE = "\\u001b(?:\\[[0-?]*[ -/]*[@-~]|[\\]_][^\\u0007\\u001b]*(?
 const ANSI_SPLIT = new RegExp(`(${ANSI_SEQUENCE})`);
 const HYPERLINK = /^\]8;;([^]*)(?:|\\)?$/;
 const HYPERLINK_OFF = "]8;;\\";
+const SGR = /^\[[0-9;]*m$/;
 const GRAPHEMES = new Intl.Segmenter(undefined, { granularity: "grapheme" });
 /**
  * Replaces the visible columns `[from, to)` of `line` with `span`, preserving
@@ -57,3 +58,38 @@ export function overlaySpan(line, from, to, span) {
         head += " ".repeat(from - column);
     return head + (hyperlinkOpen ? HYPERLINK_OFF : "") + span + replay + tail;
 }
+/**
+ * Paints only a background over [from,to), preserving every glyph and its
+ * foreground, bold, underline, and hyperlink styling. Embedded resets reapply
+ * the selection background, while leaving the span restores the row's styles.
+ */
+export function backgroundSgrSpan(line, from, to, on = "\u001b[47m", off = "\u001b[49m") {
+    let output = "";
+    let seen = "";
+    let column = 0;
+    let inside = false;
+    for (const token of line.split(ANSI_SPLIT)) {
+        if (!token)
+            continue;
+        if (token.startsWith("\u001b")) {
+            output += token;
+            if (SGR.test(token))
+                seen += token;
+            if (inside)
+                output += on;
+            continue;
+        }
+        for (const { segment } of GRAPHEMES.segment(token)) {
+            const shouldBeInside = column >= from && column < to;
+            if (shouldBeInside !== inside) {
+                output += shouldBeInside ? on : off + seen;
+                inside = shouldBeInside;
+            }
+            output += segment;
+            column += displayWidth(segment);
+        }
+    }
+    if (inside)
+        output += off;
+    return output;
+}

package/dist/ui/components/submitted-prompt.d.ts

@@ -0,0 +1,23 @@
+/** Visible width of the submitted-prompt prefix (`❯ `). */
+export declare const SUBMITTED_PROMPT_PREFIX_WIDTH = 2;
+export interface SubmittedPromptStyle {
+    readonly prefix?: (text: string) => string;
+    readonly timestamp?: (text: string) => string;
+}
+export interface SubmittedPromptLayout {
+    readonly contentWidth: number;
+    readonly timestamp: string | null;
+}
+/** Formats transcript metadata, never render time, as local 24-hour HH:mm. */
+export declare function formatSubmittedPromptTime(source: Date | number): string | null;
+/**
+ * Computes the width at which the prompt's Markdown body must be rendered.
+ * The timestamp is omitted rather than allowing it to crowd useful content.
+ */
+export declare function submittedPromptLayout(width: number, source?: Date | number | null): SubmittedPromptLayout;
+/**
+ * Composes already-rendered prompt content into the compact submitted bar.
+ * Continuations align below the content, not below the prefix, and no row can
+ * exceed the supplied terminal width even when the content renderer misbehaves.
+ */
+export declare function composeSubmittedPromptRows(contentRows: readonly string[], width: number, source?: Date | number | null, style?: SubmittedPromptStyle): readonly string[];

package/dist/ui/components/submitted-prompt.js

@@ -0,0 +1,50 @@
+import { displayWidth, truncateToWidth } from "./text.js";
+/** Visible width of the submitted-prompt prefix (`❯ `). */
+export const SUBMITTED_PROMPT_PREFIX_WIDTH = 2;
+const TIMESTAMP_MARGIN = 3;
+const MIN_USEFUL_CONTENT_WIDTH = 8;
+/** Formats transcript metadata, never render time, as local 24-hour HH:mm. */
+export function formatSubmittedPromptTime(source) {
+    const date = source instanceof Date ? source : new Date(source);
+    if (!Number.isFinite(date.getTime()))
+        return null;
+    return `${String(date.getHours()).padStart(2, "0")}:${String(date.getMinutes()).padStart(2, "0")}`;
+}
+/**
+ * Computes the width at which the prompt's Markdown body must be rendered.
+ * The timestamp is omitted rather than allowing it to crowd useful content.
+ */
+export function submittedPromptLayout(width, source) {
+    const boundedWidth = Math.max(1, width);
+    const timestamp = source === undefined || source === null ? null : formatSubmittedPromptTime(source);
+    const timestampReserve = timestamp === null ? 0 : displayWidth(timestamp) + TIMESTAMP_MARGIN;
+    const canShowTimestamp = timestamp !== null
+        && boundedWidth - SUBMITTED_PROMPT_PREFIX_WIDTH - timestampReserve >= MIN_USEFUL_CONTENT_WIDTH;
+    return {
+        contentWidth: Math.max(1, boundedWidth - SUBMITTED_PROMPT_PREFIX_WIDTH - (canShowTimestamp ? timestampReserve : 0)),
+        timestamp: canShowTimestamp ? timestamp : null,
+    };
+}
+/**
+ * Composes already-rendered prompt content into the compact submitted bar.
+ * Continuations align below the content, not below the prefix, and no row can
+ * exceed the supplied terminal width even when the content renderer misbehaves.
+ */
+export function composeSubmittedPromptRows(contentRows, width, source, style = {}) {
+    if (width <= 0)
+        return [];
+    const layout = submittedPromptLayout(width, source);
+    const prefix = (style.prefix ?? identity)("❯ ");
+    const rows = (contentRows.length === 0 ? [""] : contentRows).map((row, index) => {
+        const content = truncateToWidth(row, layout.contentWidth);
+        return `${index === 0 ? prefix : " ".repeat(SUBMITTED_PROMPT_PREFIX_WIDTH)}${content}`;
+    });
+    if (layout.timestamp !== null && rows[0] !== undefined) {
+        const gap = Math.max(1, width - displayWidth(rows[0]) - displayWidth(layout.timestamp));
+        rows[0] = `${rows[0]}${" ".repeat(gap)}${(style.timestamp ?? identity)(layout.timestamp)}`;
+    }
+    return rows.map(row => truncateToWidth(row, width));
+}
+function identity(text) {
+    return text;
+}

package/dist/ui/components/text-selection.d.ts

@@ -0,0 +1,53 @@
+export interface TextSelectionPoint {
+    readonly line: number;
+    readonly column: number;
+}
+export interface TextSelection {
+    readonly anchor: TextSelectionPoint;
+    readonly head: TextSelectionPoint;
+    readonly selecting: boolean;
+    readonly cell?: boolean;
+    readonly fullRow?: boolean;
+    /** Paint an edge whitespace run through the viewport's overlaid rail cell. */
+    readonly throughFinalColumn?: boolean;
+}
+export interface TextSelectionClick {
+    readonly time: number;
+    readonly line: number;
+    readonly column: number;
+    readonly count: number;
+}
+export interface TextSelectionLineContent {
+    readonly from?: number;
+    readonly to?: number;
+    readonly selectable?: boolean;
+}
+export interface OrderedTextSelection {
+    readonly start: TextSelectionPoint;
+    readonly end: TextSelectionPoint;
+    readonly fullRow?: boolean;
+    readonly throughFinalColumn?: boolean;
+}
+export interface TextSelectionPressInput {
+    readonly line: number;
+    readonly column: number;
+    readonly contentWidth: number;
+    readonly lineText: string;
+    readonly lineContent?: TextSelectionLineContent;
+    readonly previousClick?: TextSelectionClick;
+    readonly now?: number;
+}
+export declare const TEXT_SELECTION_MULTI_CLICK_MS = 500;
+export declare function orderedTextSelection(selection: TextSelection | undefined): OrderedTextSelection | undefined;
+export declare function pressTextSelection(input: TextSelectionPressInput): {
+    readonly selection?: TextSelection;
+    readonly click: TextSelectionClick;
+    readonly kind: "point" | "word" | "line";
+};
+export declare function extendTextSelection(selection: TextSelection | undefined, point: TextSelectionPoint): TextSelection | undefined;
+export declare function releaseTextSelection(selection: TextSelection | undefined): TextSelection | undefined;
+export declare function textSelectionLineExtendColumn(selection: TextSelection, line: number, contentWidth: number): number;
+export declare function textSelectionText(selection: OrderedTextSelection, rows: readonly string[], lineContent?: (line: number) => TextSelectionLineContent | undefined): string;
+/** Returns the plain cells covered by [from,to), using terminal grapheme widths. */
+export declare function plainTextBetweenColumns(line: string, from: number, to: number): string;
+export declare function usefulTextLineContent(line: string, from?: number): TextSelectionLineContent;

package/dist/ui/components/text-selection.js

@@ -0,0 +1,168 @@
+import { displayWidth, stripAnsi } from "./text.js";
+const GRAPHEMES = new Intl.Segmenter(undefined, { granularity: "grapheme" });
+export const TEXT_SELECTION_MULTI_CLICK_MS = 500;
+export function orderedTextSelection(selection) {
+    if (selection === undefined)
+        return undefined;
+    const { anchor, head } = selection;
+    if (anchor.line === head.line && anchor.column === head.column && !selection.cell && !selection.fullRow)
+        return undefined;
+    const anchorFirst = anchor.line < head.line || (anchor.line === head.line && anchor.column <= head.column);
+    const ordered = anchorFirst
+        ? { start: anchor, end: head }
+        : { start: head, end: anchor };
+    return {
+        ...ordered,
+        ...(selection.fullRow ? { fullRow: true } : {}),
+        ...(selection.throughFinalColumn ? { throughFinalColumn: true } : {}),
+    };
+}
+export function pressTextSelection(input) {
+    const now = input.now ?? Date.now();
+    const previous = input.previousClick;
+    const count = previous !== undefined
+        && now - previous.time <= TEXT_SELECTION_MULTI_CLICK_MS
+        && previous.line === input.line
+        && Math.abs(previous.column - input.column) <= 1
+        ? previous.count + 1
+        : 1;
+    const click = { time: now, line: input.line, column: input.column, count };
+    const column = clamp(input.column, 1, Math.max(1, input.contentWidth));
+    const kind = ((count - 1) % 3) + 1;
+    if (kind === 2) {
+        const selection = selectWord(input.line, column, input.contentWidth, input.lineText);
+        return selection === undefined ? { click, kind: "word" } : { selection, click, kind: "word" };
+    }
+    if (kind === 3) {
+        if (input.lineContent?.selectable === false)
+            return { click, kind: "line" };
+        const from = clamp(input.lineContent?.from ?? 1, 1, Math.max(1, input.contentWidth));
+        const to = clamp(input.lineContent?.to ?? input.contentWidth, from, Math.max(1, input.contentWidth));
+        return {
+            selection: {
+                anchor: { line: input.line, column: from },
+                head: { line: input.line, column: to },
+                selecting: true,
+                cell: true,
+                fullRow: true,
+            },
+            click,
+            kind: "line",
+        };
+    }
+    return {
+        selection: {
+            anchor: { line: input.line, column },
+            head: { line: input.line, column },
+            selecting: true,
+            cell: false,
+        },
+        click,
+        kind: "point",
+    };
+}
+export function extendTextSelection(selection, point) {
+    if (selection?.selecting !== true)
+        return selection;
+    if (selection.fullRow) {
+        if (point.line === selection.anchor.line && selection.head.line === selection.anchor.line)
+            return selection;
+        const edge = point.line < selection.anchor.line ? Number.MAX_SAFE_INTEGER : 1;
+        if (selection.anchor.column !== edge) {
+            return { ...selection, anchor: { line: selection.anchor.line, column: edge }, head: point };
+        }
+    }
+    return { ...selection, head: point };
+}
+export function releaseTextSelection(selection) {
+    if (selection === undefined)
+        return undefined;
+    const released = selection.selecting ? { ...selection, selecting: false } : selection;
+    return orderedTextSelection(released) === undefined ? undefined : released;
+}
+export function textSelectionLineExtendColumn(selection, line, contentWidth) {
+    return line < selection.anchor.line ? 1 : Math.max(1, contentWidth);
+}
+export function textSelectionText(selection, rows, lineContent) {
+    const parts = [];
+    for (let line = selection.start.line; line <= selection.end.line && line < rows.length; line += 1) {
+        const plain = stripAnsi(rows[line] ?? "");
+        const content = lineContent?.(line);
+        if (content?.selectable === false) {
+            parts.push("");
+            continue;
+        }
+        const baseFrom = line === selection.start.line ? selection.start.column - 1 : 0;
+        const baseTo = line === selection.end.line ? selection.end.column : Number.MAX_SAFE_INTEGER;
+        const from = Math.max(baseFrom, Math.max(0, (content?.from ?? 1) - 1));
+        const to = Math.max(from, Math.min(baseTo, content?.to ?? Number.MAX_SAFE_INTEGER));
+        parts.push(plain.slice(indexAtDisplayWidth(plain, from), indexAtDisplayWidth(plain, to)).trimEnd());
+    }
+    return parts.join("\n");
+}
+/** Returns the plain cells covered by [from,to), using terminal grapheme widths. */
+export function plainTextBetweenColumns(line, from, to) {
+    const plain = stripAnsi(line);
+    return plain.slice(indexAtDisplayWidth(plain, from), indexAtDisplayWidth(plain, to));
+}
+export function usefulTextLineContent(line, from = 1) {
+    const start = Math.max(1, from);
+    const end = displayWidth(stripAnsi(line).replace(/\s+$/, "")) + 1;
+    return { from: start, to: Math.max(start, end) };
+}
+function selectWord(line, column, contentWidth, lineText) {
+    const plain = stripAnsi(lineText);
+    const segments = [];
+    let width = 0;
+    for (const { segment } of GRAPHEMES.segment(plain)) {
+        const cellWidth = displayWidth(segment);
+        if (cellWidth <= 0)
+            continue;
+        segments.push({ cls: characterClass(segment), from: width, to: width + cellWidth });
+        width += cellWidth;
+    }
+    const at = clamp(column, 1, Math.max(1, contentWidth)) - 1;
+    const index = segments.findIndex(segment => at >= segment.from && at < segment.to);
+    if (index < 0)
+        return undefined;
+    let low = index;
+    let high = index;
+    while (low > 0 && segments[low - 1]?.cls === segments[index]?.cls)
+        low -= 1;
+    while (high + 1 < segments.length && segments[high + 1]?.cls === segments[index]?.cls)
+        high += 1;
+    const end = segments[high]?.to ?? 1;
+    return {
+        anchor: { line, column: (segments[low]?.from ?? 0) + 1 },
+        head: { line, column: end },
+        selecting: true,
+        cell: true,
+        throughFinalColumn: segments[index]?.cls === 0 && end >= contentWidth,
+    };
+}
+function characterClass(character) {
+    if (/\s/u.test(character))
+        return 0;
+    if (/[\p{L}\p{N}_]/u.test(character))
+        return 1;
+    return 2;
+}
+function indexAtDisplayWidth(plain, column) {
+    if (column <= 0)
+        return 0;
+    let width = 0;
+    let index = 0;
+    for (const { segment } of GRAPHEMES.segment(plain)) {
+        const cellWidth = displayWidth(segment);
+        if (width + cellWidth > column)
+            break;
+        width += cellWidth;
+        index += segment.length;
+        if (width >= column)
+            break;
+    }
+    return index;
+}
+function clamp(value, minimum, maximum) {
+    return Math.max(minimum, Math.min(value, maximum));
+}

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

@@ -6,6 +6,20 @@
  */
 /** Removes styling sequences so only visible characters remain. */
 export declare function stripAnsi(text: string): string;
+export interface DisplayColumnRange {
+    readonly from: number;
+    readonly to: number;
+}
+/** Visible-column segment (word, whitespace, or punctuation) under a pointer column. */
+export declare function displayWordColumnRange(text: string, pointerColumn: number): DisplayColumnRange | null;
+export interface DisplayColumnSlice {
+    /** Grapheme-aligned visible bounds in the source row. */
+    readonly from: number;
+    readonly to: number;
+    readonly text: string;
+}
+/** Plain graphemes intersecting a visible-column range, expanded at wide-character edges. */
+export declare function displayColumnSlice(text: string, requestedFrom: number, requestedTo: number): DisplayColumnSlice;
 /** Columns this text occupies once styling is removed. */
 export declare function displayWidth(text: string): number;
 /**

package/dist/ui/components/text.js

@@ -6,6 +6,7 @@
  */
 const ANSI_PATTERN = /\[[0-9;:?]*[ -/]*[@-~]|\][^]*(?:|\\)|[@-Z\\-_]/g;
 const SEGMENTER = new Intl.Segmenter(undefined, { granularity: "grapheme" });
+const WORD_SEGMENTER = new Intl.Segmenter(undefined, { granularity: "word" });
 /** Removes styling sequences so only visible characters remain. */
 export function stripAnsi(text) {
     return text.replace(ANSI_PATTERN, "");
@@ -62,6 +63,45 @@ function graphemeWidth(grapheme) {
     }
     return width;
 }
+/** Visible-column segment (word, whitespace, or punctuation) under a pointer column. */
+export function displayWordColumnRange(text, pointerColumn) {
+    const plain = stripAnsi(text);
+    const pointer = Math.max(0, pointerColumn);
+    let column = 0;
+    for (const { segment } of WORD_SEGMENTER.segment(plain)) {
+        const width = displayWidth(segment);
+        const from = column;
+        const to = column + width;
+        if (pointer >= from && pointer < to)
+            return { from, to };
+        column = to;
+    }
+    return null;
+}
+/** Plain graphemes intersecting a visible-column range, expanded at wide-character edges. */
+export function displayColumnSlice(text, requestedFrom, requestedTo) {
+    const plain = stripAnsi(text);
+    const from = Math.max(0, requestedFrom);
+    const to = Math.max(from, requestedTo);
+    let column = 0;
+    let actualFrom;
+    let actualTo = from;
+    let selected = "";
+    for (const { segment } of SEGMENTER.segment(plain)) {
+        const width = graphemeWidth(segment);
+        const start = column;
+        const end = column + width;
+        if (end > from && start < to) {
+            actualFrom ??= start;
+            actualTo = end;
+            selected += segment;
+        }
+        column = end;
+        if (start >= to)
+            break;
+    }
+    return { from: actualFrom ?? from, to: actualFrom === undefined ? from : actualTo, text: selected };
+}
 /** Columns this text occupies once styling is removed. */
 export function displayWidth(text) {
     let width = 0;

package/dist/ui/components/transcript-viewport.d.ts

@@ -0,0 +1,98 @@
+import { type ScrollbarAppearance, type ScrollbarGeometry, type ScrollbarStyle } from "./scrollbar.js";
+export interface TranscriptPromptAnchor {
+    readonly id: string;
+    readonly firstRow: number;
+    readonly lastRow: number;
+    /** The source first row, including its submitted-prompt styling and timestamp. */
+    readonly sourceRow: string;
+}
+export interface TranscriptViewportConfig {
+    readonly scrollbarAppearance: ScrollbarAppearance;
+    readonly scrollbarStyle: ScrollbarStyle;
+}
+export interface TranscriptViewportTheme {
+    readonly track: (text: string) => string;
+    readonly thumb: (text: string, active: boolean) => string;
+    readonly sticky: (text: string, hovered: boolean) => string;
+    readonly quietSticky: (text: string) => string;
+    readonly bottomControl: (text: string, hovered: boolean) => string;
+    readonly selection: (line: string, from: number, to: number) => string;
+}
+export interface TranscriptViewportFrameInput {
+    readonly documentRows: readonly string[];
+    readonly dockRows: readonly string[];
+    readonly promptAnchors: readonly TranscriptPromptAnchor[];
+    readonly width: number;
+    readonly height: number;
+    /**
+     * Optional zero-based terminal row for the floating bottom control. The shell
+     * supplies a stable anchor above its editor group so transient status and
+     * notification rows cannot make the control jump vertically.
+     */
+    readonly bottomControlRow?: number;
+    readonly now?: number;
+    readonly theme?: TranscriptViewportTheme;
+}
+export interface TranscriptViewportHitRegions {
+    readonly viewportHeight: number;
+    readonly rail: {
+        readonly column: number;
+        /** One-based terminal row. The one-row top inset is intentionally excluded. */
+        readonly rowStart: number;
+        readonly trackHeight: number;
+        readonly geometry: ScrollbarGeometry;
+    } | null;
+    readonly sticky: {
+        readonly row: number;
+        readonly target: number;
+        readonly width: number;
+    } | null;
+    readonly bottom: {
+        readonly row: number;
+        readonly columnStart: number;
+        readonly columnEnd: number;
+    } | null;
+}
+export interface TranscriptViewportFrame {
+    readonly rows: readonly string[];
+    readonly contentWidth: number;
+    readonly scrollTop: number;
+    readonly maxScroll: number;
+    readonly followingEnd: boolean;
+    readonly hits: TranscriptViewportHitRegions;
+}
+/**
+ * A1-owned viewport state. It knows only rows and semantic prompt anchors; Pi
+ * components and transcript payloads remain outside this neutral boundary.
+ */
+export declare class TranscriptViewport {
+    #private;
+    get scrollTop(): number;
+    get maxScroll(): number;
+    get followingEnd(): boolean;
+    get newMessages(): number;
+    get frame(): TranscriptViewportFrame | null;
+    /** Counts one completed assistant reply while detached; tool rows never call this. */
+    noteNewMessage(): boolean;
+    setConfig(config: TranscriptViewportConfig): void;
+    noteScrollActivity(now?: number, lingerMs?: number): void;
+    setRailHovered(hovered: boolean): void;
+    setRailDragging(dragging: boolean): void;
+    setStickyHovered(hovered: boolean): void;
+    setBottomHovered(hovered: boolean): void;
+    get selectionActive(): boolean;
+    get hasSelection(): boolean;
+    pressSelection(column: number, viewportRow: number, now?: number): boolean;
+    extendSelection(column: number, viewportRow: number, now?: number, autoScroll?: boolean): boolean;
+    releaseSelection(): boolean;
+    clearSelection(): boolean;
+    selectedText(): string | null;
+    scrollBy(lines: number, now?: number): boolean;
+    scrollTo(position: number, now?: number): boolean;
+    scrollToEnd(now?: number): boolean;
+    /** Jumps to the pinned prompt governing this position, then earlier prompts. */
+    scrollToPreviousPrompt(now?: number): boolean;
+    reset(): void;
+    clearTransient(): void;
+    compose(input: TranscriptViewportFrameInput): TranscriptViewportFrame;
+}