@timurproko/a1 0.2.6 → 0.2.7-dev.1222

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

@@ -1,22 +1,30 @@
 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) {
+/** Deterministic local hour/minute presentation shared by A1-owned time labels. */
+export function formatLocalTime(source, format = "8:00 PM") {
     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")}`;
+    const hour = date.getHours();
+    const minute = String(date.getMinutes()).padStart(2, "0");
+    if (format === "20:00")
+        return `${String(hour).padStart(2, "0")}:${minute}`;
+    return `${hour % 12 || 12}:${minute} ${hour < 12 ? "AM" : "PM"}`;
+}
+/** Visible width of the submitted-prompt prefix (` ❯ `). */
+export const SUBMITTED_PROMPT_PREFIX_WIDTH = 3;
+const TIMESTAMP_MARGIN = 3;
+const MIN_USEFUL_CONTENT_WIDTH = 8;
+/** Formats transcript metadata, never render time, in the active A1 time format. */
+export function formatSubmittedPromptTime(source, format = "8:00 PM") {
+    return formatLocalTime(source, format);
 }
 /**
  * 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) {
+export function submittedPromptLayout(width, source, format = "8:00 PM") {
     const boundedWidth = Math.max(1, width);
-    const timestamp = source === undefined || source === null ? null : formatSubmittedPromptTime(source);
+    const timestamp = source === undefined || source === null ? null : formatSubmittedPromptTime(source, format);
     const timestampReserve = timestamp === null ? 0 : displayWidth(timestamp) + TIMESTAMP_MARGIN;
     const canShowTimestamp = timestamp !== null
         && boundedWidth - SUBMITTED_PROMPT_PREFIX_WIDTH - timestampReserve >= MIN_USEFUL_CONTENT_WIDTH;
@@ -30,11 +38,11 @@ export function submittedPromptLayout(width, source) {
  * 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 = {}) {
+export function composeSubmittedPromptRows(contentRows, width, source, style = {}, format = "8:00 PM") {
     if (width <= 0)
         return [];
-    const layout = submittedPromptLayout(width, source);
-    const prefix = (style.prefix ?? identity)("❯ ");
+    const layout = submittedPromptLayout(width, source, format);
+    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}`;

package/dist/ui/components/surface.js

@@ -29,10 +29,12 @@ export function withScrollbarRail(lines, geometry, contentWidth, theme, options
  */
 export function renderEmptyState(message, mark, height, width, theme) {
     const middle = Math.floor(height / 2);
+    const messageRow = Math.min(Math.max(0, height - 1), middle + 1);
+    const markRow = messageRow - 1;
     return Array.from({ length: Math.max(0, height) }, (_line, index) => {
-        if (index === middle - 1)
+        if (index === markRow)
             return centre(theme.fg("muted", mark), mark, width);
-        return index === middle ? centre(theme.fg("muted", message), message, width) : "";
+        return index === messageRow ? centre(theme.fg("muted", message), message, width) : "";
     });
 }
 function centre(painted, raw, width) {

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

@@ -1,4 +1,3 @@
-/** A reported pointer cell plus its grapheme-aligned zero-based boundaries. */
 export interface TextSelectionPoint {
     readonly line: number;
     readonly column: number;
@@ -28,7 +27,6 @@ export interface TextSelectionLineContent {
     readonly to?: number;
     readonly selectable?: boolean;
 }
-/** Ordered zero-based, half-open display-column boundaries. */
 export interface OrderedTextSelection {
     readonly start: TextSelectionPoint;
     readonly end: TextSelectionPoint;
@@ -45,6 +43,7 @@ export interface TextSelectionPressInput {
     readonly now?: number;
 }
 export declare const TEXT_SELECTION_MULTI_CLICK_MS = 500;
+export declare function paintTextSelection(line: string, from: number, to: number, widthOf?: (text: string) => number, clearInverse?: boolean): string;
 export declare function orderedTextSelection(selection: TextSelection | undefined): OrderedTextSelection | undefined;
 export declare function pressTextSelection(input: TextSelectionPressInput): {
     readonly selection?: TextSelection;

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

@@ -1,6 +1,11 @@
+import { backgroundSgrSpan } from "./spans.js";
 import { displayWidth, stripAnsi } from "./text.js";
 const GRAPHEMES = new Intl.Segmenter(undefined, { granularity: "grapheme" });
 export const TEXT_SELECTION_MULTI_CLICK_MS = 500;
+const TEXT_SELECTION_BACKGROUND = "\u001b[48;2;38;79;120m";
+export function paintTextSelection(line, from, to, widthOf = displayWidth, clearInverse = false) {
+    return backgroundSgrSpan(line, from, to, `${clearInverse ? "\u001b[27m" : ""}${TEXT_SELECTION_BACKGROUND}`, "\u001b[49m", widthOf);
+}
 export function orderedTextSelection(selection) {
     if (selection === undefined)
         return undefined;
@@ -17,8 +22,6 @@ export function orderedTextSelection(selection) {
     }
     if (!selection.cell && selection.dragged !== true)
         return undefined;
-    // Invariant: an accepted drag includes both endpoint graphemes, even after returning
-    // to its anchor. Only an unextended point press is empty; paint and copy stay half-open.
     const anchorFirst = comparePoints(anchor, head) <= 0;
     const first = anchorFirst ? anchor : head;
     const last = anchorFirst ? head : anchor;

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

@@ -1,11 +1,8 @@
-/**
- * Display-width text handling. Terminals lay out by column, not by code unit,
- * so measuring with `String.length` mis-sizes CJK, emoji, and combining marks,
- * and counting styling escapes as visible width breaks every layout that uses
- * colour.
- */
+/** Terminal-column geometry: preserve graphemes, Unicode cell widths and ANSI styling. */
 /** Removes styling sequences so only visible characters remain. */
 export declare function stripAnsi(text: string): string;
+/** Width of one grapheme cluster: two for emoji, else the widest code point it contains. */
+export declare function graphemeWidth(grapheme: string): number;
 export interface DisplayColumnRange {
     readonly from: number;
     readonly to: number;

package/dist/ui/components/text.js

@@ -1,9 +1,4 @@
-/**
- * Display-width text handling. Terminals lay out by column, not by code unit,
- * so measuring with `String.length` mis-sizes CJK, emoji, and combining marks,
- * and counting styling escapes as visible width breaks every layout that uses
- * colour.
- */
+/** Terminal-column geometry: preserve graphemes, Unicode cell widths and ANSI styling. */
 const ANSI_PATTERN = /\[[0-9;:?]*[ -/]*[@-~]|[\]_][^]*(?:|\\)|[@-Z\\-_]/g;
 const SEGMENTER = new Intl.Segmenter(undefined, { granularity: "grapheme" });
 const WORD_SEGMENTER = new Intl.Segmenter(undefined, { granularity: "word" });
@@ -76,7 +71,7 @@ function couldBeEmoji(grapheme) {
         grapheme.length > 1);
 }
 /** Width of one grapheme cluster: two for emoji, else the widest code point it contains. */
-function graphemeWidth(grapheme) {
+export function graphemeWidth(grapheme) {
     if (couldBeEmoji(grapheme) && RGI_EMOJI_PATTERN.test(grapheme))
         return 2;
     let width = 0;
@@ -126,8 +121,11 @@ export function displayColumnSlice(text, requestedFrom, requestedTo) {
 }
 /** Columns this text occupies once styling is removed. */
 export function displayWidth(text) {
+    const plain = stripAnsi(text);
+    if (!/[^\x20-\x7e]/u.test(plain))
+        return plain.length;
     let width = 0;
-    for (const { segment } of SEGMENTER.segment(stripAnsi(text)))
+    for (const { segment } of SEGMENTER.segment(plain))
         width += graphemeWidth(segment);
     return width;
 }

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

@@ -6,6 +6,8 @@ export interface TranscriptPromptAnchor {
     readonly lastRow: number;
     /** The source first row, including its submitted-prompt styling and timestamp. */
     readonly sourceRow: string;
+    /** Right-edge metadata cells omitted from semantic prompt copies. */
+    readonly copySuffixWidth?: number;
     /** Optional source-styled row used only while prominent and not hovered. */
     readonly prominentSourceRow?: string;
 }
@@ -36,6 +38,11 @@ export interface TranscriptViewportFrameInput {
     /** Final transient rows to bottom-align with unused viewport space while content fits. */
     readonly bottomAlignedTailRowCount?: number;
     readonly dockRows: readonly string[];
+    /** Zero-based dock rows admitted to frame copying, classified before dock composition. */
+    readonly copyableDockRows?: readonly {
+        readonly row: number;
+        readonly prompt?: "first" | "continuation";
+    }[];
     readonly promptAnchors: readonly TranscriptPromptAnchor[];
     readonly width: number;
     readonly height: number;
@@ -171,7 +178,7 @@ export declare class TranscriptViewport {
     releaseSelection(): boolean;
     clearSelection(): boolean;
     selectedText(): string | null;
-    /** Captures visible selected text, not off-screen history. */
+    /** Captures selected text, including document rows of a visible selection scrolled off-screen. */
     captureSelectedText(): SelectionCopySnapshot | null;
     scrollBy(lines: number, now?: number): boolean;
     scrollTo(position: number, now?: number): boolean;
@@ -184,6 +191,6 @@ export declare class TranscriptViewport {
     clearTransient(): void;
     compose(input: TranscriptViewportFrameInput): TranscriptViewportFrame;
     /** Reuses an established transcript frame when only same-height dock rows changed. */
-    composeDockOnly(dockRows: readonly string[], width: number, height: number): TranscriptViewportFrame | null;
+    composeDockOnly(dockRows: readonly string[], width: number, height: number, copyableDockRows?: TranscriptViewportFrameInput["copyableDockRows"]): TranscriptViewportFrame | null;
 }
 export declare function assertTranscriptViewportFrameDescriptor(descriptor: TranscriptViewportFrameDescriptor): void;

package/dist/ui/components/transcript-viewport.js

@@ -1,9 +1,13 @@
 import { MAX_COPY_SOURCE_UNITS, selectionCopyLineContent } from "./selection-copy.js";
 import { isThumbRow, scrollbarGeometry, scrollbarPresentation, } from "./scrollbar.js";
-import { backgroundSgrSpan, overlaySpan } from "./spans.js";
+import { overlaySpan } from "./spans.js";
 import { faint, truncateToWidth, displayWidth, stripAnsi } from "./text.js";
-import { extendTextSelection, orderedTextSelection, pressTextSelection, releaseTextSelection, textSelectionLineExtendColumn, textSelectionPointAt, textSelectionText, usefulTextLineContent, } from "./text-selection.js";
+import { extendTextSelection, orderedTextSelection, paintTextSelection, pressTextSelection, releaseTextSelection, textSelectionLineExtendColumn, textSelectionPointAt, textSelectionText, usefulTextLineContent, } from "./text-selection.js";
 const CONTROL_STYLE_RESET = "\u001b]8;;\u001b\\\u001b[0m";
+// Protocol: upstream OSC 133 zones are layout annotations, not fullscreen cursor commands.
+// Styling/padding can move them away from the row prefix Pi strips; 133;A then advances a real
+// terminal parser to a fresh line. The custom viewport owns prompt anchors separately.
+const VIEWPORT_PROMPT_ZONES = /\u001b\]133;[ABC](?:\u0007|\u001b\\)/gu;
 // Invariant: scrollbar chrome closes source links and decoration without clearing
 // the row surface painted beneath its dedicated, non-semantic gutter.
 const GUTTER_DECORATION_RESET = "\u001b]8;;\u001b\\\u001b[22;23;24;25;27;28;29;39;54;55m";
@@ -11,6 +15,19 @@ const IDENTITY_ROW = (row) => row;
 function documentSelectionAnchor(row, source, liveFromBottom) {
     return { kind: "document", row, source, identity: stripAnsi(source).trimEnd(), liveFromBottom };
 }
+function sameSelectionRowAnchor(left, right) {
+    if (left.kind !== right.kind)
+        return false;
+    if (left.kind === "document" && right.kind === "document") {
+        return left.row === right.row && left.source === right.source && left.liveFromBottom === right.liveFromBottom;
+    }
+    if (left.kind === "screen" && right.kind === "screen") {
+        return left.row === right.row && left.source === right.source;
+    }
+    if (left.kind === "transient" && right.kind === "transient")
+        return left.fromBottom === right.fromBottom;
+    return left.kind === "dock" && right.kind === "dock" && left.fromBottom === right.fromBottom;
+}
 function viewportSelectionAnchor(row, source, selectableDocumentRowCount, documentRowCount) {
     return row < selectableDocumentRowCount
         ? documentSelectionAnchor(row, source)
@@ -26,7 +43,7 @@ const PLAIN_THEME = {
     sticky: (text, hovered) => hovered ? `\u001b[7m${text}\u001b[27m` : text,
     quietSticky: faint,
     bottomControl: (text, hovered) => hovered ? `\u001b[7m${text}\u001b[27m` : `\u001b[7m${text}\u001b[27m`,
-    selection: (line, from, to) => backgroundSgrSpan(line, from, to),
+    selection: paintTextSelection,
 };
 /**
  * A1-owned viewport state. It knows only rows and semantic prompt anchors; Pi
@@ -63,6 +80,7 @@ export class TranscriptViewport {
     #contentWidth = 0;
     #selectionWidth = 0;
     #viewportHeight = 0;
+    #copyableDockRows = new Map();
     #firstSelectableRow = 0;
     #selectionRowAnchors = [];
     #frameId = 0;
@@ -135,7 +153,12 @@ export class TranscriptViewport {
             this.scrollBy(1, now);
         else if (autoScroll && frameRow <= 1 && this.#scrollTop > 0)
             this.scrollBy(-1, now);
-        const line = clamp(frameRow - 1, 0, this.#selectionRows.length - 1);
+        const pointerLine = clamp(frameRow - 1, 0, this.#selectionRows.length - 1);
+        // Invariant: a pinned prompt alias is chrome; an upward drag reaching it keeps the pointer
+        // column on the first visible content row.
+        const line = pointerLine < this.#firstSelectableRow && pointerLine < selection.anchor.line
+            ? this.#firstSelectableRow
+            : pointerLine;
         const selectionWidth = line < (this.#frame?.hits.viewportHeight ?? 0)
             ? this.#contentWidth
             : this.#selectionWidth;
@@ -146,12 +169,13 @@ export class TranscriptViewport {
             ? { line, column: targetColumn }
             : textSelectionPointAt(line, targetColumn, this.#selectionRows[line] ?? "");
         const next = extendTextSelection(selection, point);
-        if (next !== selection) {
-            const headAnchor = this.#selectionAnchorAt(line);
-            if (headAnchor === undefined || this.#selectionAnchors === undefined) {
-                this.clearSelection();
-                return true;
-            }
+        const headAnchor = this.#selectionAnchorAt(line);
+        if (headAnchor === undefined || this.#selectionAnchors === undefined) {
+            this.clearSelection();
+            return true;
+        }
+        // Invariant: edge auto-scroll changes the document row under a still pointer; that advances the head.
+        if (next !== selection || !sameSelectionRowAnchor(this.#selectionAnchors.head, headAnchor)) {
             this.#selection = next;
             this.#selectionAnchors = { ...this.#selectionAnchors, head: headAnchor };
             this.#selectionRevision += 1;
@@ -179,35 +203,80 @@ export class TranscriptViewport {
         return true;
     }
     selectedText() {
-        const selection = this.#visibleSelection();
-        if (selection === undefined)
+        const visible = this.#visibleSelection();
+        if (visible === undefined)
             return null;
-        // Invariant: the blue range spans the complete frame, but automatic and Ctrl+C frame copy
-        // admit only persistent transcript rows. Transient status, suggestions, input, and footer
-        // chrome remain visually selectable without becoming clipboard payload.
-        const copiedLines = Array.from({ length: Math.max(0, selection.end.line - selection.start.line + 1) }, (_value, index) => selection.start.line + index).filter(line => {
+        const offscreen = offscreenSelectionRows(this.#selection, this.#selectionAnchors, this.#scrollTop, this.#firstSelectableRow, this.#viewportHeight, this.#documentRows.length);
+        // Rationale: edge auto-scroll grows a drag beyond one screen. Paint stays clipped to the
+        // frame, while copy reads the selected document rows past either viewport edge and beneath
+        // the floating bottom control.
+        const selectionRows = [];
+        const rowAnchors = [];
+        const controlLine = (this.#frame?.hits.bottom?.row ?? 0) - 1;
+        const pushDocumentRow = (row) => {
+            const source = this.#documentRows[row] ?? "";
+            selectionRows.push(truncateToWidth(source, this.#contentWidth));
+            rowAnchors.push(documentSelectionAnchor(row, source));
+        };
+        const pushBelow = () => {
+            for (let row = offscreen.below?.from ?? 0; row <= (offscreen.below?.to ?? -1); row += 1)
+                pushDocumentRow(row);
+        };
+        for (let row = offscreen.above?.from ?? 0; row <= (offscreen.above?.to ?? -1); row += 1)
+            pushDocumentRow(row);
+        if (offscreen.belowFirst)
+            pushBelow();
+        for (let line = visible.start.line; line <= visible.end.line; line += 1) {
             const anchor = this.#selectionRowAnchors[line];
-            return anchor?.kind === "document" && anchor.row < this.#selectableDocumentRowCount;
+            if (line === controlLine && anchor?.kind === "document")
+                pushDocumentRow(anchor.row);
+            else {
+                selectionRows.push(this.#selectionRows[line] ?? "");
+                rowAnchors.push(anchor);
+            }
+        }
+        if (!offscreen.belowFirst)
+            pushBelow();
+        const offscreenStart = offscreen.above !== undefined || offscreen.belowFirst === true;
+        const offscreenEnd = offscreen.below !== undefined && !offscreen.belowFirst;
+        const selection = {
+            ...visible,
+            start: { line: 0, column: offscreenStart ? offscreen.startColumn ?? 0 : visible.start.column },
+            end: {
+                line: selectionRows.length - 1,
+                column: offscreenEnd ? offscreen.endColumn ?? Number.MAX_SAFE_INTEGER : visible.end.column,
+            },
+        };
+        const copiedLines = Array.from({ length: Math.max(0, selection.end.line - selection.start.line + 1) }, (_value, index) => selection.start.line + index).filter(line => {
+            const anchor = rowAnchors[line];
+            return anchor?.kind === "document" && anchor.row < this.#selectableDocumentRowCount
+                || anchor?.kind === "dock" && this.#copyableDockRows.has(anchor.fromBottom);
         });
         if (copiedLines.length === 0)
             return null;
-        // Rationale: a prompt selected by itself uses semantic prompt text. Once surrounding transcript text
-        // participates, preserve the prompt's visible prefix, alignment, and timestamp in the bulk range.
-        const prompt = this.#promptAnchors.find(candidate => copiedLines.every(line => {
-            const anchor = this.#selectionRowAnchors[line];
+        const transcriptLines = copiedLines.filter(line => rowAnchors[line]?.kind === "document");
+        const prompt = transcriptLines.length === 0 ? undefined : this.#promptAnchors.find(candidate => transcriptLines.every(line => {
+            const anchor = rowAnchors[line];
             return anchor?.kind === "document" && anchor.row >= candidate.firstRow && anchor.row <= candidate.lastRow;
         }));
         const included = new Set(copiedLines);
-        const text = textSelectionText(selection, this.#selectionRows, line => {
-            const row = this.#selectionRows[line] ?? "";
-            const anchor = this.#selectionRowAnchors[line];
-            return prompt !== undefined && anchor?.kind === "document"
-                ? selectionCopyLineContent(row, anchor.row === prompt.firstRow ? "first" : "continuation")
-                : usefulTextLineContent(row);
+        const text = textSelectionText(selection, selectionRows, line => {
+            const row = selectionRows[line] ?? "";
+            const anchor = rowAnchors[line];
+            const dock = anchor?.kind === "dock" ? this.#copyableDockRows.get(anchor.fromBottom) : undefined;
+            if (prompt !== undefined && anchor?.kind === "document") {
+                const first = anchor.row === prompt.firstRow;
+                const copyRow = first && (prompt.copySuffixWidth ?? 0) > 0
+                    ? truncateToWidth(row, Math.max(0, displayWidth(row) - (prompt.copySuffixWidth ?? 0)))
+                    : row;
+                return selectionCopyLineContent(copyRow, first ? "first" : "continuation");
+            }
+            // Invariant: the dock editor has no prefix; transcript prompts still carry chrome.
+            return dock?.prompt !== undefined ? usefulTextLineContent(row, 1) : usefulTextLineContent(row);
         }, line => included.has(line));
         return text.length === 0 ? null : text;
     }
-    /** Captures visible selected text, not off-screen history. */
+    /** Captures selected text, including document rows of a visible selection scrolled off-screen. */
     captureSelectedText() {
         if (!this.#copyableSelection)
             return null;
@@ -315,6 +384,7 @@ export class TranscriptViewport {
         this.#contentWidth = 0;
         this.#selectionWidth = 0;
         this.#viewportHeight = 0;
+        this.#copyableDockRows.clear();
         this.clearTransient();
         this.#frame = null;
     }
@@ -330,6 +400,7 @@ export class TranscriptViewport {
         const theme = input.theme ?? PLAIN_THEME;
         const previousDescriptor = this.#frame?.descriptor ?? null;
         const dock = input.dockRows.length > height ? input.dockRows.slice(-height) : [...input.dockRows];
+        this.#copyableDockRows = copyableDockRowsBySuffix(input.dockRows, input.copyableDockRows);
         const viewportHeight = Math.max(0, height - dock.length);
         const bottomAlignedTailRowCount = clamp(input.bottomAlignedTailRowCount ?? 0, 0, input.documentRows.length);
         const transientAlignmentGapRows = bottomAlignedTailRowCount > 0
@@ -356,7 +427,7 @@ export class TranscriptViewport {
             contentLength: documentRows.length,
             viewportHeight,
             scroll: this.#scrollTop,
-            // Compatibility: the session rail deliberately starts one line below the viewport top.
+            // Invariant: the rail keeps its top gap; the shell owns the spacing above the dock.
             trackHeight: Math.max(0, viewportHeight - 1),
         });
         const presentation = scrollbarPresentation({
@@ -414,8 +485,6 @@ export class TranscriptViewport {
             visible[0] = quiet && !this.#stickyHovered ? theme.quietSticky(sticky) : sticky;
             visibleSource[0] = sourceRow;
         }
-        // Invariant: selection uses exact visible source rows within the rendered
-        // content boundary; paint-only guards and the rail gutter stay presentation-only.
         this.#selectionRows = [
             ...visibleSource.map(row => truncateToWidth(row, contentWidth)),
             ...dock,
@@ -426,7 +495,6 @@ export class TranscriptViewport {
                 ? viewportSelectionAnchor(documentRow, documentRows[documentRow] ?? "", this.#selectableDocumentRowCount, documentRows.length)
                 : { kind: "screen", row, source: this.#selectionRows[row] ?? "" };
         });
-        // Invariant: a pinned prompt is chrome over its hidden source row, which clips like off-screen rows.
         this.#firstSelectableRow = stickyActive && viewportHeight > 0 ? 1 : 0;
         this.#selectionRowAnchors = [
             ...visibleAnchors,
@@ -463,7 +531,7 @@ export class TranscriptViewport {
                 const bottomHovered = pointer !== undefined && pointer.row === bottomHit.row
                     && pointer.column >= bottomHit.columnStart && pointer.column <= bottomHit.columnEnd;
                 control = { row, left, text: `${CONTROL_STYLE_RESET}${theme.bottomControl(label, bottomHovered)}` };
-                // Invariant: the control floats above selection; its cells are never selected or copied.
+                // Invariant: the control floats above selection; copy restores the text beneath it.
                 selectionRows[row] = overlaySpan(padRowPreservingBackground(selectionRows[row] ?? "", width), left, left + labelWidth, " ".repeat(labelWidth));
             }
         }
@@ -501,7 +569,7 @@ export class TranscriptViewport {
             // Invariant: paint the rail after selection over the gutter's continued row
             // background. Source content and selection still end at the preceding cell.
             let railCell = "";
-            if (row < viewportHeight && presentation.visible && geometry !== null && row > 0) {
+            if (row > 0 && row < viewportHeight && presentation.visible && geometry !== null) {
                 const trackRow = row - 1;
                 const thumb = isThumbRow(geometry, trackRow);
                 const glyph = thumb ? presentation.thumbGlyph : presentation.trackGlyph;
@@ -523,7 +591,7 @@ export class TranscriptViewport {
                 return overlayWidth === 0 ? withControl : overlaySpan(padRowPreservingBackground(withControl, width), overlayLimit - overlayWidth, overlayLimit, `${GUTTER_DECORATION_RESET}${overlayText}`, { inheritStartStyle: true });
             });
             rowRecomputed ||= !final.reused;
-            frameRows[row] = final.value;
+            frameRows[row] = final.value.replace(VIEWPORT_PROMPT_ZONES, "");
             (rowRecomputed ? recomputedRows : reusedRows).push(row + 1);
             const state = `${width}\u0000${row}\u0000${painted}\u0000${rangeKey}\u0000${range === null ? "" : selectionPainterId}\u0000${railCell}\u0000${overlayText}\u0000${rowControl?.text ?? ""}`;
             visibleStates.push(state);
@@ -609,7 +677,7 @@ export class TranscriptViewport {
         return frame;
     }
     /** Reuses an established transcript frame when only same-height dock rows changed. */
-    composeDockOnly(dockRows, width, height) {
+    composeDockOnly(dockRows, width, height, copyableDockRows = []) {
         const previous = this.#frame;
         const boundedWidth = Math.max(1, width);
         const boundedHeight = Math.max(0, height);
@@ -624,19 +692,10 @@ export class TranscriptViewport {
             || !sameRectangle(previous.descriptor.transcript, expectedTranscript))
             return null;
         const descriptor = {
+            ...previous.descriptor,
             frameId: ++this.#frameId,
-            width: boundedWidth,
-            height: boundedHeight,
-            transcript: expectedTranscript,
-            dock: expectedDock,
             previousDocumentRange: previous.descriptor.nextDocumentRange,
-            nextDocumentRange: previous.descriptor.nextDocumentRange,
             previousFollowingEnd: previous.followingEnd,
-            followingEnd: previous.followingEnd,
-            transientRowCount: previous.descriptor.transientRowCount,
-            transientAlignmentGapRows: previous.descriptor.transientAlignmentGapRows,
-            bottomAlignedTailRowCount: previous.descriptor.bottomAlignedTailRowCount,
-            liveTailRows: previous.descriptor.liveTailRows,
             verticalShiftRows: 0,
             safeVerticalShift: false,
             selectionRevision: this.#selectionRevision,
@@ -645,13 +704,10 @@ export class TranscriptViewport {
         };
         assertTranscriptViewportFrameDescriptor(descriptor);
         this.#selectionRows = [...this.#selectionRows.slice(0, viewportHeight), ...dock].slice(0, boundedHeight);
+        this.#copyableDockRows = copyableDockRowsBySuffix(dockRows, copyableDockRows);
         const frame = {
-            rows: [...previous.rows.slice(0, viewportHeight), ...dock].slice(0, boundedHeight),
-            contentWidth: previous.contentWidth,
-            scrollTop: previous.scrollTop,
-            maxScroll: previous.maxScroll,
-            followingEnd: previous.followingEnd,
-            hits: previous.hits,
+            ...previous,
+            rows: [...previous.rows.slice(0, viewportHeight), ...dock.map(row => row.replace(VIEWPORT_PROMPT_ZONES, ""))].slice(0, boundedHeight),
             descriptor,
             selectionDamage: {
                 revision: this.#selectionRevision,
@@ -706,7 +762,7 @@ export class TranscriptViewport {
         const anchors = this.#selectionAnchors;
         if (selection === undefined || anchors === undefined)
             return;
-        const project = (anchor) => {
+        const project = (anchor, moving) => {
             if (anchor.kind === "dock") {
                 const dockIndex = dockRows.length - anchor.fromBottom - 1;
                 return dockIndex < 0 || dockIndex >= dockRows.length
@@ -748,7 +804,7 @@ export class TranscriptViewport {
             // Concurrency: a streaming chunk may replace or reflow the pointer's current live-tail
             // row before the next motion report. During the held gesture only, retain its distance
             // from the persistent tail; release restores identity-only projection.
-            if (selection.selecting && anchor.liveFromBottom !== undefined && this.#liveTailStartRow !== undefined) {
+            if (selection.selecting && moving && anchor.liveFromBottom !== undefined && this.#liveTailStartRow !== undefined) {
                 const documentRow = this.#selectableDocumentRowCount - anchor.liveFromBottom - 1;
                 if (documentRow >= this.#liveTailStartRow && documentRow < this.#selectableDocumentRowCount) {
                     const visible = this.#selectionRowAnchors.findIndex(candidate => candidate?.kind === "document" && candidate.row === documentRow);
@@ -760,10 +816,18 @@ export class TranscriptViewport {
                     }
                 }
             }
+            // Concurrency: streaming may restyle a held endpoint's row; it keeps its document index.
+            // Following the tail would drag the press row toward the newest output.
+            if (selection.selecting && anchor.row >= 0 && anchor.row < documentRows.length) {
+                return {
+                    line: anchor.row - this.#scrollTop,
+                    anchor: documentSelectionAnchor(anchor.row, documentRows[anchor.row] ?? "", anchor.liveFromBottom),
+                };
+            }
             return undefined;
         };
-        const projectedAnchor = project(anchors.anchor);
-        const projectedHead = project(anchors.head);
+        const projectedAnchor = project(anchors.anchor, false);
+        const projectedHead = project(anchors.head, true);
         if (projectedAnchor === undefined || projectedHead === undefined) {
             this.clearSelection();
             return;
@@ -783,11 +847,59 @@ export class TranscriptViewport {
         // Invariant: mixed viewport/dock ranges project across the same complete frame regardless
         // of origin. Document-only ranges remain clipped to the scrollable viewport when off-screen.
         const rows = crossesDock ? this.#selectionRows.length : this.#viewportHeight;
-        return visibleTextSelection(orderedTextSelection(this.#selection), rows, this.#firstSelectableRow);
+        const ordered = orderedTextSelection(dockOrderedSelection(this.#selection, anchors, this.#viewportHeight));
+        return visibleTextSelection(ordered, rows, this.#firstSelectableRow);
     }
     #updateCopyableSelection() {
-        this.#copyableSelection = this.selectedText() !== null;
+        // Performance: off-screen rows count as copyable by range alone; capture trims whitespace later.
+        const offscreen = offscreenSelectionRows(this.#selection, this.#selectionAnchors, this.#scrollTop, this.#firstSelectableRow, this.#viewportHeight, this.#documentRows.length);
+        const selectable = [offscreen.above, offscreen.below]
+            .some(range => range !== undefined && range.from < this.#selectableDocumentRowCount);
+        this.#copyableSelection = selectable && this.#visibleSelection() !== undefined || this.selectedText() !== null;
+    }
+}
+/**
+ * Invariant: dock rows follow the whole transcript, so a document endpoint scrolled below the
+ * viewport orders before every dock row instead of at its numeric frame line among them.
+ */
+function dockOrderedSelection(selection, anchors, viewportHeight) {
+    if (selection === undefined || anchors === undefined || anchors.anchor.kind !== "dock" && anchors.head.kind !== "dock") {
+        return selection;
     }
+    const place = (point, kind) => kind === "document" && point.line >= viewportHeight ? { line: viewportHeight, column: 1, from: 0, to: 0 } : point;
+    return { ...selection, anchor: place(selection.anchor, anchors.anchor.kind), head: place(selection.head, anchors.head.kind) };
+}
+/** Document rows of a selection whose endpoints lie beyond the visible viewport edges. */
+function offscreenSelectionRows(selection, anchors, scrollTop, firstSelectableRow, viewportHeight, documentRowCount) {
+    const ordered = orderedTextSelection(dockOrderedSelection(selection, anchors, viewportHeight));
+    if (selection === undefined || ordered === undefined || anchors === undefined)
+        return {};
+    const placed = dockOrderedSelection(selection, anchors, viewportHeight);
+    const anchorFirst = placed.anchor.line < placed.head.line
+        || placed.anchor.line === placed.head.line && placed.anchor.column <= placed.head.column;
+    const top = anchorFirst ? anchors.anchor : anchors.head;
+    const bottom = anchorFirst ? anchors.head : anchors.anchor;
+    const topPoint = anchorFirst ? selection.anchor : selection.head;
+    const bottomPoint = anchorFirst ? selection.head : selection.anchor;
+    const firstVisibleRow = scrollTop + firstSelectableRow;
+    const pastVisibleRow = scrollTop + viewportHeight;
+    const columns = {
+        startColumn: selection.fullRow ? 0 : topPoint.from ?? Math.max(0, topPoint.column - 1),
+        endColumn: selection.fullRow ? Number.MAX_SAFE_INTEGER : bottomPoint.to ?? bottomPoint.column,
+    };
+    if (top.kind === "document" && bottom.kind === "dock" && top.row >= pastVisibleRow) {
+        return { ...columns, below: { from: top.row, to: documentRowCount - 1 }, belowFirst: true };
+    }
+    return {
+        ...columns,
+        ...(top.kind === "document" && top.row < firstVisibleRow && ordered.start.line < firstSelectableRow
+            ? { above: { from: top.row, to: firstVisibleRow - 1 } }
+            : {}),
+        ...(top.kind === "document" && bottom.kind === "document" && bottom.row >= pastVisibleRow
+            && ordered.end.line >= viewportHeight
+            ? { below: { from: pastVisibleRow, to: bottom.row } }
+            : {}),
+    };
 }
 function visibleTextSelection(selection, rowCount, firstRow) {
     if (selection === undefined || rowCount <= firstRow || selection.end.line < firstRow || selection.start.line >= rowCount)
@@ -963,6 +1075,15 @@ function assertDocumentRange(range, label) {
 function sameRectangle(left, right) {
     return left === null ? right === null : right !== null && left.rowStart === right.rowStart && left.rowEnd === right.rowEnd;
 }
+function copyableDockRowsBySuffix(dockRows, declarations) {
+    const result = new Map();
+    for (const declaration of declarations ?? []) {
+        if (!Number.isSafeInteger(declaration.row) || declaration.row < 0 || declaration.row >= dockRows.length)
+            continue;
+        result.set(dockRows.length - declaration.row - 1, declaration.prompt === undefined ? {} : { prompt: declaration.prompt });
+    }
+    return result;
+}
 function clamp(value, minimum, maximum) {
     return Math.min(Math.max(value, minimum), maximum);
 }