@timurproko/a1 0.2.7-dev.1221 → 0.2.7-dev.1225

package/dist/composition/settings-route-host.js

@@ -18,7 +18,7 @@ export function createOwnedRouteHost(settings, references, options = {}) {
             const title = session ? "Session Info" : changelog ? input ? "What's New" : "Changelog" : HOTKEYS_TITLE;
             const document = session ? references.session() : changelog ? references.changelog(input) : references.hotkeys();
             const pinned = options.tabRoute === route;
-            return deferredSurface(route, title, () => loadReferenceSurface(settings, route, title, document, pinned));
+            return deferredSurface(route, title, () => loadReferenceSurface(settings, route, title, document, pinned, options));
         },
     };
 }
@@ -63,9 +63,10 @@ function deferredSurface(id, label, load) {
     };
 }
 async function loadSettingsSurface(settings, options) {
-    const [{ SettingsApp }, { createSettingsSearchInputFactory }] = await Promise.all([
+    const [{ SettingsApp }, { createSettingsSearchInputFactory }, { renderFloatingDialogSurface, renderFloatingMenuSurface }] = await Promise.all([
         import("../features/owned-ui/settings-app.js"),
         import("./settings-search-input.js"),
+        import("../ui/components/dialog-panel.js"),
     ]);
     const pinned = options.tabRoute === SETTINGS_ROUTE;
     const searchInputFactory = createSettingsSearchInputFactory({
@@ -78,14 +79,19 @@ async function loadSettingsSurface(settings, options) {
         pinned,
         searchInputFactory,
         configurePlusMenu: options.configurePlusMenu ?? null,
+        dialogPanel: text => renderFloatingDialogSurface(text, piTheme().getColorMode()),
         ...(options.copyText === undefined ? {} : { copyText: options.copyText }),
-    }), !pinned, true);
+    }), !pinned, true, text => renderFloatingMenuSurface(text, piTheme().getColorMode()));
 }
-async function loadReferenceSurface(settings, route, title, document, pinned) {
+async function loadReferenceSurface(settings, route, title, document, pinned, options) {
     const id = route;
-    // Rationale: the app module and the document load together, so a document that fails
-    // to render is reported by the placeholder rather than by a screen that never fills.
-    const [{ ReferenceScreenApp }, content] = await Promise.all([import("../features/owned-ui/reference-screen-app.js"), document]);
+    const [{ ReferenceScreenApp }, content, selection] = await Promise.all([
+        import("../features/owned-ui/reference-screen-app.js"),
+        document,
+        route === CHANGELOG_ROUTE
+            ? import("./reference-selection-options.js").then(module => module.createReferenceSelectionOptions(settings.file, options.copyText))
+            : undefined,
+    ]);
     return hostApp(id, route, () => new ReferenceScreenApp({
         id,
         title,
@@ -96,9 +102,10 @@ async function loadReferenceSurface(settings, route, title, document, pinned) {
             scrollbarSpeed: settings.value("scrollbarSpeed"),
         }),
         pinned,
-    }), !pinned);
+        ...(selection === undefined ? {} : { selection }),
+    }), !pinned, selection !== undefined);
 }
-async function hostApp(id, route, create, closeOnInterrupt = true, appInputBeforeInterrupt = false) {
+async function hostApp(id, route, create, closeOnInterrupt = true, appInputBeforeInterrupt = false, panel = text => text) {
     const [{ UiAppHost }, { UiAppRegistry }] = await Promise.all([
         import("../ui/apps/host.js"),
         import("../ui/apps/registry.js"),
@@ -114,7 +121,7 @@ async function hostApp(id, route, create, closeOnInterrupt = true, appInputBefor
         registry,
         closeOnInterrupt,
         appInputBeforeInterrupt,
-        theme: pinnedTheme(),
+        theme: pinnedTheme(panel),
         surface: {
             size: () => size,
             requestRender: () => onRender(),
@@ -143,8 +150,7 @@ async function hostApp(id, route, create, closeOnInterrupt = true, appInputBefor
         onExitRequested: listener => { onExit = listener; },
     };
 }
-/** Maps A1 UI tokens onto the pinned Pi theme so owned screens match the shell. */
-function pinnedTheme() {
+function pinnedTheme(panel) {
     return {
         fg: (token, text) => piTheme().fg(token, text),
         bold: (text) => piTheme().bold(text),
@@ -152,6 +158,6 @@ function pinnedTheme() {
         accentPreview: (color, text) => renderPiAccentPreview(color, text),
         disabled: (text) => faint(piTheme().fg("dim", text)),
         highlight: (text) => piTheme().bg("selectedBg", text),
-        panel: (text) => `\u001b[48;2;55;55;55m${text}\u001b[49m`,
+        panel,
     };
 }

package/dist/composition/settings-search-input.js

@@ -3,6 +3,7 @@ import { createPiShellEditor } from "../integrations/pi/components/shell-editor-
 import { piShellTruncateToWidth, piShellVisibleWidth, } from "../integrations/pi/components/shell-shared-facade.js";
 import { backgroundSgrSpan } from "../ui/components/spans.js";
 import { caretCell } from "../ui/components/line-input.js";
+import { paintTextSelection } from "../ui/components/text-selection.js";
 import { PromptInput } from "../ui/components/prompt-input.js";
 /** Builds Settings search from the same configurable owned editor used by the agent prompt. */
 export function createSettingsSearchInputFactory(options = {}) {
@@ -32,7 +33,9 @@ function createSettingsSearchInput(surface, options) {
         requestRender: surface.requestRender,
         onSubmit: () => { },
         onCopyText: text => surface.copyText(text),
-        paintEditorSelection: (line, from, to, atomic) => backgroundSgrSpan(line, from, to, atomic ? "\u001b[7m" : "\u001b[27m\u001b[48;2;38;79;120m", atomic ? "\u001b[27m" : "\u001b[49m", piShellVisibleWidth),
+        paintEditorSelection: (line, from, to, atomic) => atomic
+            ? backgroundSgrSpan(line, from, to, "\u001b[7m", "\u001b[27m", piShellVisibleWidth)
+            : paintTextSelection(line, from, to, piShellVisibleWidth, true),
         promptPresentation: {
             input: new PromptInput({ fg: (token, text) => surface.theme.fg(token, text) }, {
                 measure: piShellVisibleWidth,

package/dist/composition/utility-tab.js

@@ -73,8 +73,10 @@ function createUtilityRouteHost(options, settings, keybindings, cwd, agentDir) {
         agentDir,
         cwd,
         copyText: text => {
-            if (Buffer.byteLength(text) <= MAX_CLIPBOARD_TEXT_BYTES)
-                void writeSystemClipboardText(text).catch(() => { });
+            if (Buffer.byteLength(text) > MAX_CLIPBOARD_TEXT_BYTES)
+                return false;
+            void writeSystemClipboardText(text).catch(() => { });
+            return true;
         },
     }));
 }

package/dist/features/launch/intent.js

@@ -1,8 +1,8 @@
 import { sessionSelectionArguments } from "../../foundation/lifecycle/index.js";
 export { parseSessionSelection } from "../../foundation/lifecycle/index.js";
 export function interactiveLaunchIntent(profileId, sessionSelection, launchMode = profileId === "a1" ? "tabs" : "solo") {
-    if (sessionSelection !== undefined && (profileId !== "a1" || launchMode === "solo")) {
-        throw new Error("session selection requires the normal tabbed A1 launch");
+    if (sessionSelection !== undefined && profileId !== "a1") {
+        throw new Error("session selection requires the A1 profile");
     }
     if (profileId === "pi" && launchMode !== "solo")
         throw new Error("the Pi comparison launch is always solo");

package/dist/features/owned-ui/plus-menu-dialog.js

@@ -1,9 +1,15 @@
-import { LineInput, displayWidth, handleLineInputKey, renderInputRow, truncateToWidth, } from "../../ui/components/index.js";
+import { LineInput, handleLineInputKey, padToWidth, renderInputRow, renderShortcutHintsWithClose, truncateToWidth, } from "../../ui/components/index.js";
 /** The A1 setting holding the tab kinds the strip's `+` offers. */
 export const PLUS_MENU_SETTING_ID = "tabBarPlusMenu";
 const TITLE = "Plus Menu";
 const DESCRIPTION = "Choose what the + button in the tab bar can add.";
-const HINT = "Type search · ↑↓ navigate · Space toggle · Esc close";
+const HINTS = [
+    { key: "Type", action: "search" },
+    { key: "↑↓", action: "navigate" },
+    { key: "Space", action: "toggle" },
+    { key: "esc", action: "close" },
+];
+const PADDING_X = 2;
 /**
  * The plus-menu dialog: every tab kind with `●` when `+` offers it and `○` when not, filtered by typed
  * text. It owns only its filter and the row in hand; the enabled record and its saving stay with the
@@ -41,36 +47,38 @@ export class PlusMenuDialog {
         return "handled";
     }
     lines(enabled, width, theme) {
-        const rule = theme.fg("border", "─".repeat(Math.max(0, width)));
-        const inset = width > 0 ? " " : "";
-        const contentWidth = Math.max(0, width - inset.length);
-        const row = (painted, raw) => {
-            const clipped = truncateToWidth(painted, contentWidth);
-            return `${inset}${clipped}${" ".repeat(Math.max(0, contentWidth - displayWidth(raw)))}`;
+        const frameWidth = Math.max(0, width);
+        const left = Math.min(PADDING_X, frameWidth);
+        const right = Math.min(PADDING_X, frameWidth - left);
+        const contentWidth = Math.max(0, frameWidth - left - right);
+        const blank = " ".repeat(frameWidth);
+        const row = (painted, selected = false) => {
+            const content = padToWidth(truncateToWidth(painted, contentWidth), contentWidth);
+            const rightPadding = " ".repeat(right);
+            return `${" ".repeat(left)}${selected ? theme.highlight(content) : content}${selected ? theme.panel(rightPadding) : rightPadding}`;
         };
         const shown = this.shown();
         const index = Math.min(this.#index, Math.max(0, shown.length - 1));
         const rows = shown.length === 0
-            ? [row(theme.fg("dim", "No tabs match"), "No tabs match")]
+            ? [row(theme.fg("dim", "No tabs match"))]
             : shown.map((kind, position) => {
                 const selected = position === index;
                 const cursor = selected ? "→ " : "  ";
                 const marker = enabled[kind.key] === true ? "●" : "○";
-                const raw = `${cursor}${marker} ${kind.label}`;
                 const content = `${selected ? theme.fg("accent", cursor) : cursor}${theme.fg("text", marker)} ${theme.fg("text", kind.label)}`;
-                return row(selected ? theme.highlight(content) : content, raw);
+                return row(content, selected);
             });
         return [
-            rule,
-            row(theme.bold(theme.fg("accent", TITLE)), TITLE),
-            row(theme.fg("dim", DESCRIPTION), DESCRIPTION),
-            "",
-            ...renderInputRow(this.#filter, width, { ruled: false, promptGlyph: "> ", theme }).lines,
-            "",
+            blank,
+            row(theme.bold(theme.fg("accent", TITLE))),
+            row(theme.fg("dim", DESCRIPTION)),
+            blank,
+            ...renderInputRow(this.#filter, contentWidth, { ruled: false, promptGlyph: "> ", theme }).lines.map(line => row(line)),
+            blank,
             ...rows,
-            "",
-            row(theme.fg("dim", HINT), HINT),
-            rule,
+            blank,
+            row(renderShortcutHintsWithClose(HINTS, theme, contentWidth)),
+            blank,
         ];
     }
 }

package/dist/features/owned-ui/reference-document-selection.d.ts

@@ -0,0 +1,30 @@
+import { type PaneMouseEvent, type UiTheme } from "../../ui/components/index.js";
+export interface ReferenceDocumentSelectionOptions {
+    readonly copyOnSelect: () => boolean;
+    readonly copyText: (text: string) => boolean | void;
+}
+interface ReferenceSelectionFrame {
+    readonly bodyRowStart: number;
+    readonly contentWidth: number;
+    readonly documentRows: readonly string[];
+    readonly visibleDocumentRows: readonly (number | undefined)[];
+}
+/** Selection state for an opted-in read-only reference document. */
+export declare class ReferenceDocumentSelection {
+    #private;
+    constructor(options: ReferenceDocumentSelectionOptions);
+    get selecting(): boolean;
+    get hasSelection(): boolean;
+    updateFrame(frame: ReferenceSelectionFrame): void;
+    paintVisibleRow(visibleRow: number, line: string, theme: UiTheme): string;
+    handleInput(data: string): {
+        readonly consumed: boolean;
+        readonly cleared: boolean;
+    };
+    handleMouse(event: PaneMouseEvent, requestRender?: () => void): {
+        readonly consumed: boolean;
+        readonly changed: boolean;
+    };
+    clear(): void;
+}
+export {};

package/dist/features/owned-ui/reference-document-selection.js

@@ -0,0 +1,179 @@
+import { COPY_ACKNOWLEDGEMENT_DURATION_MS, copyAcknowledgementText, displayWidth, extendTextSelection, orderedTextSelection, overlaySpan, paintTextSelection, padToWidth, pressTextSelection, releaseTextSelection, stripAnsi, textSelectionLineExtendColumn, textSelectionPointAt, textSelectionText, truncateToWidth, usefulTextLineContent, } from "../../ui/components/index.js";
+const INTERRUPT = "\u0003";
+class CopyAcknowledgement {
+    #message;
+    #timer;
+    paint(line, finalRow, width, theme) {
+        if (!finalRow || this.#message === undefined || width === 0)
+            return line;
+        const message = truncateToWidth(theme.fg("accent", this.#message), width);
+        return overlaySpan(line, width - displayWidth(message), width, message, { inheritStartStyle: true });
+    }
+    show(characters, requestRender) {
+        this.#message = copyAcknowledgementText(characters);
+        this.#clearTimer();
+        this.#timer = setTimeout(() => {
+            this.#timer = undefined;
+            this.#message = undefined;
+            requestRender();
+        }, COPY_ACKNOWLEDGEMENT_DURATION_MS);
+        this.#timer.unref?.();
+        requestRender();
+    }
+    clear() {
+        this.#clearTimer();
+        this.#message = undefined;
+    }
+    #clearTimer() {
+        if (this.#timer !== undefined)
+            clearTimeout(this.#timer);
+        this.#timer = undefined;
+    }
+}
+/** Selection state for an opted-in read-only reference document. */
+export class ReferenceDocumentSelection {
+    #copyOnSelect;
+    #copyText;
+    #selection;
+    #click;
+    #frame;
+    #acknowledgement = new CopyAcknowledgement();
+    constructor(options) {
+        this.#copyOnSelect = options.copyOnSelect;
+        this.#copyText = options.copyText;
+    }
+    get selecting() {
+        return this.#selection?.selecting === true;
+    }
+    get hasSelection() {
+        return orderedTextSelection(this.#selection) !== undefined;
+    }
+    updateFrame(frame) {
+        const previous = this.#frame;
+        if (this.#selection !== undefined && previous !== undefined && !selectionStillMaps(this.#selection, previous.documentRows, frame.documentRows)) {
+            this.#selection = undefined;
+            this.#click = undefined;
+        }
+        this.#frame = frame;
+    }
+    paintVisibleRow(visibleRow, line, theme) {
+        const frame = this.#frame;
+        const documentRow = frame?.visibleDocumentRows[visibleRow];
+        const ordered = orderedTextSelection(this.#selection);
+        const width = frame?.contentWidth ?? 0;
+        let painted = padToWidth(line, width);
+        if (documentRow !== undefined && ordered !== undefined
+            && documentRow >= ordered.start.line && documentRow <= ordered.end.line) {
+            const from = documentRow === ordered.start.line ? ordered.start.column : 0;
+            const to = documentRow === ordered.end.line ? ordered.end.column : width;
+            painted = paintTextSelection(painted, Math.max(0, from), Math.min(width, to));
+        }
+        return this.#acknowledgement.paint(painted, visibleRow === (frame?.visibleDocumentRows.length ?? 0) - 1, width, theme);
+    }
+    handleInput(data) {
+        if (data === INTERRUPT && this.hasSelection) {
+            this.#submitSelection();
+            this.#selection = undefined;
+            this.#click = undefined;
+            return { consumed: true, cleared: true };
+        }
+        if (this.#selection === undefined)
+            return { consumed: false, cleared: false };
+        this.#selection = undefined;
+        this.#click = undefined;
+        return { consumed: false, cleared: true };
+    }
+    handleMouse(event, requestRender) {
+        const frame = this.#frame;
+        if (frame === undefined)
+            return { consumed: false, changed: false };
+        if (event.kind === "motion" && this.selecting) {
+            const row = documentRowAt(frame, event.row, true);
+            if (row === undefined)
+                return { consumed: true, changed: false };
+            this.#extend(row, event.column);
+            return { consumed: true, changed: true };
+        }
+        if (event.kind === "release" && this.selecting) {
+            this.#selection = releaseTextSelection(this.#selection);
+            const copiedCharacters = this.hasSelection && this.#copyOnSelect() ? this.#submitSelection() : undefined;
+            if (copiedCharacters !== undefined && requestRender !== undefined) {
+                this.#acknowledgement.show(copiedCharacters, requestRender);
+            }
+            return { consumed: true, changed: true };
+        }
+        if (event.kind !== "press" || event.button !== 0)
+            return { consumed: false, changed: false };
+        const row = documentRowAt(frame, event.row, false);
+        if (row === undefined || event.column < 1 || event.column > frame.contentWidth) {
+            const changed = this.#selection !== undefined;
+            this.#selection = undefined;
+            this.#click = undefined;
+            return { consumed: false, changed };
+        }
+        const source = frame.documentRows[row] ?? "";
+        const pressed = pressTextSelection({
+            line: row,
+            column: event.column,
+            contentWidth: frame.contentWidth,
+            lineText: source,
+            lineContent: usefulTextLineContent(source),
+            ...(this.#click === undefined ? {} : { previousClick: this.#click }),
+        });
+        this.#selection = pressed.selection;
+        this.#click = pressed.click;
+        return { consumed: true, changed: true };
+    }
+    clear() {
+        this.#selection = undefined;
+        this.#click = undefined;
+        this.#frame = undefined;
+        this.#acknowledgement.clear();
+    }
+    #extend(row, column) {
+        const selection = this.#selection;
+        const frame = this.#frame;
+        if (selection?.selecting !== true || frame === undefined)
+            return;
+        const targetColumn = selection.fullRow
+            ? textSelectionLineExtendColumn(selection, row, frame.contentWidth)
+            : Math.max(1, Math.min(column, frame.contentWidth));
+        this.#selection = extendTextSelection(selection, selection.fullRow
+            ? { line: row, column: targetColumn }
+            : textSelectionPointAt(row, targetColumn, frame.documentRows[row] ?? ""));
+    }
+    #submitSelection() {
+        const frame = this.#frame;
+        const ordered = orderedTextSelection(this.#selection);
+        if (frame === undefined || ordered === undefined)
+            return undefined;
+        const text = textSelectionText(ordered, frame.documentRows, line => usefulTextLineContent(frame.documentRows[line] ?? "")).trim();
+        if (text.length === 0 || this.#copyText(text) === false)
+            return undefined;
+        return text.length;
+    }
+}
+function documentRowAt(frame, screenRow, clampToDocument) {
+    const visible = frame.visibleDocumentRows;
+    let index = screenRow - frame.bodyRowStart;
+    if (!clampToDocument)
+        return visible[index];
+    index = Math.max(0, Math.min(index, visible.length - 1));
+    if (visible[index] !== undefined)
+        return visible[index];
+    const defined = visible.flatMap(row => row === undefined ? [] : [row]);
+    if (defined.length === 0)
+        return undefined;
+    return screenRow < frame.bodyRowStart ? defined[0] : defined.at(-1);
+}
+function selectionStillMaps(selection, previous, next) {
+    const first = Math.min(selection.anchor.line, selection.head.line);
+    const last = Math.max(selection.anchor.line, selection.head.line);
+    if (last >= previous.length || last >= next.length)
+        return false;
+    for (let line = first; line <= last; line += 1) {
+        if (stripAnsi(previous[line] ?? "") !== stripAnsi(next[line] ?? ""))
+            return false;
+    }
+    return true;
+}

package/dist/features/owned-ui/reference-screen-app.d.ts

@@ -1,4 +1,5 @@
 import type { OwnedUiViewportSettings } from "../../contracts/owned-ui/index.js";
+import { type ReferenceDocumentSelectionOptions } from "./reference-document-selection.js";
 import type { AppHostServices, UiApp } from "../../ui/apps/index.js";
 import { ShortcutRegistry, type PaneInputResult, type PaneMouseEvent, type PaneRect } from "../../ui/components/index.js";
 type Action = "up" | "down" | "page-up" | "page-down" | "first" | "last" | "close";
@@ -26,6 +27,8 @@ export interface ReferenceScreenOptions {
     readonly scrollSettings: () => OwnedUiViewportSettings;
     /** The screen is a resident tab, such as the Changelog tab: it offers no screen-level close. */
     readonly pinned?: boolean;
+    /** Enables owned text selection for document routes that explicitly opt in. */
+    readonly selection?: ReferenceDocumentSelectionOptions;
 }
 /**
  * Presents one read-only document full screen between two accent rules: the bold
@@ -42,6 +45,6 @@ export declare class ReferenceScreenApp implements UiApp {
     onClose(_host: AppHostServices): void;
     render(rect: PaneRect, host: AppHostServices): readonly string[];
     onInput(data: string, host: AppHostServices): PaneInputResult;
-    onMouse(event: PaneMouseEvent, _host: AppHostServices): PaneInputResult;
+    onMouse(event: PaneMouseEvent, host: AppHostServices): PaneInputResult;
 }
 export {};

package/dist/features/owned-ui/reference-screen-app.js

@@ -1,3 +1,4 @@
+import { ReferenceDocumentSelection } from "./reference-document-selection.js";
 import { DIALOG_CLOSE_SHORTCUT_HINT } from "../../contracts/presentation/index.js";
 import { GLOBAL_SCOPE, PLAIN_THEME, RAIL_COLUMNS, ShortcutRegistry, ScrollbarRails, assertNoShortcutConflicts, displayWidth, layoutList, padToWidth, renderGroupHeader, renderShortcutHintsWithClose, scrollForTrackPage, scrollbarGeometry, scrollbarPresentation, scrollbarWheelRows, truncateToWidth, withScrollbarRail, } from "../../ui/components/index.js";
 const SCOPE = "reference-screen";
@@ -49,6 +50,7 @@ export class ReferenceScreenApp {
     #document;
     #scrollSettings;
     #pinned;
+    #selection;
     #scroll = 0;
     #interruptArmed = false;
     #failure = null;
@@ -58,7 +60,6 @@ export class ReferenceScreenApp {
     #rails = new ScrollbarRails();
     // Rationale: the rail as drawn in the last frame, or null when nothing can be pointed at.
     #railFrame = null;
-    #bodyHeight = 0;
     // Invariant: a scroll lights the rail until this time; the timer repaints once it has passed.
     #activeUntil = 0;
     #activityTimer;
@@ -69,6 +70,7 @@ export class ReferenceScreenApp {
         this.#document = options.document;
         this.#scrollSettings = options.scrollSettings;
         this.#pinned = options.pinned === true;
+        this.#selection = options.selection === undefined ? undefined : new ReferenceDocumentSelection(options.selection);
     }
     onActivate(host) {
         const ready = this.#document.ready;
@@ -85,6 +87,7 @@ export class ReferenceScreenApp {
     onClose(_host) {
         this.#clearActivityTimer();
         this.#rails.clear();
+        this.#selection?.clear();
     }
     render(rect, host) {
         const theme = host.theme ?? PLAIN_THEME;
@@ -93,9 +96,9 @@ export class ReferenceScreenApp {
         const reservesRail = settings.scrollbarAppearance !== "hidden";
         const contentWidth = reservesRail ? Math.max(0, rect.width - RAIL_COLUMNS) : rect.width;
         const bodyHeight = Math.max(0, rect.height - HEADER_ROWS - FOOTER_ROWS);
-        this.#bodyHeight = bodyHeight;
         const content = this.#content(contentWidth, theme);
         const body = [];
+        const visibleDocumentRows = [];
         let contentLength;
         let viewportLength = bodyHeight;
         if (content.kind === "sections") {
@@ -115,10 +118,22 @@ export class ReferenceScreenApp {
             for (let index = this.#scroll; index < this.#scroll + bodyHeight; index++) {
                 const row = content.rows[index] ?? "";
                 body.push(displayWidth(row) > contentWidth ? truncateToWidth(row, contentWidth) : row);
+                visibleDocumentRows.push(index < content.rows.length ? index : undefined);
             }
         }
         while (body.length < bodyHeight)
             body.push("");
+        while (visibleDocumentRows.length < bodyHeight)
+            visibleDocumentRows.push(undefined);
+        this.#selection?.updateFrame({
+            bodyRowStart: HEADER_ROWS + 1,
+            contentWidth,
+            documentRows: content.kind === "flat" ? content.rows : [],
+            visibleDocumentRows,
+        });
+        const paintedBody = this.#selection === undefined
+            ? body
+            : body.map((row, index) => this.#selection.paintVisibleRow(index, row, theme));
         const now = Date.now();
         // Rationale: every way of scrolling ends in this frame, so a moved document is noticed here
         // once rather than at each wheel, drag, and key branch.
@@ -138,7 +153,7 @@ export class ReferenceScreenApp {
         this.#railFrame = reservesRail && geometry !== null
             ? { rail: { key: this.id, column: rect.width, rowStart: HEADER_ROWS, trackHeight: geometry.trackHeight }, geometry, page: viewportLength }
             : null;
-        const withRail = withScrollbarRail(body.slice(0, bodyHeight), geometry, contentWidth, theme, { presentation });
+        const withRail = withScrollbarRail(paintedBody.slice(0, bodyHeight), geometry, contentWidth, theme, { presentation });
         const hint = this.#interruptArmed
             ? theme.fg("dim", " press ctrl+c again to exit a1")
             : renderShortcutHintsWithClose(this.#hintEntries(), theme, rect.width, 1);
@@ -150,11 +165,19 @@ export class ReferenceScreenApp {
         return frame.slice(0, rect.height).concat(Array(Math.max(0, rect.height - frame.length)).fill(""));
     }
     onInput(data, host) {
+        const explicitCopy = data === "\u0003" ? this.#selection?.handleInput(data) : undefined;
+        if (explicitCopy?.consumed === true)
+            return { consumed: true };
         const action = REFERENCE_SCREEN_SHORTCUTS.resolve(KEYS[data] ?? data, SCOPE);
-        if (action === null)
+        if (action === null) {
+            const cleared = explicitCopy?.cleared ?? (this.#selection?.handleInput(data).cleared === true);
+            if (cleared)
+                host.requestRender();
             return { consumed: false };
+        }
         switch (action) {
             case "close":
+                this.#selection?.handleInput(data);
                 if (!this.#pinned)
                     host.close();
                 return { consumed: true };
@@ -165,10 +188,10 @@ export class ReferenceScreenApp {
                 this.#scrollBy(1);
                 return { consumed: true };
             case "page-up":
-                this.#scrollBy(-Math.max(1, this.#bodyHeight));
+                this.#scrollBy(-Math.max(1, host.getSize().height - HEADER_ROWS - FOOTER_ROWS));
                 return { consumed: true };
             case "page-down":
-                this.#scrollBy(Math.max(1, this.#bodyHeight));
+                this.#scrollBy(Math.max(1, host.getSize().height - HEADER_ROWS - FOOTER_ROWS));
                 return { consumed: true };
             case "first":
                 this.#scroll = 0;
@@ -178,17 +201,25 @@ export class ReferenceScreenApp {
                 return { consumed: true };
         }
     }
-    onMouse(event, _host) {
+    onMouse(event, host) {
         if (event.kind === "wheel-up" || event.kind === "wheel-down") {
             // Invariant: the whole screen owns wheel scrolling; it must not depend on the pointer's row.
             const distance = scrollbarWheelRows(this.#scrollSettings().scrollbarSpeed);
             this.#scrollBy(event.kind === "wheel-down" ? distance : -distance);
             return { consumed: true };
         }
+        if (this.#selection?.selecting === true) {
+            const selection = this.#selection.handleMouse(event, () => host.requestRender());
+            if (selection.consumed)
+                return { consumed: true, render: selection.changed };
+        }
         const rail = this.#railPointer(event);
         if (rail.owned)
             return { consumed: true };
-        return { consumed: event.kind !== "motion", render: rail.changed };
+        const selection = this.#selection?.handleMouse(event, () => host.requestRender());
+        if (selection?.consumed === true)
+            return { consumed: true, render: selection.changed || rail.changed };
+        return { consumed: event.kind !== "motion", render: selection?.changed === true || rail.changed };
     }
     // Rationale: the rail takes its share of a pointer report first: hover, a thumb drag, or a
     // track page. Owned means the document must not see the report; changed means the rail looks different.

package/dist/features/owned-ui/settings-app.d.ts

@@ -22,6 +22,7 @@ export declare class SettingsApp implements UiApp {
         readonly searchInputFactory: SettingsSearchInputFactory;
         readonly copyText?: (text: string) => void;
         readonly configurePlusMenu?: (() => boolean) | null;
+        readonly dialogPanel?: (text: string) => string;
     });
     onActivate(host: AppHostServices): void;
     onClose(_host: AppHostServices): void;