@code-yeongyu/senpi-tui 2026.11.12 → 2026.11.13

package/dist/components/scroll-view.js

@@ -1,4 +1,5 @@
 import { LAYOUT_NODE } from "../layout-node.js";
+import { copyLineSources } from "../selection-source.js";
 import { Container } from "../tui.js";
 export class ScrollView extends Container {
     constructor(component, options = {}) {
@@ -175,7 +176,9 @@ export class ScrollView extends Container {
     render(width) {
         const contentWidth = this.getContentWidth(width);
         const lines = this.child.render(contentWidth);
-        return contentWidth === width ? lines : lines.map((line) => `${line} `);
+        return contentWidth === width
+            ? lines
+            : copyLineSources(lines, lines.map((line) => `${line} `));
     }
     [LAYOUT_NODE]() {
         return { type: "scroll", component: this.child, state: this };

package/dist/components/spacer.js

@@ -1,4 +1,5 @@
 import { nextRenderRevision } from "../tui.js";
+import { setLineSource } from "../selection-source.js";
 /**
  * Spacer component that renders empty lines
  */
@@ -25,6 +26,7 @@ export class Spacer {
         const result = [];
         for (let i = 0; i < this.lines; i++) {
             result.push("");
+            setLineSource(result, i, null);
         }
         return result;
     }

package/dist/components/text.js

@@ -1,4 +1,5 @@
 import { nextRenderRevision } from "../tui.js";
+import { setLineSource } from "../selection-source.js";
 import { applyBackgroundToLine, flattenLines, visibleWidth, wrapTextWithAnsi } from "../utils.js";
 /**
  * Text component - displays multi-line text with word wrapping
@@ -90,6 +91,10 @@ export class Text {
             emptyLines.push(line);
         }
         const result = [...emptyLines, ...contentLines, ...emptyLines];
+        for (let row = 0; row < emptyLines.length; row++) {
+            setLineSource(result, row, null);
+            setLineSource(result, result.length - row - 1, null);
+        }
         flattenLines(result);
         // Update cache
         this.cachedText = this.text;

package/dist/components/v-stack.js

@@ -1,3 +1,4 @@
+import { copyLineSources, setLineSource } from "../selection-source.js";
 import { allocateStackSizes, Stack, visibleStackEntries } from "./stack.js";
 export class VStack extends Stack {
     constructor(children = [], options = {}) {
@@ -12,13 +13,20 @@ export class VStack extends Stack {
         const lines = [];
         for (let index = 0; index < entries.length; index++) {
             if (index > 0) {
-                for (let gap = 0; gap < this.gap; gap++)
+                for (let gap = 0; gap < this.gap; gap++) {
                     lines.push("");
+                    setLineSource(lines, lines.length - 1, null);
+                }
             }
-            const childLines = rendered[index].slice(0, sizes[index]);
+            const original = rendered[index];
+            const childLines = copyLineSources(original, original.slice(0, sizes[index]));
+            const offset = lines.length;
             lines.push(...childLines);
-            for (let padding = childLines.length; padding < sizes[index]; padding++)
+            copyLineSources(childLines, lines, offset);
+            for (let padding = childLines.length; padding < sizes[index]; padding++) {
                 lines.push("");
+                setLineSource(lines, lines.length - 1, null);
+            }
         }
         return lines;
     }

package/dist/index.d.ts

@@ -34,6 +34,7 @@ export { parseTerminalColorSchemeReport, type RgbColor, type TerminalColorScheme
 export declare function calculateImageRows(imageDimensions: ImageDimensions, targetWidthCells: number, cellDimensions?: CellDimensions): number;
 export { allocateImageId, buildKittyPlaceholderRow, type CellDimensions, deleteAllKittyImages, deleteKittyImage, detectCapabilities, encodeITerm2, encodeKitty, getCapabilities, getCellDimensions, getGifDimensions, getImageDimensions, getJpegDimensions, getPngDimensions, getTerminalColorMode, getWebpDimensions, hyperlink, type ImageDimensions, type ImageProtocol, type ImageRenderOptions, imageFallback, KITTY_PLACEHOLDER_MAX, outerKittyGraphicsMode, renderImage, resetCapabilitiesCache, setCapabilities, setCapabilityOverrides, setCellDimensions, type TerminalCapabilities, type TmuxPassthroughState, wrapTmuxPassthrough, } from "./terminal-image.ts";
 export { sanitizeTerminalLabel, shortenImagePath } from "./terminal-text.ts";
+export { copyLineSources } from "./selection-source.ts";
 export { encodeProgramStatus, type ProgramStatus, type ProgramStatusKind, type ProgramStatusState, } from "./program-status.ts";
 export { type Component, CompositeRevision, Container, CURSOR_MARKER, claimFrameRow, compositeTuiLine, currentRenderRevision, dispatchMouseEvent, type Focusable, type FrameLineBytesTotals, frameLineBytesTotals, frameMode, frameScrollbackRows, isFocusable, isViewportTUI, joinLineArrays, mainScreenHistoryLines, nextRenderRevision, type OverlayAnchor, type OverlayBounds, type OverlayHandle, type OverlayMargin, type OverlayOptions, type OverlayUnfocusOptions, renderAtFrameRow, resetMainScreenHistoryLines, type SizeValue, TUI, type TuiInputListener, type TuiInputListenerResult, type TuiMode, type TuiMouseButton, type TuiMouseDispatchResult, type TuiMouseEvent, type TuiMouseEventResult, type TuiMouseEventType, type TuiStopOptions, type ViewportTUI, } from "./tui.ts";
 export { TuiAltScreen, type TuiAltScreenOptions } from "./tui-alt-screen.ts";

package/dist/index.js

@@ -49,6 +49,7 @@ export function calculateImageRows(imageDimensions, targetWidthCells, cellDimens
 }
 export { allocateImageId, buildKittyPlaceholderRow, deleteAllKittyImages, deleteKittyImage, detectCapabilities, encodeITerm2, encodeKitty, getCapabilities, getCellDimensions, getGifDimensions, getImageDimensions, getJpegDimensions, getPngDimensions, getTerminalColorMode, getWebpDimensions, hyperlink, imageFallback, KITTY_PLACEHOLDER_MAX, outerKittyGraphicsMode, renderImage, resetCapabilitiesCache, setCapabilities, setCapabilityOverrides, setCellDimensions, wrapTmuxPassthrough, } from "./terminal-image.js";
 export { sanitizeTerminalLabel, shortenImagePath } from "./terminal-text.js";
+export { copyLineSources } from "./selection-source.js";
 export { encodeProgramStatus, } from "./program-status.js";
 export { CompositeRevision, Container, CURSOR_MARKER, claimFrameRow, compositeTuiLine, currentRenderRevision, dispatchMouseEvent, frameLineBytesTotals, frameMode, frameScrollbackRows, isFocusable, isViewportTUI, joinLineArrays, mainScreenHistoryLines, nextRenderRevision, renderAtFrameRow, resetMainScreenHistoryLines, TUI, } from "./tui.js";
 export { TuiAltScreen } from "./tui-alt-screen.js";

package/dist/selection-source.d.ts

@@ -0,0 +1,43 @@
+import { type SourceRange, type SourceRanges } from "./source-ranges.ts";
+export type { SourceRange } from "./source-ranges.ts";
+export interface SourceDocument {
+    readonly text: string;
+    readonly enclosures: Array<SourceRange & {
+        readonly content: SourceRange;
+    }>;
+    readonly resolveLines?: () => readonly (SourceLine | null | undefined)[] | undefined;
+}
+export interface SourceLine {
+    readonly document: SourceDocument;
+    readonly ranges: SourceRanges;
+    readonly sourceRow?: number;
+    readonly columnOffset?: number;
+    readonly unavailable?: boolean;
+    readonly renderedFallback?: boolean;
+}
+export declare function setLineSources(lines: readonly string[], mapping: readonly (SourceLine | null | undefined)[]): void;
+export declare function setLineSource(lines: readonly string[], row: number, source: SourceLine | null): void;
+export declare function getLineSources(lines: readonly string[]): readonly (SourceLine | null | undefined)[] | undefined;
+/**
+ * Preserve provenance when a component copies, pads, or decorates an existing rendered array.
+ * columnOffset is the number of inserted ASCII padding spaces, not the width of arbitrary text.
+ * Populate unpublished arrays only; retained frames must keep their original provenance.
+ */
+export declare function copyLineSources(from: readonly string[], to: string[], rowOffset?: number, columnOffset?: number): string[];
+type SourceSelection = {
+    readonly text: string;
+} | {
+    readonly unavailable: true;
+} | {
+    readonly renderedFallback: true;
+};
+/**
+ * Resolve the exact source interval of each selected Markdown document. Enclosures are included
+ * only when their complete visible contents were selected; an interior selection remains interior.
+ */
+export declare function resolveSourceSelection(lines: readonly string[], rows: readonly {
+    readonly row: number;
+    readonly start: number;
+    readonly end: number;
+}[]): SourceSelection | undefined;
+//# sourceMappingURL=selection-source.d.ts.map

package/dist/selection-source.js

@@ -0,0 +1,200 @@
+import { getGraphemeSegmenter, stripTerminalSequences, visibleWidth } from "./utils.js";
+import { concatRanges, emptyRanges, repeatedRange, sliceRanges, } from "./source-ranges.js";
+// Undefined rows retain rendered plain text; null rows are known layout padding.
+const sources = new WeakMap();
+export function setLineSources(lines, mapping) {
+    sources.set(lines, [...mapping]);
+}
+export function setLineSource(lines, row, source) {
+    const mapping = sources.get(lines) ?? [];
+    mapping[row] = source;
+    sources.set(lines, mapping);
+}
+export function getLineSources(lines) {
+    return sources.get(lines);
+}
+/**
+ * Preserve provenance when a component copies, pads, or decorates an existing rendered array.
+ * columnOffset is the number of inserted ASCII padding spaces, not the width of arbitrary text.
+ * Populate unpublished arrays only; retained frames must keep their original provenance.
+ */
+export function copyLineSources(from, to, rowOffset = 0, columnOffset = 0) {
+    const mapping = sources.get(from);
+    if (mapping) {
+        const result = sources.get(to) ?? [];
+        for (let row = 0; row < mapping.length && row + rowOffset < to.length; row++) {
+            const line = mapping[row];
+            result[row + rowOffset] =
+                line && columnOffset
+                    ? line.sourceRow === undefined
+                        ? { ...line, ranges: concatRanges([repeatedRange(undefined, columnOffset), line.ranges]) }
+                        : { ...line, columnOffset: (line.columnOffset ?? 0) + columnOffset }
+                    : line;
+        }
+        sources.set(to, result);
+    }
+    return to;
+}
+/**
+ * Resolve the exact source interval of each selected Markdown document. Enclosures are included
+ * only when their complete visible contents were selected; an interior selection remains interior.
+ */
+export function resolveSourceSelection(lines, rows) {
+    const mapping = sources.get(lines);
+    if (!mapping)
+        return undefined;
+    const resolvedDocuments = new Map();
+    for (const selection of rows) {
+        const document = mapping[selection.row]?.document;
+        if (!document?.resolveLines || resolvedDocuments.has(document))
+            continue;
+        const resolved = document.resolveLines();
+        resolvedDocuments.set(document, {
+            lines: resolved,
+            document: { ...(resolved?.find((line) => line)?.document ?? document) },
+        });
+    }
+    const resolveLine = (line) => {
+        if (!line)
+            return undefined;
+        if (line.sourceRow === undefined)
+            return line;
+        const resolved = resolvedDocuments.get(line.document);
+        if (!resolved)
+            return undefined;
+        if (!resolved.lines)
+            return { document: resolved.document, ranges: emptyRanges, unavailable: true };
+        const original = resolved.lines[line.sourceRow];
+        if (!original)
+            return undefined;
+        return {
+            ...original,
+            document: resolved.document,
+            ranges: line.columnOffset
+                ? concatRanges([repeatedRange(undefined, line.columnOffset), original.ranges])
+                : original.ranges,
+        };
+    };
+    const documentLines = new Map();
+    for (const source of mapping) {
+        const line = resolveLine(source);
+        if (!line)
+            continue;
+        const group = documentLines.get(line.document);
+        if (group)
+            group.push(line);
+        else
+            documentLines.set(line.document, [line]);
+    }
+    const pieces = [];
+    let active;
+    let usedSource = false;
+    let unavailable = false;
+    let renderedFallback = false;
+    const flush = () => {
+        if (!active)
+            return;
+        let { start, end } = active;
+        const covered = [];
+        for (const range of active.selected.sort((left, right) => left.start - right.start)) {
+            const previous = covered.at(-1);
+            if (previous && previous.end >= range.start)
+                previous.end = Math.max(previous.end, range.end);
+            else
+                covered.push({ ...range });
+        }
+        // A wrapped table can visit source cells out of order. Never fill an unselected hole.
+        for (const line of documentLines.get(active.document) ?? []) {
+            for (const span of line.ranges.spans) {
+                const range = span.source;
+                if (!range)
+                    continue;
+                const left = span.linear ? Math.max(start, range.start) : range.start;
+                const right = span.linear ? Math.min(end, range.end) : range.end;
+                if (left < start || right > end || left >= right)
+                    continue;
+                let low = 0;
+                let high = covered.length;
+                while (low < high) {
+                    const middle = (low + high) >>> 1;
+                    if (covered[middle].start <= left)
+                        low = middle + 1;
+                    else
+                        high = middle;
+                }
+                if (low === 0 || covered[low - 1].end < right)
+                    unavailable = true;
+            }
+        }
+        // Inner enclosures can make an outer enclosure complete.
+        for (const enclosure of active.document.enclosures) {
+            if (start <= enclosure.content.start && end >= enclosure.content.end) {
+                start = Math.min(start, enclosure.start);
+                end = Math.max(end, enclosure.end);
+            }
+        }
+        pieces.push(active.document.text.slice(start, end));
+        active = undefined;
+    };
+    for (const selection of rows) {
+        const source = mapping[selection.row];
+        if (source === null)
+            continue;
+        const line = resolveLine(source);
+        const text = stripTerminalSequences(lines[selection.row] ?? "");
+        if (!line) {
+            // Source-owned blank rows are represented by the source interval.
+            // Unmapped plain-text rows must retain their hard blank lines.
+            if (source && !text.trim())
+                continue;
+            flush();
+            let column = 0;
+            let selected = "";
+            for (const { segment } of getGraphemeSegmenter().segment(text)) {
+                const width = visibleWidth(segment);
+                if (column < selection.end && column + width > selection.start)
+                    selected += segment;
+                column += width;
+            }
+            pieces.push(selected.trimEnd());
+            continue;
+        }
+        usedSource = true;
+        if (active && active.document !== line.document)
+            flush();
+        let column = 0;
+        let unitStart = text.length;
+        let unitEnd = 0;
+        for (const { segment, index } of getGraphemeSegmenter().segment(text)) {
+            const width = visibleWidth(segment);
+            if (column < selection.end && column + width > selection.start) {
+                if (line.unavailable && segment.trim())
+                    return { unavailable: true };
+                if (line.renderedFallback && segment.trim())
+                    renderedFallback = true;
+                unitStart = Math.min(unitStart, index);
+                unitEnd = index + segment.length;
+            }
+            column += width;
+        }
+        for (const span of sliceRanges(line.ranges, unitStart, unitEnd).spans) {
+            const range = span.source;
+            if (range === null)
+                return { unavailable: true };
+            if (!active)
+                active = { document: line.document, ...range, selected: [] };
+            else {
+                active.start = Math.min(active.start, range.start);
+                active.end = Math.max(active.end, range.end);
+            }
+            active.selected.push(range);
+        }
+    }
+    flush();
+    if (unavailable)
+        return { unavailable: true };
+    if (renderedFallback)
+        return { renderedFallback: true };
+    return usedSource ? { text: pieces.join("\n") } : undefined;
+}
+//# sourceMappingURL=selection-source.js.map

package/dist/source-ranges.d.ts

@@ -0,0 +1,25 @@
+export interface SourceRange {
+    readonly start: number;
+    readonly end: number;
+}
+interface SourceSpan {
+    readonly offset: number;
+    readonly length: number;
+    /** null marks visible output whose original source cannot be recovered. */
+    readonly source: SourceRange | null;
+    /** Linear spans map UTF-16 units one-to-one; other spans repeat one source interval. */
+    readonly linear: boolean;
+}
+/** Display-only padding occupies length but has no span. */
+export interface SourceRanges {
+    readonly length: number;
+    readonly spans: readonly SourceSpan[];
+}
+export declare const emptyRanges: SourceRanges;
+export declare function linearRanges(start: number, length: number): SourceRanges;
+export declare function repeatedRange(source: SourceRange | null | undefined, length: number): SourceRanges;
+export declare function rangeAt(ranges: SourceRanges, offset: number): SourceRange | null | undefined;
+export declare function sliceRanges(ranges: SourceRanges, from: number, to?: number): SourceRanges;
+export declare function concatRanges(parts: readonly SourceRanges[]): SourceRanges;
+export {};
+//# sourceMappingURL=source-ranges.d.ts.map

package/dist/source-ranges.js

@@ -0,0 +1,122 @@
+export const emptyRanges = { length: 0, spans: [] };
+/** Most token slices are contiguous; retain two numbers instead of a span object graph. */
+class LinearRanges {
+    constructor(start, length) {
+        this.start = start;
+        this.length = length;
+    }
+    get spans() {
+        return [
+            {
+                offset: 0,
+                length: this.length,
+                source: { start: this.start, end: this.start + this.length },
+                linear: true,
+            },
+        ];
+    }
+}
+export function linearRanges(start, length) {
+    return length ? new LinearRanges(start, length) : emptyRanges;
+}
+export function repeatedRange(source, length) {
+    return length
+        ? { length, spans: source === undefined ? [] : [{ offset: 0, length, source, linear: false }] }
+        : emptyRanges;
+}
+function firstSpan(ranges, offset) {
+    let low = 0;
+    let high = ranges.spans.length;
+    while (low < high) {
+        const middle = (low + high) >>> 1;
+        const span = ranges.spans[middle];
+        if (span.offset + span.length <= offset)
+            low = middle + 1;
+        else
+            high = middle;
+    }
+    return low;
+}
+export function rangeAt(ranges, offset) {
+    if (ranges instanceof LinearRanges) {
+        if (offset < 0 || offset >= ranges.length)
+            return undefined;
+        const start = ranges.start + offset;
+        return { start, end: start + 1 };
+    }
+    const span = ranges.spans[firstSpan(ranges, offset)];
+    if (!span || offset < span.offset)
+        return undefined;
+    if (!span.linear || !span.source)
+        return span.source;
+    const start = span.source.start + offset - span.offset;
+    return { start, end: start + 1 };
+}
+export function sliceRanges(ranges, from, to = ranges.length) {
+    const start = Math.max(0, Math.min(ranges.length, from < 0 ? ranges.length + from : from));
+    const end = Math.max(start, Math.min(ranges.length, to < 0 ? ranges.length + to : to));
+    if (start === 0 && end === ranges.length)
+        return ranges;
+    if (ranges instanceof LinearRanges)
+        return linearRanges(ranges.start + start, end - start);
+    const spans = [];
+    for (let index = firstSpan(ranges, start); index < ranges.spans.length; index++) {
+        const span = ranges.spans[index];
+        if (span.offset >= end)
+            break;
+        const left = Math.max(start, span.offset);
+        const right = Math.min(end, span.offset + span.length);
+        spans.push({
+            offset: left - start,
+            length: right - left,
+            source: span.linear && span.source
+                ? {
+                    start: span.source.start + left - span.offset,
+                    end: span.source.start + right - span.offset,
+                }
+                : span.source,
+            linear: span.linear,
+        });
+    }
+    return compactRanges(end - start, spans);
+}
+export function concatRanges(parts) {
+    if (parts.length === 1)
+        return parts[0];
+    const spans = [];
+    let length = 0;
+    for (const part of parts) {
+        for (const span of part.spans) {
+            const offset = length + span.offset;
+            const previous = spans.at(-1);
+            if (previous &&
+                previous.offset + previous.length === offset &&
+                previous.linear === span.linear &&
+                (previous.linear
+                    ? previous.source && span.source && previous.source.end === span.source.start
+                    : previous.source?.start === span.source?.start && previous.source?.end === span.source?.end)) {
+                spans[spans.length - 1] = {
+                    ...previous,
+                    length: previous.length + span.length,
+                    source: previous.linear && previous.source && span.source
+                        ? { start: previous.source.start, end: span.source.end }
+                        : previous.source,
+                };
+            }
+            else {
+                spans.push(length ? { ...span, offset } : span);
+            }
+        }
+        length += part.length;
+    }
+    return compactRanges(length, spans);
+}
+function compactRanges(length, spans) {
+    if (!length)
+        return emptyRanges;
+    const span = spans[0];
+    return spans.length === 1 && span.offset === 0 && span.length === length && span.linear && span.source
+        ? linearRanges(span.source.start, length)
+        : { length, spans };
+}
+//# sourceMappingURL=source-ranges.js.map

package/dist/tui-alt-screen.d.ts

@@ -151,6 +151,7 @@ export declare class TuiAltScreen extends TuiBase implements ViewportTUI {
     private handleSelectionMouseEvent;
     private getSelectionBounds;
     private getSelectionColumns;
+    private selectionSourceUnavailable;
     private getActiveSelectionText;
     private copySelectionToClipboard;
     private copyTextToClipboard;

package/dist/tui-alt-screen.js

@@ -7,6 +7,7 @@ import { isKeyRelease } from "./keys.js";
 import { getLayoutBoxesAt, getScrollbarGeometry, getScrollViewBox, getScrollViewsAt, renderLayoutFrame, } from "./layout.js";
 import { getLayoutNode } from "./layout-node.js";
 import { decodeMouseButton, isMouseSequence, parseSgrMouseEvent, parseWheelEvent } from "./mouse-input.js";
+import { resolveSourceSelection } from "./selection-source.js";
 import { deleteAllKittyImages, deleteAllKittyPlacements, deleteKittyImage, getCapabilities, getKittyImagePlacement, isImageLine, setCapabilities, } from "./terminal-image.js";
 import { Container, CURSOR_MARKER, compositeTuiLine, dispatchMouseEvent, retargetMouseEvent, TuiBase, VIEWPORT_TUI, } from "./tui.js";
 import { extractAnsiCode, getGraphemeCellRange, getOsc8LinkAtColumn, getWordSegmenter, sliceByColumn, stripTerminalSequences, truncateToWidth, visibleWidth, } from "./utils.js";
@@ -54,6 +55,7 @@ export class TuiAltScreen extends TuiBase {
         this.selectionPressActive = false;
         this.selectionDragged = false;
         this.mousePressMoved = false;
+        this.selectionSourceUnavailable = false;
         this.implicitDocument = {
             render: (width) => super.render(width),
             handleMouse: (event) => super.handleMouse(event),
@@ -93,14 +95,11 @@ export class TuiAltScreen extends TuiBase {
     }
     /** Whether the fullscreen viewport has a non-empty active text selection. */
     hasActiveSelection() {
-        return this.getActiveSelectionText() !== undefined;
+        return this.getActiveSelectionText() !== undefined || this.selectionSourceUnavailable;
     }
     /** Copy the active fullscreen text selection, if any, using the configured selection clipboard path. */
     async copyActiveSelectionToClipboard() {
-        const text = this.getActiveSelectionText();
-        if (!text)
-            return false;
-        return this.copyTextToClipboard(text);
+        return this.copySelectionToClipboard();
     }
     /** The lines of the last rendered frame, one per terminal row, as written to the terminal. */
     getScreenLines() {
@@ -1126,6 +1125,7 @@ export class TuiAltScreen extends TuiBase {
         return { start: Math.max(minColumn, start), end: Math.min(maxColumn, end) };
     }
     getActiveSelectionText() {
+        this.selectionSourceUnavailable = false;
         const selection = this.getSelectionBounds();
         if (!selection)
             return undefined;
@@ -1138,6 +1138,17 @@ export class TuiAltScreen extends TuiBase {
                 return undefined;
             sourceLines = box.scrollContentLines;
         }
+        const rows = [];
+        for (let row = selection.start.row; row <= selection.end.row; row++) {
+            rows.push({ row, ...this.getSelectionColumns(sourceLines[row] ?? "", row, selection) });
+        }
+        const original = resolveSourceSelection(sourceLines, rows);
+        if (original && "unavailable" in original) {
+            this.selectionSourceUnavailable = true;
+            return undefined;
+        }
+        if (original && "text" in original)
+            return original.text || undefined;
         const lines = [];
         for (let row = selection.start.row; row <= selection.end.row; row++) {
             const line = sourceLines[row] ?? "";
@@ -1149,6 +1160,10 @@ export class TuiAltScreen extends TuiBase {
     }
     async copySelectionToClipboard() {
         const text = this.getActiveSelectionText();
+        if (this.selectionSourceUnavailable) {
+            this.flash("Original source unavailable for this selection", COPY_ERROR_FLASH_DURATION_MS);
+            return false;
+        }
         if (!text)
             return false;
         return this.copyTextToClipboard(text);

package/dist/tui.js

@@ -9,6 +9,7 @@ import { performance } from "node:perf_hooks";
 import { isKeyRelease, matchesKey } from "./keys.js";
 import { buildKittyGraphicsQuery, KITTY_GRAPHICS_PROBE_TIMEOUT_MS, parseKittyGraphicsProbeResponse, } from "./kitty-graphics-probe.js";
 import { isMultiplexerSession, useLegacyMuxRender, viewportRenderEnabled } from "./mux.js";
+import { copyLineSources } from "./selection-source.js";
 import { parseOscColorResponse, parseTerminalColorSchemeReport, } from "./terminal-colors.js";
 import { allocateImageId, deleteKittyImage, getCapabilities, isImageLine, resetCapabilitiesCache, setCellDimensions, setProbedImageProtocol, } from "./terminal-image.js";
 import { consumeTmuxFocusEvent, DISABLE_FOCUS_REPORTING, ENABLE_FOCUS_REPORTING } from "./tmux-focus.js";
@@ -574,13 +575,20 @@ const JOIN_BATCH = 1024;
  * which keeps a frame over a long transcript from paying a per-line iterator and push.
  */
 export function joinLineArrays(chunks) {
-    if (chunks.length <= JOIN_BATCH)
-        return [].concat(...chunks);
+    if (chunks.length <= JOIN_BATCH) {
+        const result = [].concat(...chunks);
+        let offset = 0;
+        for (const chunk of chunks) {
+            copyLineSources(chunk, result, offset);
+            offset += chunk.length;
+        }
+        return result;
+    }
     const batches = [];
     for (let start = 0; start < chunks.length; start += JOIN_BATCH) {
-        batches.push([].concat(...chunks.slice(start, start + JOIN_BATCH)));
+        batches.push(joinLineArrays(chunks.slice(start, start + JOIN_BATCH)));
     }
-    return [].concat(...batches);
+    return joinLineArrays(batches);
 }
 /**
  * TUI - Main class for managing terminal UI with differential rendering

package/dist/utils.d.ts

@@ -60,7 +60,8 @@ export declare function getActiveBackgroundAnsi(text: string): string;
  * reads it whole, so V8 flattens it in place; the strings' values do not change.
  */
 export declare function flattenLines(lines: readonly string[]): void;
-export declare function wrapTextWithAnsi(text: string, width: number): string[];
+/** onLine receives each output line's consumed UTF-16 interval in the ANSI-stripped input. */
+export declare function wrapTextWithAnsi(text: string, width: number, onLine?: (start: number, end: number) => void): string[];
 export declare const PUNCTUATION_REGEX: RegExp;
 /**
  * Check if a character is whitespace.