@timurproko/a1 0.1.8-dev.49ff83a → 0.1.8-dev.508

package/dist/ui/components/scrollbar.js

@@ -0,0 +1,137 @@
+/**
+ * One scrollbar for every scrollable surface. Hover and drag belong to a named
+ * 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 uses the same configured rate as a wheel event. */
+export function scrollbarSelectionRows(speed) {
+    return scrollbarWheelRows(speed);
+}
+/** Pure appearance decision; activity time is supplied so tests own the clock. */
+export function scrollbarPresentation(input) {
+    const overflowing = input.geometry !== null;
+    // Invariant: auto/always 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;
+    if (trackHeight <= 0 || viewportHeight <= 0)
+        return null;
+    if (contentLength <= viewportHeight)
+        return null;
+    const maxScroll = contentLength - viewportHeight;
+    const scroll = Math.min(Math.max(input.scroll, 0), maxScroll);
+    const thumbHeight = Math.max(1, Math.min(trackHeight, Math.round(trackHeight * viewportHeight / contentLength)));
+    const travel = trackHeight - thumbHeight;
+    const thumbTop = maxScroll === 0 ? 0 : Math.min(travel, Math.round(travel * scroll / maxScroll));
+    return { trackHeight, thumbHeight, thumbTop, maxScroll };
+}
+export function scrollbarReservesSpace(geometry) {
+    return geometry !== null;
+}
+/** True when this track row is part of the thumb. */
+export function isThumbRow(geometry, trackRow) {
+    if (geometry === null)
+        return false;
+    return trackRow >= geometry.thumbTop && trackRow < geometry.thumbTop + geometry.thumbHeight;
+}
+/** Scroll position for a thumb dragged to a track row. */
+export function scrollForThumbRow(geometry, trackRow) {
+    if (geometry === null)
+        return 0;
+    const travel = geometry.trackHeight - geometry.thumbHeight;
+    if (travel <= 0)
+        return 0;
+    const clamped = Math.min(Math.max(trackRow, 0), travel);
+    return Math.round(clamped * geometry.maxScroll / travel);
+}
+/** Scroll position after paging on the track above or below the thumb. */
+export function scrollForTrackPage(geometry, trackRow, scroll, viewportHeight) {
+    if (geometry === null)
+        return scroll;
+    const page = Math.max(1, viewportHeight);
+    const next = trackRow < geometry.thumbTop ? scroll - page : scroll + page;
+    return Math.min(Math.max(next, 0), geometry.maxScroll);
+}
+/**
+ * Hover and drag state for every rail on screen. State is keyed by rail, so a
+ * pointer over one rail cannot make another appear hot, and a drag started on
+ * one rail cannot be continued by a report addressed to another.
+ */
+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);
+    }
+    isDragging(key) {
+        return this.#dragging?.key === key;
+    }
+    get draggingKey() {
+        return this.#dragging?.key ?? null;
+    }
+    /** Records the pointer position. Returns the rail it is over, if any. */
+    notePointer(rails, pointer) {
+        this.#hovered.clear();
+        for (const rail of rails) {
+            if (pointer.column !== rail.column)
+                continue;
+            const trackRow = pointer.row - rail.rowStart;
+            if (trackRow < 0 || trackRow >= rail.trackHeight)
+                continue;
+            this.#hovered.add(rail.key);
+            return rail.key;
+        }
+        return null;
+    }
+    /** Starts a drag when the pointer is on that rail's thumb. */
+    beginDrag(rail, geometry, pointer) {
+        if (geometry === null || pointer.column !== rail.column)
+            return false;
+        const trackRow = pointer.row - rail.rowStart;
+        if (!isThumbRow(geometry, trackRow))
+            return false;
+        this.#dragging = { key: rail.key, grabOffset: trackRow - geometry.thumbTop };
+        return true;
+    }
+    /** Scroll position for a drag in progress, or null when this rail is not being dragged. */
+    dragTo(rail, geometry, pointer) {
+        const dragging = this.#dragging;
+        if (dragging === undefined || dragging.key !== rail.key || geometry === null)
+            return null;
+        return scrollForThumbRow(geometry, pointer.row - rail.rowStart - dragging.grabOffset);
+    }
+    endDrag() {
+        this.#dragging = undefined;
+    }
+    clear() {
+        this.#hovered.clear();
+        this.#activeUntil.clear();
+        this.#dragging = undefined;
+    }
+}

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

@@ -0,0 +1,24 @@
+import { type OrderedTextSelection, type TextSelectionLineContent } from "./text-selection.js";
+/** Bound selected-source retention independently of history length and encoded payload size. */
+export declare const MAX_COPY_SOURCE_UNITS: number;
+export declare const MAX_COPY_ROWS = 65536;
+export type SelectionCopyPrompt = "first" | "continuation" | undefined;
+export interface SelectionCopyRow {
+    readonly text: string;
+    readonly prompt?: "first" | "continuation";
+}
+/** Immutable selected rows only; safe to transfer to an isolated text preparer. */
+export interface SelectionCopySnapshot {
+    readonly selection: OrderedTextSelection;
+    readonly revision: number;
+    /** Prompt copy/cut already supplies exact expanded text; do not apply transcript chrome stripping. */
+    readonly literal?: boolean;
+    readonly rows: readonly SelectionCopyRow[];
+    readonly sourceUnits: number;
+    readonly captureMs?: number;
+    readonly rejected?: "size";
+}
+/** Shares the viewport's semantic chrome exclusions with isolated copy preparation. */
+export declare function selectionCopyLineContent(text: string, prompt: SelectionCopyPrompt): TextSelectionLineContent;
+/** Extracts one snapshot row with the existing grapheme/newline policy; run expensive rows off-thread. */
+export declare function selectionCopyRowText(snapshot: Pick<SelectionCopySnapshot, "selection" | "literal">, row: SelectionCopyRow, index: number): string;

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

@@ -0,0 +1,39 @@
+import { textSelectionText, usefulTextLineContent } from "./text-selection.js";
+import { stripAnsi } from "./text.js";
+/** Bound selected-source retention independently of history length and encoded payload size. */
+export const MAX_COPY_SOURCE_UNITS = 32 * 1024 * 1024;
+export const MAX_COPY_ROWS = 65_536;
+/** Shares the viewport's semantic chrome exclusions with isolated copy preparation. */
+export function selectionCopyLineContent(text, prompt) {
+    const plain = stripAnsi(text);
+    if (prompt !== undefined) {
+        if (prompt === "first") {
+            const timestamp = /\s+\d{2}:\d{2}\s*$/.exec(plain);
+            if (timestamp !== null)
+                return usefulTextLineContent(plain.slice(0, timestamp.index), 3);
+        }
+        return usefulTextLineContent(plain, 3);
+    }
+    const from = plain.trim().length === 0 || (plain.startsWith(" ") && !plain.startsWith("  ")) ? 2 : 1;
+    if (plain.trim().length === 0)
+        return { from, to: from + 1 };
+    return usefulTextLineContent(plain, from);
+}
+/** Extracts one snapshot row with the existing grapheme/newline policy; run expensive rows off-thread. */
+export function selectionCopyRowText(snapshot, row, index) {
+    if (snapshot.literal)
+        return row.text;
+    let plain = stripAnsi(row.text);
+    if (row.prompt === "first") {
+        const timestamp = /\s+\d{2}:\d{2}\s*$/.exec(plain);
+        if (timestamp !== null)
+            plain = plain.slice(0, timestamp.index);
+    }
+    const from = row.prompt !== undefined ? 3 : plain.startsWith(" ") && !plain.startsWith("  ") ? 2 : 1;
+    // Performance: trailing chrome is excluded before extraction; full-row copy need not measure every grapheme.
+    plain = plain.trimEnd();
+    return textSelectionText({
+        start: { line: 0, column: index === snapshot.selection.start.line ? snapshot.selection.start.column : 0 },
+        end: { line: 0, column: index === snapshot.selection.end.line ? snapshot.selection.end.column : Number.MAX_SAFE_INTEGER },
+    }, [plain], () => ({ from }));
+}

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

@@ -0,0 +1,58 @@
+/**
+ * Shortcuts as declared data. Dispatch resolves a key through declarations
+ * rather than inline comparisons, conflicts are reported when the registry is
+ * assembled, and any listing is generated from the same declarations — so a
+ * listed shortcut is one dispatch would actually invoke.
+ */
+export interface ShortcutDeclaration {
+    /** Key token, for example `up`, `shift+down`, `ctrl+c`, or a literal character. */
+    readonly key: string;
+    /** Screen this applies to, or `global` for every screen. */
+    readonly scope: string;
+    readonly description: string;
+    /** Grouping label for the listing. */
+    readonly section?: string;
+    /**
+     * How this key reads on a screen's hint line, when it belongs there. Keys that
+     * do one thing together — the two arrows, enter and space — declare the same
+     * pair and are shown once.
+     */
+    readonly hint?: {
+        readonly keys: string;
+        readonly does: string;
+    };
+}
+export declare const GLOBAL_SCOPE = "global";
+export interface ShortcutConflict {
+    readonly key: string;
+    readonly scopes: readonly [string, string];
+    readonly descriptions: readonly [string, string];
+    readonly kind: "duplicate" | "shadowed";
+}
+export interface ShortcutRegistryResult {
+    readonly declarations: readonly ShortcutDeclaration[];
+    readonly conflicts: readonly ShortcutConflict[];
+}
+/**
+ * Assembles declarations and reports every key claimed twice in overlapping
+ * scopes. A screen claiming a global key is reported as shadowed rather than
+ * silently resolved by declaration order.
+ */
+export declare function assembleShortcuts(declarations: readonly ShortcutDeclaration[]): ShortcutRegistryResult;
+export declare function assertNoShortcutConflicts(result: ShortcutRegistryResult): void;
+/** Keeps shortcut dispatch and reader-facing listings derived from one ordered declaration set. */
+export declare class ShortcutRegistry<Action extends string = string> {
+    #private;
+    declare(declaration: ShortcutDeclaration, action: Action): void;
+    /** The action this key invokes in this scope, preferring a screen over a global. */
+    resolve(key: string, scope: string): Action | null;
+    assemble(): ShortcutRegistryResult;
+    /**
+     * The hint line, in the order the screen declares its keys. It is rendered from
+     * the same declarations dispatch reads, so a key cannot be described here and
+     * bound to something else, or bound and never mentioned.
+     */
+    hint(scope: string, separator?: string): string;
+    /** The listing, derived from the declarations dispatch reads. */
+    list(scope?: string): readonly ShortcutDeclaration[];
+}

package/dist/ui/components/shortcuts.js

@@ -0,0 +1,82 @@
+/**
+ * Shortcuts as declared data. Dispatch resolves a key through declarations
+ * rather than inline comparisons, conflicts are reported when the registry is
+ * assembled, and any listing is generated from the same declarations — so a
+ * listed shortcut is one dispatch would actually invoke.
+ */
+export const GLOBAL_SCOPE = "global";
+function overlaps(left, right) {
+    return left === right || left === GLOBAL_SCOPE || right === GLOBAL_SCOPE;
+}
+/**
+ * Assembles declarations and reports every key claimed twice in overlapping
+ * scopes. A screen claiming a global key is reported as shadowed rather than
+ * silently resolved by declaration order.
+ */
+export function assembleShortcuts(declarations) {
+    const conflicts = [];
+    for (let left = 0; left < declarations.length; left++) {
+        for (let right = left + 1; right < declarations.length; right++) {
+            const a = declarations[left];
+            const b = declarations[right];
+            if (a === undefined || b === undefined)
+                continue;
+            if (a.key !== b.key || !overlaps(a.scope, b.scope))
+                continue;
+            conflicts.push({
+                key: a.key,
+                scopes: [a.scope, b.scope],
+                descriptions: [a.description, b.description],
+                kind: a.scope === b.scope ? "duplicate" : "shadowed",
+            });
+        }
+    }
+    return { declarations: Object.freeze([...declarations]), conflicts: Object.freeze(conflicts) };
+}
+export function assertNoShortcutConflicts(result) {
+    const duplicate = result.conflicts.find(conflict => conflict.kind === "duplicate");
+    if (duplicate) {
+        throw new Error(`shortcut ${duplicate.key} is declared twice in scope ${duplicate.scopes[0]}: `
+            + `"${duplicate.descriptions[0]}" and "${duplicate.descriptions[1]}"`);
+    }
+}
+/** Keeps shortcut dispatch and reader-facing listings derived from one ordered declaration set. */
+export class ShortcutRegistry {
+    #declarations = [];
+    #actions = new Map();
+    declare(declaration, action) {
+        this.#declarations.push(declaration);
+        this.#actions.set(`${declaration.scope}\u0000${declaration.key}`, action);
+    }
+    /** The action this key invokes in this scope, preferring a screen over a global. */
+    resolve(key, scope) {
+        return this.#actions.get(`${scope}\u0000${key}`) ?? this.#actions.get(`${GLOBAL_SCOPE}\u0000${key}`) ?? null;
+    }
+    assemble() {
+        return assembleShortcuts(this.#declarations);
+    }
+    /**
+     * The hint line, in the order the screen declares its keys. It is rendered from
+     * the same declarations dispatch reads, so a key cannot be described here and
+     * bound to something else, or bound and never mentioned.
+     */
+    hint(scope, separator = " · ") {
+        const shown = new Map();
+        for (const declaration of this.#declarations) {
+            if (declaration.hint === undefined)
+                continue;
+            if (declaration.scope !== scope && declaration.scope !== GLOBAL_SCOPE)
+                continue;
+            if (!shown.has(declaration.hint.keys))
+                shown.set(declaration.hint.keys, declaration.hint.does);
+        }
+        return [...shown].map(([keys, does]) => `${keys} ${does}`).join(separator);
+    }
+    /** The listing, derived from the declarations dispatch reads. */
+    list(scope) {
+        const inScope = scope === undefined
+            ? this.#declarations
+            : this.#declarations.filter(declaration => declaration.scope === scope || declaration.scope === GLOBAL_SCOPE);
+        return Object.freeze([...inScope].sort((left, right) => (left.section ?? "").localeCompare(right.section ?? "") || left.key.localeCompare(right.key)));
+    }
+}

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

@@ -0,0 +1,28 @@
+/**
+ * Replaces the visible columns `[from, to)` of `line` with `span`, preserving
+ * the styling before it and re-asserting whatever was still open afterwards, so
+ * the tail keeps the colour it had. A wide character straddling either edge is
+ * replaced by spaces rather than split. Opt into the replaced cell's boundary
+ * style for background-preserving overlays; the span still owns its decoration.
+ */
+export declare function overlaySpan(line: string, from: number, to: number, span: string, options?: {
+    readonly inheritStartStyle?: boolean;
+}): string;
+/** Wraps visible columns `[from,to)` in an explicit OSC 8 hyperlink. */
+export declare function hyperlinkSgrSpan(line: string, from: number, to: number, target: string, widthOf?: (text: string) => number): string;
+/** Returns the OSC 8 target painted at a zero-based visible terminal column. */
+export declare function hyperlinkTargetAtColumn(line: string, targetColumn: number, widthOf?: (text: string) => number): string | undefined;
+/**
+ * Gives existing and bare web links explicit, tightly bounded OSC 8 regions so
+ * the terminal owns dotted-idle/solid-hover decoration without leaking hover
+ * state into cells repainted during scrolling.
+ */
+export declare function nativeHyperlinkStyle(line: string, color?: (text: string, target: string) => string): string;
+/**
+ * Held-button paint for terminal-native links. OSC 8 is removed so the terminal
+ * cannot switch a selected link to its solid hover underline. A dotted SGR
+ * underline preserves the idle appearance, and VS15 transiently breaks native
+ * plain-text URL detection without changing visible width.
+ */
+export declare function heldNativeHyperlinkStyle(line: string): string;
+export declare function backgroundSgrSpan(line: string, from: number, to: number, on?: string, off?: string, widthOf?: (text: string) => number): string;

package/dist/ui/components/spans.js

@@ -0,0 +1,266 @@
+import { displayWidth } from "./text.js";
+/**
+ * Ported from the A1 UI reference implementation (`core/presentation/spans.ts`).
+ * Writing over part of a rendered row is not string slicing: the row carries
+ * styling and hyperlink sequences, and cutting through them either loses the
+ * styling of the tail or leaks the span's own reset into it.
+ */
+const ANSI_SEQUENCE = "\\u001b(?:\\[[0-?]*[ -/]*[@-~]|[\\]_][^\\u0007\\u001b]*(?:\\u0007|\\u001b\\\\|$))";
+const ANSI_SPLIT = new RegExp(`(${ANSI_SEQUENCE})`);
+const HYPERLINK = /^\]8;;([^]*)(?:|\\)?$/;
+const HYPERLINK_OFF = "]8;;\\";
+const SGR = /^\[[0-9;]*m$/;
+const BARE_URL = /https?:\/\/[^\s\u0000-\u001f\u007f<>"']+/giu;
+const TRAILING_URL_PUNCTUATION = /[.,;:!?]/u;
+const GRAPHEMES = new Intl.Segmenter(undefined, { granularity: "grapheme" });
+/**
+ * Replaces the visible columns `[from, to)` of `line` with `span`, preserving
+ * the styling before it and re-asserting whatever was still open afterwards, so
+ * the tail keeps the colour it had. A wide character straddling either edge is
+ * replaced by spaces rather than split. Opt into the replaced cell's boundary
+ * style for background-preserving overlays; the span still owns its decoration.
+ */
+export function overlaySpan(line, from, to, span, options = {}) {
+    let head = "";
+    let replay = "";
+    let tail = "";
+    let column = 0;
+    let hyperlinkOpen = false;
+    for (const token of line.split(ANSI_SPLIT)) {
+        if (!token)
+            continue;
+        if (token.startsWith("")) {
+            // Protocol: image transfers are one-shot commands, not styling to replay after an overlay.
+            if (token.startsWith("\u001b_G") || token.startsWith("\u001b]1337;File=")) {
+                if (column >= to)
+                    tail += token;
+                else
+                    head += token;
+                continue;
+            }
+            if (column >= to) {
+                tail += token;
+                continue;
+            }
+            if (column < from || (options.inheritStartStyle === true && column === from)) {
+                head += token;
+                const link = HYPERLINK.exec(token);
+                if (link)
+                    hyperlinkOpen = (link[1] ?? "").length > 0;
+            }
+            // Invariant: re-assert everything still active: the span's own reset clobbers the tail.
+            replay += token;
+            continue;
+        }
+        for (const { segment } of GRAPHEMES.segment(token)) {
+            const width = displayWidth(segment);
+            if (column + width <= from)
+                head += segment;
+            else if (column >= to)
+                tail += segment;
+            else if (column < from)
+                head += " ".repeat(from - column);
+            else if (column + width > to)
+                tail += " ".repeat(column + width - to);
+            column += width;
+        }
+    }
+    if (column < from)
+        head += " ".repeat(from - column);
+    return head + (hyperlinkOpen ? HYPERLINK_OFF : "") + span + replay + tail;
+}
+/** Wraps visible columns `[from,to)` in an explicit OSC 8 hyperlink. */
+export function hyperlinkSgrSpan(line, from, to, target, widthOf = displayWidth) {
+    const on = `\u001b]8;;${target}\u001b\\`;
+    const off = "\u001b]8;;\u001b\\";
+    let output = "";
+    let column = 0;
+    let inside = false;
+    for (const token of line.split(ANSI_SPLIT)) {
+        if (!token)
+            continue;
+        if (token.startsWith("\u001b")) {
+            output += token;
+            continue;
+        }
+        for (const { segment } of GRAPHEMES.segment(token)) {
+            const shouldBeInside = column >= from && column < to;
+            if (shouldBeInside !== inside) {
+                output += shouldBeInside ? on : off;
+                inside = shouldBeInside;
+            }
+            output += segment;
+            column += widthOf(segment);
+        }
+    }
+    if (inside)
+        output += off;
+    return output;
+}
+/** Returns the OSC 8 target painted at a zero-based visible terminal column. */
+export function hyperlinkTargetAtColumn(line, targetColumn, widthOf = displayWidth) {
+    if (targetColumn < 0)
+        return undefined;
+    let hyperlinkTarget;
+    let column = 0;
+    for (const token of line.split(ANSI_SPLIT)) {
+        if (!token)
+            continue;
+        const link = HYPERLINK.exec(token);
+        if (link) {
+            hyperlinkTarget = (link[1] ?? "") || undefined;
+            continue;
+        }
+        if (token.startsWith("\u001b"))
+            continue;
+        for (const { segment } of GRAPHEMES.segment(token)) {
+            const width = widthOf(segment);
+            if (targetColumn >= column && targetColumn < column + width)
+                return hyperlinkTarget;
+            column += width;
+        }
+    }
+    return undefined;
+}
+/**
+ * Gives existing and bare web links explicit, tightly bounded OSC 8 regions so
+ * the terminal owns dotted-idle/solid-hover decoration without leaking hover
+ * state into cells repainted during scrolling.
+ */
+export function nativeHyperlinkStyle(line, color = text => text) {
+    let hyperlinkTarget;
+    let sgrReplay = "";
+    let output = "";
+    for (const token of line.split(ANSI_SPLIT)) {
+        if (!token)
+            continue;
+        const link = HYPERLINK.exec(token);
+        if (link) {
+            hyperlinkTarget = (link[1] ?? "") || undefined;
+            output += token;
+            continue;
+        }
+        if (!token.startsWith("\u001b")) {
+            output += hyperlinkTarget === undefined
+                ? decorateBareUrls(token, color, sgrReplay)
+                : color(token, hyperlinkTarget);
+            continue;
+        }
+        if (SGR.test(token)) {
+            if (token === "\u001b[0m")
+                sgrReplay = token;
+            else
+                sgrReplay += token;
+        }
+        if (hyperlinkTarget === undefined || (token !== "\u001b[4m" && token !== "\u001b[24m"))
+            output += token;
+    }
+    return hyperlinkTarget === undefined ? output : output + HYPERLINK_OFF;
+}
+/**
+ * Held-button paint for terminal-native links. OSC 8 is removed so the terminal
+ * cannot switch a selected link to its solid hover underline. A dotted SGR
+ * underline preserves the idle appearance, and VS15 transiently breaks native
+ * plain-text URL detection without changing visible width.
+ */
+export function heldNativeHyperlinkStyle(line) {
+    let hyperlinkTarget;
+    let fileDetectorBroken = false;
+    let output = "";
+    for (const token of line.split(ANSI_SPLIT)) {
+        if (!token)
+            continue;
+        const link = HYPERLINK.exec(token);
+        if (link) {
+            const nextTarget = (link[1] ?? "") || undefined;
+            if ((nextTarget !== undefined) !== (hyperlinkTarget !== undefined)) {
+                output += nextTarget === undefined ? "\u001b[24m" : "\u001b[4:4m";
+            }
+            if (nextTarget !== hyperlinkTarget)
+                fileDetectorBroken = false;
+            hyperlinkTarget = nextTarget;
+            continue;
+        }
+        if (token.startsWith("\u001b")) {
+            output += token;
+            // Protocol: foreground helpers may reset every SGR attribute; restore the held
+            // dotted underline without disturbing the source colour or intensity.
+            if (hyperlinkTarget !== undefined && SGR.test(token))
+                output += "\u001b[4:4m";
+            continue;
+        }
+        if (hyperlinkTarget === undefined) {
+            output += token;
+            continue;
+        }
+        let painted = token.replaceAll("https://", "https:\uFE0E//").replaceAll("http://", "http:\uFE0E//");
+        // Platform: Windows Terminal also detects file-link labels such as package.json and
+        // D:/work/file.ts after OSC 8 is removed. Break that detector once inside
+        // the paint-only label; semantic transcript text remains untouched.
+        if (!fileDetectorBroken && /^file:/iu.test(hyperlinkTarget)) {
+            const firstVisible = /\S/u.exec(painted);
+            if (firstVisible?.index !== undefined) {
+                const index = firstVisible.index;
+                const codePoint = painted.codePointAt(index) ?? 0;
+                const end = index + (codePoint > 0xffff ? 2 : 1);
+                painted = `${painted.slice(0, end)}\uFE0E${painted.slice(end)}`;
+                fileDetectorBroken = true;
+            }
+        }
+        output += painted;
+    }
+    return hyperlinkTarget === undefined ? output : `${output}\u001b[24m`;
+}
+function decorateBareUrls(text, color, sgrReplay) {
+    return text.replace(BARE_URL, candidate => {
+        const { target, trailing } = splitUrlTrailingPunctuation(candidate);
+        if (target.length === 0)
+            return candidate;
+        return `\u001b]8;;${target}\u001b\\\u001b[24m${color(target, target)}${HYPERLINK_OFF}${sgrReplay}${trailing}`;
+    });
+}
+function splitUrlTrailingPunctuation(candidate) {
+    let end = candidate.length;
+    while (end > 0 && TRAILING_URL_PUNCTUATION.test(candidate[end - 1] ?? ""))
+        end -= 1;
+    for (const [opening, closing] of [["(", ")"], ["[", "]"], ["{", "}"]]) {
+        while (candidate.slice(0, end).endsWith(closing)
+            && occurrences(candidate.slice(0, end), closing) > occurrences(candidate.slice(0, end), opening)) {
+            end -= 1;
+        }
+    }
+    return { target: candidate.slice(0, end), trailing: candidate.slice(end) };
+}
+function occurrences(text, value) {
+    return text.split(value).length - 1;
+}
+export function backgroundSgrSpan(line, from, to, on = "\u001b[47m", off = "\u001b[49m", widthOf = displayWidth) {
+    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 += widthOf(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[];