@agi-fans/dsh-tui 0.1.0

package/lib/event-views.js

@@ -0,0 +1,678 @@
+/**
+ * Transcript state machine: SessionEvent -> display blocks, and the pure
+ * view that composes blocks + status + input into a render frame.
+
+ * applyEvent is the single writer of TranscriptState; renderView is the
+ * single reader. windowTranscript clips the body the way OMP's ScrollView
+ * does. Both are pure so the whole rendering pipeline is testable without
+ * a terminal.
+ * @module @agi-fans/dsh-tui
+ */
+import { renderAutocomplete, slashInlineHint } from "./autocomplete.js";
+import { HISTORY_SEARCH_MAX_VISIBLE, renderHistorySearch } from "./history-search.js";
+import { renderEditor, renderFramedBlock, renderWelcome, renderWorking } from "./box.js";
+import { renderMarkdown } from "./markdown.js";
+import { renderCopySelector } from "./copy-selector.js";
+import { renderSettings } from "./settings-list.js";
+import { renderPlanReviewPage, renderPromptSelector, renderPromptSelectorPage, } from "./prompt-selector.js";
+import { resolveStatusBarConfig } from "./status-config.js";
+import { renderStatusFooter } from "./status-line.js";
+import { createTheme, SPINNER, SYMBOL } from "./theme.js";
+import { padToWidth, truncateToWidth, visibleWidth, wrapText } from "./width.js";
+import { renderTool } from "./tool-renderers.js";
+import { renderToolsPanel } from "./tools-list.js";
+import { renderHotkeysPanel } from "./hotkeys.js";
+import { renderCommandOutput, renderCommandSeparator } from "./command-output.js";
+import { renderPathMentionRows } from "./path-mentions.js";
+/** Empty starting state. */
+export function initialTranscript() {
+    return { blocks: [], status: 'idle', turn: 0 };
+}
+/** Extract plain text from text blocks, ignoring other block kinds. */
+function contentToText(content) {
+    return content
+        .flatMap((block) => {
+        if (block.type === 'text')
+            return [block.text];
+        if (block.type === 'image') {
+            const ref = block.attachment;
+            return [`[image ${ref.width}×${ref.height} · ${ref.mediaType}]`];
+        }
+        return [];
+    })
+        .join('');
+}
+/** Extract reasoning text from reasoning blocks. */
+function contentToReasoning(content) {
+    return content
+        .filter((block) => block.type === 'reasoning')
+        .map((block) => block.text)
+        .join('');
+}
+/** Compact pretty-print of a tool call's raw arguments JSON. */
+function prettyArgs(raw) {
+    try {
+        return JSON.stringify(JSON.parse(raw));
+    }
+    catch {
+        return raw;
+    }
+}
+/** The streaming assistant block if it is the last block, else undefined. */
+function streamingBlock(state, turn, step) {
+    const last = state.blocks[state.blocks.length - 1];
+    if (last?.kind === 'assistant' && last.streaming && last.turn === turn && last.step === step)
+        return last;
+    return undefined;
+}
+/** Replace the trailing streaming block with a settled one, or append. */
+function settleAssistant(state, turn, step, text, reasoning) {
+    const blocks = state.blocks.slice();
+    const last = blocks[blocks.length - 1];
+    if (last?.kind === 'assistant' && last.streaming && last.turn === turn && last.step === step) {
+        blocks[blocks.length - 1] = { kind: 'assistant', turn, step, text, reasoning, streaming: false };
+    }
+    else {
+        blocks.push({ kind: 'assistant', turn, step, text, reasoning, streaming: false });
+    }
+    return { ...state, blocks };
+}
+/**
+ * Fold one session-log event into the transcript state.
+ * @param state - prior state.
+ * @param event - the appended session event.
+ * @returns the next state.
+ */
+export function applyEvent(state, event, presentation) {
+    switch (event.type) {
+        case 'turn/start':
+            return { ...state, status: 'running', turn: event.data.turn };
+        case 'turn/end': {
+            const blocks = state.blocks.slice();
+            const last = blocks[blocks.length - 1];
+            if (last?.kind === 'assistant' && last.streaming) {
+                blocks[blocks.length - 1] = { ...last, streaming: false };
+            }
+            const reason = event.data.reason;
+            if (reason.kind === 'error') {
+                blocks.push({ kind: 'notice', level: 'error', text: 'error: ' + reason.error.code + ': ' + reason.error.message });
+            }
+            else if (reason.kind === 'aborted') {
+                blocks.push({ kind: 'notice', level: 'info', text: 'interrupted' });
+            }
+            return { ...state, blocks, status: 'idle' };
+        }
+        case 'user/message': {
+            // Synthetic plugin injections (system-prompt runtime context, skill
+            // catalog) reach the surface as user-role messages but are model input,
+            // not what the human typed; only human prompts render as transcript.
+            if (event.data.source.kind !== 'user')
+                return state;
+            const text = contentToText(event.data.content);
+            if (text === '')
+                return state;
+            return { ...state, blocks: [...state.blocks, { kind: 'user', text }] };
+        }
+        case 'assistant/chunk': {
+            const { turn, step, chunk } = event.data;
+            if (chunk.type === 'text-delta') {
+                const blocks = state.blocks.slice();
+                const last = streamingBlock(state, turn, step);
+                if (last !== undefined) {
+                    const idx = blocks.length - 1;
+                    const found = blocks[idx];
+                    if (found?.kind === 'assistant')
+                        blocks[idx] = { ...found, text: found.text + chunk.text };
+                }
+                else {
+                    blocks.push({ kind: 'assistant', turn, step, text: chunk.text, reasoning: '', streaming: true });
+                }
+                return { ...state, blocks };
+            }
+            if (chunk.type === 'reasoning-delta') {
+                const blocks = state.blocks.slice();
+                const last = streamingBlock(state, turn, step);
+                if (last !== undefined) {
+                    const idx = blocks.length - 1;
+                    const found = blocks[idx];
+                    if (found?.kind === 'assistant')
+                        blocks[idx] = { ...found, reasoning: found.reasoning + chunk.text };
+                }
+                else {
+                    blocks.push({ kind: 'assistant', turn, step, text: '', reasoning: chunk.text, streaming: true });
+                }
+                return { ...state, blocks };
+            }
+            if (chunk.type === 'tool-call-delta') {
+                const blocks = state.blocks.slice();
+                const index = blocks.findIndex(block => block.kind === 'tool' && block.callId === chunk.id);
+                const existing = blocks[index];
+                if (existing?.kind === 'tool') {
+                    blocks[index] = {
+                        ...existing,
+                        name: chunk.name ?? existing.name,
+                        args: existing.args + chunk.argumentsDelta,
+                        partial: true,
+                    };
+                }
+                else {
+                    blocks.push({
+                        kind: 'tool', callId: chunk.id, name: chunk.name ?? 'tool',
+                        args: chunk.argumentsDelta, status: 'running', output: '', partial: true,
+                    });
+                }
+                return { ...state, blocks };
+            }
+            return state;
+        }
+        case 'assistant/message': {
+            const { turn, step, message } = event.data;
+            return settleAssistant(state, turn, step, contentToText(message.content), contentToReasoning(message.content));
+        }
+        case 'tool/call': {
+            const block = {
+                kind: 'tool',
+                callId: event.data.callId,
+                name: event.data.name,
+                args: prettyArgs(event.data.arguments),
+                status: 'running',
+                output: '',
+                ...(presentation === undefined ? {} : { presentation }),
+            };
+            const blocks = state.blocks.slice();
+            const partial = blocks.findIndex(item => item.kind === 'tool' && item.callId === event.data.callId);
+            if (partial >= 0)
+                blocks[partial] = block;
+            else
+                blocks.push(block);
+            return { ...state, blocks };
+        }
+        case 'tool/result':
+            return applyToolResult(state, event.data.message, event.data.error, presentation);
+        // Log-only vocabulary (boundaries, usage, compaction, approvals, ...):
+        // nothing to display; the recognized core events above own the surface.
+        default:
+            return state;
+    }
+}
+/** Fold one tool result into its tool block. */
+function applyToolResult(state, message, error, presentation) {
+    // A tool-result message carries exactly one tool-result block; the call
+    // identity and outcome live on that inner block.
+    const inner = message.content[0];
+    if (inner?.type !== 'tool-result')
+        return state;
+    const blocks = state.blocks.slice();
+    for (let i = blocks.length - 1; i >= 0; i -= 1) {
+        const block = blocks[i];
+        if (block?.kind === 'tool' && block.callId === inner.toolCallId) {
+            blocks[i] = {
+                ...block,
+                status: error !== undefined || inner.isError === true ? 'error' : 'ok',
+                output: contentToText(inner.content),
+                ...(presentation === undefined ? {} : { presentation }),
+            };
+            return { ...state, blocks };
+        }
+    }
+    return state;
+}
+/** Collapsed tool-output preview height (OMP `DEFAULT_TERMINAL_PREVIEW_LINES`). */
+export const TOOL_COLLAPSED_LINES = 10;
+/** OMP AssistantMessage uses one horizontal cell of padding and no vertical padding. */
+const ASSISTANT_PADDING_X = 1;
+function assistantContentLines(lines, width, paddingX) {
+    const margin = ' '.repeat(paddingX);
+    return lines.map((line) => padToWidth(margin + line + margin, width));
+}
+function assistantMarkdown(source, theme, width) {
+    const paddingX = width > ASSISTANT_PADDING_X * 2 ? ASSISTANT_PADDING_X : 0;
+    const contentWidth = Math.max(1, width - paddingX * 2);
+    return assistantContentLines(renderMarkdown(source, theme, contentWidth), width, paddingX);
+}
+function userBubble(text, theme, width) {
+    const inner = Math.max(1, width - 2);
+    const wrapped = renderPathMentionRows(text, inner, theme);
+    const rows = ['', ...wrapped, ''];
+    return rows.map((row) => {
+        const content = row === '' ? padToWidth('', width) : padToWidth(' ' + row, width);
+        return theme.colors ? theme.bg('userMessageBg', content) : content;
+    });
+}
+function toolIcon(status, theme, spinnerFrame) {
+    if (status === 'running') {
+        return theme.fg('accent', SPINNER[spinnerFrame % SPINNER.length] ?? SYMBOL.running);
+    }
+    if (status === 'ok')
+        return theme.fg('success', SYMBOL.success);
+    return theme.fg('error', SYMBOL.error);
+}
+/** Render one tool block as an OMP framed output box. */
+function toolBlockLines(block, theme, width, spinnerFrame, expanded) {
+    const icon = toolIcon(block.status, theme, spinnerFrame);
+    const presentation = renderTool({
+        name: block.name,
+        arguments: prettyArgs(block.args),
+        output: block.output,
+        status: block.status,
+        expanded,
+        ...(block.presentation === undefined ? {} : { presentation: block.presentation }),
+    });
+    const summary = presentation.summary === undefined || presentation.summary === ''
+        ? ''
+        : theme.fg('dim', ' ' + presentation.summary);
+    const header = icon + ' ' + theme.bold(presentation.title ?? block.name) + summary;
+    const raw = [...(presentation.lines ?? [])];
+    const hidden = expanded ? 0 : Math.max(0, raw.length - TOOL_COLLAPSED_LINES);
+    const shown = hidden > 0 ? raw.slice(0, TOOL_COLLAPSED_LINES) : raw;
+    const output = shown.map((line) => theme.fg('toolOutput', line));
+    if (hidden > 0) {
+        output.push(theme.fg('dim', '… ' + hidden + ' more lines · ⟨Ctrl+O: Expand⟩'));
+    }
+    const state = block.status === 'running' ? 'running' : block.status === 'ok' ? 'ok' : 'error';
+    return renderFramedBlock({ header, state, lines: output, width }, theme);
+}
+/**
+ * Render one transcript block to display lines. Pure; shared by the tty view
+ * and the non-tty plain printer.
+ * @param block - the block to render.
+ * @param theme - active theme.
+ * @param width - terminal width in columns.
+ * @param spinnerFrame - activity spinner phase for running tools.
+ * @param toolsExpanded - paint full tool output instead of the collapsed preview.
+ * @returns display lines (already width-fitted).
+ */
+export function blockLines(block, theme, width, spinnerFrame = 0, toolsExpanded = false) {
+    if (block.kind === 'user')
+        return userBubble(block.text, theme, width);
+    if (block.kind === 'assistant') {
+        const lines = [];
+        if (block.reasoning !== '') {
+            for (const part of assistantMarkdown(block.reasoning, theme, width)) {
+                lines.push(theme.italic(theme.fg('thinkingText', part)));
+            }
+            if (block.text !== '')
+                lines.push('');
+        }
+        if (block.text === '' && block.streaming) {
+            const paddingX = width > ASSISTANT_PADDING_X * 2 ? ASSISTANT_PADDING_X : 0;
+            lines.push(...assistantContentLines([theme.fg('dim', '…')], width, paddingX));
+        }
+        else if (block.text !== '') {
+            lines.push(...assistantMarkdown(block.text, theme, width));
+        }
+        return lines;
+    }
+    if (block.kind === 'tool')
+        return toolBlockLines(block, theme, width, spinnerFrame, toolsExpanded);
+    if (block.kind === 'toolCatalog')
+        return renderToolsPanel(block.tools, theme, width, toolsExpanded);
+    if (block.kind === 'hotkeyCatalog')
+        return renderHotkeysPanel(block.bindings, theme, width);
+    if (block.kind === 'commandOutput')
+        return renderCommandOutput(block.command, block.text, theme, width);
+    if (block.level === 'info' && !block.text.includes('\n')) {
+        const prefix = '  ';
+        const continuation = ' '.repeat(visibleWidth(prefix));
+        return wrapText(block.text, Math.max(1, width - visibleWidth(prefix))).map((line, index) => truncateToWidth((index === 0 ? prefix : continuation) + theme.fg('dim', line), width));
+    }
+    const state = block.level === 'error' ? 'error' : 'info';
+    const paint = (text) => (block.level === 'error' ? theme.fg('error', text) : theme.fg('dim', text));
+    const wrapped = wrapText(block.text, Math.max(1, width - 4));
+    const title = paint(wrapped[0] ?? '');
+    return renderFramedBlock({
+        header: title,
+        state,
+        width,
+        lines: wrapped.slice(1).map(paint),
+        applyBg: false,
+    }, theme);
+}
+function fitFrame(lines, width) {
+    return lines.map((line) => {
+        if (visibleWidth(line) <= width)
+            return line;
+        return truncateToWidth(line, width);
+    });
+}
+/**
+ * Scroll changes only the viewport. Cache the expensive Markdown/tool fold by
+ * immutable TranscriptState identity so wheel frames slice already-rendered
+ * rows instead of formatting the complete session again.
+ */
+const transcriptBodyCache = new WeakMap();
+function renderTranscriptBody(state, options, theme, spinnerFrame) {
+    const toolsExpanded = options.toolsExpanded === true;
+    const expandedTools = [...(options.expandedTools ?? [])].sort().join('\0');
+    const themeName = options.themeName ?? 'dark';
+    const trueColor = options.trueColor === true;
+    const cached = transcriptBodyCache.get(state);
+    if (cached !== undefined
+        && cached.width === options.width
+        && cached.colors === options.colors
+        && cached.trueColor === trueColor
+        && cached.themeName === themeName
+        && cached.spinnerFrame === spinnerFrame
+        && cached.toolsExpanded === toolsExpanded
+        && cached.expandedTools === expandedTools) {
+        return { lines: cached.lines, blockStarts: cached.blockStarts };
+    }
+    const lines = [];
+    const blockStarts = [];
+    let previous;
+    for (const block of state.blocks) {
+        if (lines.length > 0) {
+            const previousCommand = commandSurfaceName(previous);
+            const currentCommand = commandSurfaceName(block);
+            if (previousCommand !== undefined && currentCommand !== undefined && previousCommand !== currentCommand) {
+                lines.push('', renderCommandSeparator(theme, options.width), '');
+            }
+            else {
+                lines.push('');
+            }
+        }
+        blockStarts.push(lines.length);
+        const expanded = toolsExpanded || (block.kind === 'tool' && options.expandedTools?.has(block.callId) === true);
+        lines.push(...blockLines(block, theme, options.width, spinnerFrame, expanded));
+        previous = block;
+    }
+    transcriptBodyCache.set(state, {
+        width: options.width,
+        colors: options.colors,
+        trueColor,
+        themeName,
+        spinnerFrame,
+        toolsExpanded,
+        expandedTools,
+        lines,
+        blockStarts,
+    });
+    return { lines, blockStarts };
+}
+function commandSurfaceName(block) {
+    if (block?.kind === 'toolCatalog')
+        return 'tools';
+    if (block?.kind === 'hotkeyCatalog')
+        return 'hotkeys';
+    if (block?.kind === 'commandOutput')
+        return block.command;
+    return undefined;
+}
+/** Rows moved per Shift+Arrow (OMP ScrollView `fastScrollLines`). */
+export const TRANSCRIPT_FAST_SCROLL = 5;
+/** Rows moved per mouse-wheel notch. */
+export const TRANSCRIPT_WHEEL_SCROLL = 3;
+function earlierLabel(count) {
+    return '… ↑ ' + count + ' earlier line' + (count === 1 ? '' : 's') + ' ⟨Pg↑⟩';
+}
+function laterLabel(count) {
+    return '… ↓ ' + count + ' later line' + (count === 1 ? '' : 's') + ' ⟨Pg↓⟩';
+}
+/**
+ * Window `body` into `budget` rows with ↑/↓ overflow markers.
+ * `start` is the first body row to keep; non-finite values pin to the tail.
+ */
+export function windowTranscript(body, budget, start, theme) {
+    const len = body.length;
+    if (budget <= 0) {
+        return { lines: [], start: 0, maxStart: 0, budget, hiddenAbove: len, hiddenBelow: 0 };
+    }
+    if (len <= budget) {
+        return { lines: [...body], start: 0, maxStart: 0, budget, hiddenAbove: 0, hiddenBelow: 0 };
+    }
+    const maxStart = Math.max(0, len - (budget - 1));
+    const s = Number.isFinite(start) ? Math.max(0, Math.min(Math.trunc(start), maxStart)) : maxStart;
+    const atTail = s >= maxStart;
+    const atTop = s <= 0;
+    if (budget === 1) {
+        const label = atTail
+            ? earlierLabel(len)
+            : atTop
+                ? laterLabel(len)
+                : '… ↑ ' + s + ' · ↓ ' + (len - s) + ' ⟨Pg↑/Pg↓⟩';
+        return {
+            lines: [theme.fg('dim', label)],
+            start: s,
+            maxStart,
+            budget,
+            hiddenAbove: atTail ? len : s,
+            hiddenBelow: atTail ? 0 : len - s,
+        };
+    }
+    if (atTail) {
+        const take = budget - 1;
+        const hiddenAbove = len - take;
+        return {
+            lines: [theme.fg('dim', earlierLabel(hiddenAbove)), ...body.slice(hiddenAbove)],
+            start: hiddenAbove,
+            maxStart,
+            budget,
+            hiddenAbove,
+            hiddenBelow: 0,
+        };
+    }
+    if (atTop) {
+        const take = budget - 1;
+        const hiddenBelow = len - take;
+        return {
+            lines: [...body.slice(0, take), theme.fg('dim', laterLabel(hiddenBelow))],
+            start: 0,
+            maxStart,
+            budget,
+            hiddenAbove: 0,
+            hiddenBelow,
+        };
+    }
+    if (budget === 2) {
+        return {
+            lines: [theme.fg('dim', earlierLabel(s)), body[s] ?? ''],
+            start: s,
+            maxStart,
+            budget,
+            hiddenAbove: s,
+            hiddenBelow: len - s - 1,
+        };
+    }
+    const take = budget - 2;
+    const hiddenBelow = len - s - take;
+    return {
+        lines: [
+            theme.fg('dim', earlierLabel(s)),
+            ...body.slice(s, s + take),
+            theme.fg('dim', laterLabel(hiddenBelow)),
+        ],
+        start: s,
+        maxStart,
+        budget,
+        hiddenAbove: s,
+        hiddenBelow,
+    };
+}
+const IMAGE_MARKER = /\[Image #\d+(?:, \d+x\d+)?\]/gu;
+function paintImageMarkerSlice(fullText, slice, sourceStart, theme) {
+    const sourceEnd = sourceStart + slice.length;
+    let output = '';
+    let cursor = sourceStart;
+    for (const match of fullText.matchAll(IMAGE_MARKER)) {
+        const markerStart = match.index;
+        const markerEnd = markerStart + match[0].length;
+        if (markerEnd <= sourceStart || markerStart >= sourceEnd)
+            continue;
+        const overlapStart = Math.max(sourceStart, markerStart);
+        const overlapEnd = Math.min(sourceEnd, markerEnd);
+        output += fullText.slice(cursor, overlapStart);
+        output += theme.underline(theme.bold(theme.fg('accent', fullText.slice(overlapStart, overlapEnd))));
+        cursor = overlapEnd;
+    }
+    output += fullText.slice(cursor, sourceEnd);
+    return output;
+}
+/**
+ * Compose the welcome card, transcript, working row, and rounded editor into
+ * one frame — the oh-my-pi surface.
+ * @param state - transcript state.
+ * @param options - terminal geometry and input state.
+ * @returns the frame to hand to a renderer.
+ */
+export function renderView(state, options) {
+    const theme = createTheme(options.colors, options.trueColor === true, options.themeName ?? 'dark');
+    const width = options.width;
+    const height = options.height;
+    const appName = options.appName ?? 'omdsh';
+    const version = options.version ?? '0.1.0';
+    const pwd = options.pwd ?? '';
+    const spinnerFrame = options.spinnerFrame ?? 0;
+    if (options.settings !== undefined && options.promptSelector === undefined) {
+        const settings = renderSettings(options.settings, theme, width, height);
+        return {
+            lines: fitFrame(settings.lines, width),
+            cursor: settings.cursor,
+            cursorVisible: false,
+            overlay: { kind: 'settings', start: 0, itemRows: settings.itemRows },
+        };
+    }
+    if (options.promptSelector?.request.presentation === 'fullscreen-list') {
+        const selector = renderPromptSelectorPage(options.promptSelector, theme, width, height, options.input, options.inputCursor, appName);
+        return {
+            lines: fitFrame(selector.lines, width),
+            cursor: selector.cursor,
+            cursorVisible: true,
+            ...(selector.editor === undefined ? {} : { editor: selector.editor }),
+            overlay: {
+                kind: 'prompt',
+                start: 0,
+                ...(selector.itemRows === undefined ? {} : { itemRows: selector.itemRows }),
+            },
+        };
+    }
+    if (options.promptSelector?.request.presentation === 'plan-review') {
+        const review = renderPlanReviewPage(options.promptSelector, theme, width, height, options.input, options.inputCursor, appName);
+        return {
+            lines: fitFrame(review.lines, width),
+            cursor: review.cursor,
+            cursorVisible: review.cursorVisible === true,
+            ...(review.editor === undefined ? {} : { editor: review.editor }),
+            overlay: {
+                kind: 'prompt',
+                start: 0,
+                ...(review.document === undefined ? {} : { document: review.document }),
+            },
+        };
+    }
+    const welcome = renderWelcome({
+        width,
+        model: options.model,
+        ...(options.reasoningEffort === undefined ? {} : { reasoningEffort: options.reasoningEffort }),
+        version,
+        appName,
+        ...(options.recentSessions === undefined ? {} : { recentSessions: options.recentSessions }),
+        ...(options.welcomeTips === undefined ? {} : { tips: options.welcomeTips }),
+    }, theme);
+    const transcript = renderTranscriptBody(state, options, theme, spinnerFrame);
+    const body = [...welcome];
+    let transcriptStart = body.length;
+    if (transcript.lines.length > 0) {
+        if (body.length > 0)
+            body.push('');
+        transcriptStart = body.length;
+        body.push(...transcript.lines);
+    }
+    const working = state.status === 'running' ? renderWorking(theme, spinnerFrame, undefined, width) : [];
+    const statusBar = resolveStatusBarConfig(options.statusBar, options.statusPreset);
+    const inlineHint = slashInlineHint(options.input, options.inputCursor, options.commands);
+    const statusFooter = renderStatusFooter({
+        model: options.model,
+        ...(options.reasoningEffort === undefined ? {} : { reasoningEffort: options.reasoningEffort }),
+        ...(options.sessionControls === undefined ? {} : { controls: options.sessionControls }),
+        ...(pwd === '' ? {} : { pwd }),
+        ...(options.branch === undefined || options.branch === '' ? {} : { branch: options.branch }),
+        ...(options.sessionStats === undefined ? {} : { stats: options.sessionStats }),
+        config: statusBar,
+        width,
+    }, theme);
+    const editorOpts = {
+        width,
+        input: options.input,
+        inputCursor: options.inputCursor,
+        status: ' ' + theme.fg('accent', '🐳') + ' ',
+        border: state.status === 'running' ? 'accent' : 'border',
+        ...(options.inputImages === undefined || options.inputImages === 0
+            ? {}
+            : { paintInput: (text, start) => paintImageMarkerSlice(options.input, text, start, theme) }),
+        ...(inlineHint !== null ? { inlineHint } : {}),
+    };
+    const promptSelector = options.promptSelector === undefined
+        ? undefined
+        : renderPromptSelector(options.promptSelector, theme, width, options.input, options.inputCursor, Math.max(3, Math.min(10, height - working.length - 14)));
+    const settings = promptSelector !== undefined || options.settings === undefined
+        ? undefined
+        : renderSettings(options.settings, theme, width);
+    const copySelector = promptSelector !== undefined || settings !== undefined || options.copySelector === undefined
+        ? undefined
+        : renderCopySelector(options.copySelector, theme, width);
+    const search = promptSelector !== undefined || settings !== undefined || copySelector !== undefined || options.historySearch === undefined
+        ? undefined
+        : renderHistorySearch(options.historySearch, theme, width, Math.max(1, Math.min(HISTORY_SEARCH_MAX_VISIBLE, height - working.length - 8)));
+    const editor = promptSelector === undefined && settings === undefined && copySelector === undefined && search === undefined
+        ? renderEditor(editorOpts, theme)
+        : undefined;
+    const autocomplete = promptSelector !== undefined || settings !== undefined || copySelector !== undefined || search !== undefined
+        || options.autocomplete === undefined
+        ? []
+        : renderAutocomplete(options.autocomplete.items, options.autocomplete.selected, theme, width);
+    const inputLines = promptSelector?.lines ?? settings?.lines ?? copySelector?.lines ?? search?.lines
+        ?? (editor === undefined ? [] : editor.lines);
+    const spacer = 1;
+    const reserved = inputLines.length + working.length + spacer + autocomplete.length + statusFooter.length;
+    const budget = Math.max(0, height - reserved);
+    const focusStart = options.focusBlock === undefined
+        ? undefined
+        : transcript.blockStarts[Math.max(0, Math.min(options.focusBlock, transcript.blockStarts.length - 1))];
+    const requestedStart = focusStart === undefined
+        ? (options.scrollStart ?? Number.POSITIVE_INFINITY)
+        : transcriptStart + focusStart;
+    const windowed = windowTranscript(body, budget, requestedStart, theme);
+    const visible = windowed.lines;
+    const lines = [...visible];
+    if (visible.length > 0)
+        lines.push('');
+    const bottomRows = working.length + inputLines.length + autocomplete.length + statusFooter.length;
+    const fill = Math.max(0, height - lines.length - bottomRows);
+    lines.push(...Array.from({ length: fill }, () => ''));
+    lines.push(...working);
+    const editorStart = lines.length;
+    lines.push(...inputLines);
+    lines.push(...autocomplete);
+    lines.push(...statusFooter);
+    const trimmed = fitFrame(lines, width);
+    const caret = promptSelector?.cursor ?? settings?.cursor ?? copySelector?.cursor ?? search?.cursor ?? editor?.cursor ?? { row: 0, column: 0 };
+    return {
+        lines: trimmed,
+        cursor: {
+            row: editorStart + caret.row,
+            column: Math.min(caret.column, width),
+        },
+        cursorVisible: promptSelector?.cursorVisible
+            ?? (settings === undefined && copySelector === undefined),
+        ...(promptSelector?.editor !== undefined
+            ? { editor: { start: editorStart + promptSelector.editor.start, rows: promptSelector.editor.rows } }
+            : editor === undefined ? {} : { editor: { start: editorStart, rows: editor.lines.length } }),
+        ...(settings !== undefined
+            ? { overlay: { kind: 'settings', start: editorStart } }
+            : copySelector !== undefined
+                ? { overlay: { kind: 'copy', start: editorStart } }
+                : search !== undefined
+                    ? { overlay: { kind: 'search', start: editorStart, resultsRow: search.resultsRow } }
+                    : autocomplete.length > 0
+                        ? { overlay: { kind: 'autocomplete', start: editorStart + (editor?.lines.length ?? 0) } }
+                        : {}),
+        transcript: {
+            start: windowed.start,
+            maxStart: windowed.maxStart,
+            budget: windowed.budget,
+            hiddenAbove: windowed.hiddenAbove,
+            hiddenBelow: windowed.hiddenBelow,
+        },
+    };
+}
+//# sourceMappingURL=event-views.js.map