min-agent 0.3.0 → 0.4.0

package/dist/tui/hydrate.js

@@ -0,0 +1,129 @@
+import { summarizeToolCall, summarizeToolResult, toolResultText } from "../tool-display.js";
+import { extractXmlSearch } from "../xml-search.js";
+function isRecord(v) {
+    return typeof v === "object" && v !== null;
+}
+function textFromContent(content) {
+    if (typeof content === "string")
+        return content;
+    if (!Array.isArray(content))
+        return "";
+    const parts = [];
+    for (const part of content) {
+        if (isRecord(part) && part.type === "text" && typeof part.text === "string")
+            parts.push(part.text);
+    }
+    return parts.join("");
+}
+function hasMediaPart(content) {
+    if (!Array.isArray(content))
+        return false;
+    return content.some((part) => isRecord(part) && (part.type === "image" || part.type === "file"));
+}
+function unwrapToolOutput(output) {
+    if (!isRecord(output))
+        return output;
+    if ((output.type === "text" || output.type === "json") && "value" in output)
+        return output.value;
+    return output;
+}
+function userText(content) {
+    const text = textFromContent(content).trim();
+    if (text)
+        return textFromContent(content);
+    if (hasMediaPart(content))
+        return "[📎 图片]";
+    return null;
+}
+export function lastUserText(messages) {
+    for (let i = messages.length - 1; i >= 0; i--) {
+        const msg = messages[i];
+        if (msg?.role !== "user")
+            continue;
+        const text = textFromContent(msg.content).trim();
+        if (text)
+            return textFromContent(msg.content);
+    }
+    return null;
+}
+export function hydrateMessages(messages) {
+    const out = [];
+    for (let i = 0; i < messages.length; i++) {
+        const msg = messages[i];
+        if (msg.role === "assistant") {
+            out.push(...hydrateAssistant(msg, i));
+            continue;
+        }
+        const mapped = mapMessage(msg, i);
+        if (mapped)
+            out.push(mapped);
+    }
+    return out;
+}
+function hydrateAssistant(msg, index) {
+    const content = textFromContent(msg.content);
+    if (!content)
+        return [];
+    const { slices } = extractXmlSearch(content);
+    if (slices.every((sl) => sl.type === "display")) {
+        return [{ id: `hyd-${index}-assistant`, role: "assistant", content, timestamp: 0 }];
+    }
+    const out = [];
+    let part = 0;
+    for (const sl of slices) {
+        if (sl.type === "display") {
+            if (!sl.text.trim())
+                continue;
+            out.push({ id: `hyd-${index}-assistant-${part++}`, role: "assistant", content: sl.text, timestamp: 0 });
+            continue;
+        }
+        const query = sl.block.query;
+        const result = sl.block.kind === "results" ? sl.block.body : sl.block.query;
+        const input = { query };
+        out.push({
+            id: `hyd-${index}-search-${part++}`,
+            role: "tool",
+            content: summarizeToolCall("search_web", input),
+            toolName: "search_web",
+            toolCallId: `xml-search-hyd-${index}-${part}`,
+            toolResult: result,
+            toolResultSummary: summarizeToolResult("search_web", result),
+            timestamp: 0,
+        });
+    }
+    return out;
+}
+function mapMessage(msg, index) {
+    if (msg.role === "user") {
+        const content = userText(msg.content);
+        if (content == null)
+            return null;
+        return { id: `hyd-${index}-user`, role: "user", content, timestamp: 0 };
+    }
+    if (msg.role === "tool") {
+        if (!Array.isArray(msg.content))
+            return null;
+        for (const part of msg.content) {
+            if (!isRecord(part) || part.type !== "tool-result")
+                continue;
+            const toolName = typeof part.toolName === "string" ? part.toolName : "";
+            if (!toolName)
+                continue;
+            const output = unwrapToolOutput(part.output);
+            const result = toolResultText(output);
+            const toolCallId = typeof part.toolCallId === "string" ? part.toolCallId : undefined;
+            return {
+                id: `hyd-${index}-tool`,
+                role: "tool",
+                content: toolName,
+                toolName,
+                toolCallId,
+                toolResult: result,
+                toolResultSummary: summarizeToolResult(toolName, output),
+                timestamp: 0,
+            };
+        }
+        return null;
+    }
+    return null;
+}

package/dist/tui/index.js

@@ -2,6 +2,8 @@ import { jsx as _jsx } from "react/jsx-runtime";
 import { render } from "ink";
 import { App } from "./App.js";
 import { createCaretAwareStdout, setCaretPosition } from "./caret.js";
+import { mergeToolChild } from "./tool-children.js";
+import { normalizeQuestionOptions, normalizeQuestionPrompt } from "../question-format.js";
 /**
  * TUI renderer — manages the Ink app lifecycle and provides
  * imperative methods to update state from the agent loop.
@@ -16,23 +18,26 @@ export class TuiRenderer {
     pendingThinking = "";
     thinkingTimer = null;
     copyNoticeTimer = null;
-    constructor(callbacks, model) {
+    constructor(callbacks, model, sessionId) {
         this.state = {
             messages: [],
             isRunning: false,
             model,
+            sessionId,
         };
         this.callbacks = callbacks;
     }
+    appElement() {
+        return (_jsx(App, { initialState: this.state, onSubmit: this.callbacks.onSubmit, onConfirm: this.callbacks.onConfirm, onQuestionAnswer: this.callbacks.onQuestionAnswer, onModelPick: this.callbacks.onModelPick, onModelCancel: this.callbacks.onModelCancel, onSessionPick: this.callbacks.onSessionPick, onSessionCancel: this.callbacks.onSessionCancel, onToggleSelectionMode: this.callbacks.onToggleSelectionMode, onExitSelectionMode: this.callbacks.onExitSelectionMode, onExit: this.callbacks.onExit, onCopyNotice: (text) => this.showCopyNotice(text) }));
+    }
     start() {
-        this.inkInstance = render(_jsx(App, { initialState: this.state, onSubmit: this.callbacks.onSubmit, onConfirm: this.callbacks.onConfirm, onQuestionAnswer: this.callbacks.onQuestionAnswer, onModelPick: this.callbacks.onModelPick, onModelCancel: this.callbacks.onModelCancel, onExit: this.callbacks.onExit, onCopyNotice: (text) => this.showCopyNotice(text) }), { exitOnCtrlC: false, stdout: createCaretAwareStdout(process.stdout) });
+        this.inkInstance = render(this.appElement(), { exitOnCtrlC: false, stdout: createCaretAwareStdout(process.stdout) });
     }
     /** Update state and trigger re-render — always replaces the reference so React sees a new prop. */
     update(partial) {
         this.state = { ...this.state, ...partial };
-        if (this.inkInstance) {
-            this.inkInstance.rerender(_jsx(App, { initialState: this.state, onSubmit: this.callbacks.onSubmit, onConfirm: this.callbacks.onConfirm, onQuestionAnswer: this.callbacks.onQuestionAnswer, onModelPick: this.callbacks.onModelPick, onModelCancel: this.callbacks.onModelCancel, onExit: this.callbacks.onExit, onCopyNotice: (text) => this.showCopyNotice(text) }));
-        }
+        if (this.inkInstance)
+            this.inkInstance.rerender(this.appElement());
     }
     addMessage(msg) {
         this.flushPendingDeltas();
@@ -128,8 +133,6 @@ export class TuiRenderer {
         this.pendingDelta = "";
         if (!accumulated)
             return;
-        if (accumulated.trim() === "")
-            return;
         const msgs = [...this.state.messages];
         const last = msgs[msgs.length - 1];
         if (last && last.role === "assistant") {
@@ -137,7 +140,7 @@ export class TuiRenderer {
             this.state.messages = msgs;
             this.update({});
         }
-        else {
+        else if (accumulated.trim() !== "") {
             this.addMessage({
                 id: `msg-${Date.now()}`,
                 role: "assistant",
@@ -164,28 +167,54 @@ export class TuiRenderer {
         this.update({ isRunning: running, spinnerText });
     }
     showConfirm(message) {
-        this.update({ confirmMessage: message });
+        this.update({ confirmMessage: message, selectionMode: false });
     }
     hideConfirm() {
         this.update({ confirmMessage: undefined });
     }
     showQuestion(prompt, options) {
-        this.update({ question: { prompt, options } });
+        const choices = normalizeQuestionOptions(options);
+        this.update({
+            question: {
+                prompt: normalizeQuestionPrompt(prompt),
+                ...(choices.length > 0 ? { options: choices } : {}),
+            },
+            selectionMode: false,
+        });
     }
     hideQuestion() {
         this.update({ question: undefined });
     }
     showModelPicker() {
-        this.update({ modelPicker: true });
+        this.update({ modelPicker: true, selectionMode: false });
     }
     hideModelPicker() {
         this.update({ modelPicker: false });
     }
+    showSessionPicker() {
+        this.update({ sessionPicker: true, selectionMode: false });
+    }
+    hideSessionPicker() {
+        this.update({ sessionPicker: false });
+    }
+    setSessionId(id) {
+        this.update({ sessionId: id });
+    }
+    setSelectionMode(on) {
+        this.update({ selectionMode: on });
+    }
+    toggleSelectionMode() {
+        this.update({ selectionMode: !this.state.selectionMode });
+    }
+    appendToolChild(parentToolCallId, child) {
+        this.state.messages = mergeToolChild(this.state.messages, parentToolCallId, child);
+        this.update({});
+    }
     setModel(model) {
         this.update({ model });
     }
-    setTokenInfo(input, output, contextWindow) {
-        this.update({ tokenInfo: { input, output, contextWindow } });
+    setTokenInfo(info) {
+        this.update({ tokenInfo: info });
     }
     /** Flash a transient copy confirmation in the status bar (2.5s). */
     showCopyNotice(text) {

package/dist/tui/input-history.js

@@ -1,7 +1,64 @@
-export function createHistory() {
-    return { entries: [], index: -1, draft: "" };
+import { existsSync, mkdirSync, readFileSync, renameSync } from "fs";
+import path from "path";
+import { getConfigDir } from "../config.js";
+import { atomicWriteFileSync } from "../tools/atomic-file.js";
+export const HISTORY_LIMIT = 1000;
+function historyFile() {
+    return path.join(getConfigDir(), "input-history.json");
+}
+export function createHistory(entries = []) {
+    return { entries, index: -1, draft: "" };
+}
+export function parseHistoryFile(raw) {
+    let data;
+    try {
+        data = JSON.parse(raw);
+    }
+    catch {
+        return null;
+    }
+    if (typeof data !== "object" || data === null || Array.isArray(data))
+        return null;
+    const entries = data.entries;
+    if (!Array.isArray(entries) || entries.some((e) => typeof e !== "string"))
+        return null;
+    return entries;
+}
+export function serializeHistoryFile(entries) {
+    return JSON.stringify({ entries }, null, 2);
+}
+export function loadInputHistoryFrom(file) {
+    if (!existsSync(file))
+        return [];
+    let raw;
+    try {
+        raw = readFileSync(file, "utf-8");
+    }
+    catch {
+        return [];
+    }
+    const parsed = parseHistoryFile(raw);
+    if (parsed)
+        return parsed;
+    try {
+        renameSync(file, `${file}.corrupt-${Date.now()}`);
+    }
+    catch { }
+    return [];
+}
+export function saveInputHistoryTo(file, entries) {
+    try {
+        mkdirSync(path.dirname(file), { recursive: true });
+        atomicWriteFileSync(file, serializeHistoryFile(entries));
+    }
+    catch { }
+}
+export function loadInputHistory() {
+    return loadInputHistoryFrom(historyFile());
+}
+export function saveInputHistory(entries) {
+    saveInputHistoryTo(historyFile(), entries);
 }
-const HISTORY_LIMIT = 500;
 export function pushInput(state, text) {
     if (!text)
         return state;
@@ -22,23 +79,47 @@ export function searchHistory(state, query) {
     }
     return null;
 }
-export function browseHistory(state, direction) {
+export function browseHistory(state, direction, skip) {
     const count = state.entries.length;
     if (count === 0)
         return { text: state.draft, state };
+    const last = count - 1;
+    const usable = (i) => i >= 0 && i <= last && !skip?.(state.entries[i]);
+    const current = state.index === -1 ? -1 : Math.max(0, Math.min(last, state.index));
     if (direction === 1) {
-        const index = state.index === -1 ? count - 1 : Math.max(0, Math.min(count - 1, state.index - 1));
-        return { text: state.entries[index], state: { ...state, index } };
+        const start = current === -1 ? last : current - 1;
+        for (let i = start; i >= 0; i--) {
+            if (usable(i))
+                return { text: state.entries[i], state: { ...state, index: i } };
+        }
+        if (current !== -1)
+            return { text: state.entries[current], state };
+        return { text: state.draft, state };
     }
-    if (state.index === -1)
+    if (current === -1)
         return { text: state.draft, state };
-    if (state.index >= count - 1)
-        return { text: state.draft, state: { ...state, index: -1 } };
-    const index = state.index + 1;
-    return { text: state.entries[index], state: { ...state, index } };
+    for (let i = current + 1; i <= last; i++) {
+        if (usable(i))
+            return { text: state.entries[i], state: { ...state, index: i } };
+    }
+    return { text: state.draft, state: { ...state, index: -1 } };
 }
 export function resetHistory(state, text) {
     if (state.index === -1 && state.draft === text)
         return state;
     return { entries: state.entries, index: -1, draft: text };
 }
+export function isCtrlC(input, key) {
+    return (key.ctrl === true && input === "c") || input === "\x03";
+}
+export const EXIT_CTRL_C_WINDOW_MS = 2000;
+export function clearInputOnCtrlC(state, value, armedAt = null, now = 0) {
+    if (value === "") {
+        if (armedAt !== null && now - armedAt <= EXIT_CTRL_C_WINDOW_MS) {
+            return { state, value: "", exit: true, armedAt: null };
+        }
+        return { state, value: "", exit: false, armedAt: now };
+    }
+    const next = value.trim() ? pushInput(state, value) : { entries: state.entries, index: -1, draft: "" };
+    return { state: next, value: "", exit: false, armedAt: null };
+}

package/dist/tui/layout.js

@@ -2,16 +2,87 @@ export const BOX_CHROME = 4;
 export const GUTTER_WIDTH = 2;
 export const TEXT_START_COLUMN = 5;
 export const STATUS_BAR_ROWS = 2;
-export const SAFETY_MARGIN = 2;
 export const INPUT_BAR_ROWS = 3;
+export const MIN_MESSAGE_ROWS = 2;
+/** Ink paddingLeft on every message row. */
+export const MESSAGE_PAD_LEFT = 1;
+/**
+ * Cells reserved at the right of a message row. Filling the last terminal
+ * column wraps the cursor; East-Asian-ambiguous glyphs (`→`, `▸`) may also
+ * occupy one more cell than `displayWidth` reports.
+ */
+export const COL_WRAP_GUARD = 2;
+/** Pinned chrome of ConfirmBar: borders + title + gap + [y]/[N] prompt. */
+export const CONFIRM_CHROME_ROWS = 5;
+/** Pinned chrome of QuestionBar: borders + gap + input + hint. */
+export const QUESTION_CHROME_ROWS = 5;
+/**
+ * Ink's log-update writes the frame plus a trailing newline. A root box that
+ * uses the full terminal height therefore places the input bar's bottom
+ * border on the last row, which that extra newline clips.
+ */
+export const LAST_ROW_GUARD = 1;
+export function frameRows(terminalRows) {
+    if (terminalRows <= 0)
+        return 0;
+    return Math.max(1, terminalRows - LAST_ROW_GUARD);
+}
 export function innerTextWidth(columns) {
     return Math.max(1, columns - 5);
 }
+export function messageTextWidth(columns) {
+    return Math.max(1, columns - MESSAGE_PAD_LEFT - COL_WRAP_GUARD);
+}
 export function inputTextWidth(columns) {
     return Math.max(8, columns - BOX_CHROME - GUTTER_WIDTH);
 }
-export function computeMessageMaxHeight(terminalRows, footerRows, spinnerRows) {
-    if (terminalRows <= 0)
+export function computeMessageMaxHeight(frameRowCount, footerRows, spinnerRows) {
+    if (frameRowCount <= 0)
         return undefined;
-    return Math.max(2, terminalRows - footerRows - STATUS_BAR_ROWS - spinnerRows - SAFETY_MARGIN);
+    return Math.max(MIN_MESSAGE_ROWS, frameRowCount - footerRows - STATUS_BAR_ROWS - spinnerRows);
+}
+/**
+ * Max rows a confirm/question footer may occupy while leaving the status bar
+ * and a two-row peek of the conversation. `minChrome` is the pinned action
+ * chrome (title + prompt) that must stay on screen.
+ */
+export function footerMaxRows(frameRowCount, minChrome) {
+    if (frameRowCount <= 0)
+        return Number.POSITIVE_INFINITY;
+    return Math.max(minChrome, frameRowCount - STATUS_BAR_ROWS - MIN_MESSAGE_ROWS);
+}
+/** Rows a line window actually paints: content plus one indicator per hidden side. */
+export function lineWindowPaintRows(window) {
+    return window.lines.length + (window.above > 0 ? 1 : 0) + (window.below > 0 ? 1 : 0);
+}
+/**
+ * Visible slice of wrapped lines for a max-height body. Hidden sides take an
+ * indicator row each, subtracted from the content budget so the painted
+ * window never exceeds `maxHeight`.
+ */
+export function sliceLineWindow(lines, maxHeight, top) {
+    if (maxHeight <= 0) {
+        return { start: 0, lines: [], above: 0, below: lines.length };
+    }
+    if (lines.length <= maxHeight) {
+        return { start: 0, lines, above: 0, below: 0 };
+    }
+    let above = 0;
+    let below = 0;
+    let start = 0;
+    let viewH = maxHeight;
+    for (let pass = 0; pass < 3; pass++) {
+        const chrome = (above > 0 ? 1 : 0) + (below > 0 ? 1 : 0);
+        viewH = Math.max(1, maxHeight - chrome);
+        const maxTop = Math.max(0, lines.length - viewH);
+        start = Math.max(0, Math.min(top, maxTop));
+        above = start;
+        below = Math.max(0, lines.length - (start + viewH));
+    }
+    return {
+        start,
+        lines: lines.slice(start, start + viewH),
+        above,
+        below,
+    };
 }

package/dist/tui/prompt-queue.js

@@ -0,0 +1,24 @@
+export function createPromptQueue() {
+    let tail = Promise.resolve();
+    let generation = 0;
+    let size = 0;
+    const settle = () => undefined;
+    return {
+        run(job, onCancelled) {
+            const gen = generation;
+            size++;
+            const start = () => (gen !== generation ? Promise.resolve(onCancelled()) : job());
+            const result = tail.then(start, start);
+            tail = result.then(settle, settle);
+            return result.finally(() => {
+                size--;
+            });
+        },
+        cancelAll() {
+            generation++;
+        },
+        get size() {
+            return size;
+        },
+    };
+}

package/dist/tui/selection.js

@@ -1,4 +1,4 @@
-import { charWidth, displayWidth } from "./text-width.js";
+import { clustersOf, displayWidth } from "./text-width.js";
 const RESET = "\x1b[0m";
 const INVERSE_ON = "\x1b[7m";
 const INVERSE_OFF = "\x1b[27m";
@@ -20,9 +20,6 @@ export function applySelection(line, start, end) {
     let inSel = false;
     for (const token of line.split(/(\x1b\[[0-9;]*m)/g)) {
         if (token.startsWith("\x1b[")) {
-            // A reset inside the selection would cancel the highlight, so it is
-            // re-applied right after; a reset at/after the selection end closes the
-            // highlight first, keeping the boundary between the two styles.
             if (inSel && token === RESET) {
                 if (col < end)
                     out += token + INVERSE_ON;
@@ -35,9 +32,9 @@ export function applySelection(line, start, end) {
             out += token;
             continue;
         }
-        for (const ch of token) {
+        for (const { text: g, width: w } of clustersOf(token)) {
             const cellStart = col;
-            const cellEnd = col + charWidth(ch);
+            const cellEnd = col + w;
             const selected = cellEnd > start && cellStart < end;
             if (selected && !inSel) {
                 out += INVERSE_ON;
@@ -47,7 +44,7 @@ export function applySelection(line, start, end) {
                 out += INVERSE_OFF;
                 inSel = false;
             }
-            out += ch;
+            out += g;
             col = cellEnd;
         }
     }
@@ -61,23 +58,16 @@ export function extractText(line, start, end) {
         return "";
     let out = "";
     let col = 0;
-    for (const ch of cachedStrip(line)) {
-        const cellEnd = col + charWidth(ch);
+    for (const { text: g, width: w } of clustersOf(cachedStrip(line))) {
+        const cellEnd = col + w;
         if (cellEnd > start && col < end)
-            out += ch;
+            out += g;
         col = cellEnd;
         if (col >= end)
             break;
     }
     return out;
 }
-/**
- * Flow-style selection over the message area. `rows` mirrors the rendered
- * rows (null = blank/chrome row, no text); anchor/current are 0-based
- * (row = index into `rows`, col = display column). Dragging down selects the
- * anchor to end-of-line, full middle rows, then start to current; dragging up
- * is symmetric. Returns one range per row (null = nothing selected there).
- */
 const strippedCache = new Map();
 function cachedStrip(row) {
     const hit = strippedCache.get(row);
@@ -89,6 +79,106 @@ function cachedStrip(row) {
     strippedCache.set(row, s);
     return s;
 }
+export function textFromSelection(rows, kinds, ranges) {
+    const parts = [];
+    for (let i = 0; i < ranges.length; i++) {
+        const range = ranges[i];
+        const row = rows[i];
+        if (!range || !row)
+            continue;
+        parts.push(stripCopyDecorations(extractText(row, range.start, range.end), kinds[i] ?? "plain"));
+    }
+    while (parts.length > 0 && parts[parts.length - 1] === "")
+        parts.pop();
+    return parts.join("\n");
+}
+export function stripCopyDecorations(line, kind) {
+    if (kind === "user-head" && line.startsWith("> "))
+        return line.slice(2);
+    if (kind === "tool-head")
+        return line.replace(/^⚡ .*?[▸▾] /, "");
+    if (kind === "tool-body" && line.startsWith("  "))
+        return line.slice(2);
+    return line;
+}
+/** Visible prefix rendered in its own Ink Text (user `> `, tool `⚡ name ▸ `). */
+export function visualPrefix(line, role) {
+    if (role === "user" && line.startsWith("> "))
+        return "> ";
+    if (role === "tool") {
+        const m = line.match(/^⚡ .*?[▸▾] /);
+        return m ? m[0] : "";
+    }
+    return "";
+}
+/** Split a display-column range across a prefix of `at` cells. */
+export function splitRangeAt(range, at) {
+    const head = range.start < at && range.end > 0 ? { start: range.start, end: Math.min(at, range.end) } : null;
+    const tail = range.end > at ? { start: Math.max(0, range.start - at), end: range.end - at } : null;
+    return {
+        head: head && head.end > head.start ? head : null,
+        tail: tail && tail.end > tail.start ? tail : null,
+    };
+}
+export function wordRangeAt(line, col) {
+    const cells = [];
+    let x = 0;
+    for (const { text: g, width: w } of clustersOf(line)) {
+        cells.push({ ch: g, start: x, end: x + w });
+        x += w;
+    }
+    const hit = cells.find((c) => col >= c.start && col < c.end);
+    if (!hit || /\s/.test(hit.ch))
+        return { start: col, end: col };
+    let left = cells.indexOf(hit);
+    let right = left;
+    while (left > 0 && !/\s/.test(cells[left - 1].ch))
+        left--;
+    while (right < cells.length - 1 && !/\s/.test(cells[right + 1].ch))
+        right++;
+    return { start: cells[left].start, end: cells[right].end };
+}
+/**
+ * Map a 1-based SGR mouse position to a cell in `rows`.
+ * `padLeft` is the Ink paddingLeft of every message row (first text cell is
+ * terminal column padLeft+1).
+ */
+export function mouseToCell(rows, termRow, termCol, padLeft = 1) {
+    const maxRow = Math.max(0, rows.length - 1);
+    return {
+        row: Math.min(maxRow, Math.max(0, termRow - 1)),
+        col: Math.max(0, termCol - 1 - padLeft),
+    };
+}
+/**
+ * Distribute viewport ranges onto each message part's shown-line index.
+ * The resulting arrays are sparse: missing indices mean that shown line is
+ * not highlighted. Callers must not require `arr.length === shown.length`.
+ */
+export function alignPartSelections(ranges, partMeta) {
+    const map = new Map();
+    for (let i = 0; i < ranges.length; i++) {
+        const meta = partMeta[i];
+        const range = ranges[i];
+        if (!meta || !range || range.end <= range.start)
+            continue;
+        let arr = map.get(meta.part);
+        if (!arr) {
+            arr = [];
+            map.set(meta.part, arr);
+        }
+        arr[meta.shown] = range;
+    }
+    return map;
+}
+/**
+ * Flow-style selection over the message area. `rows` mirrors the rendered
+ * rows (null = blank/chrome row, no text); anchor/current are 0-based
+ * (row = index into `rows`, col = display column of the cell under the
+ * pointer). Both endpoints are inclusive: dragging onto a character selects
+ * it. Dragging down selects the anchor through end-of-line, full middle rows,
+ * then start through current; dragging up is symmetric.
+ */
 export function selectionRanges(rows, anchor, current) {
     const result = rows.map(() => null);
     const top = Math.min(anchor.row, current.row);
@@ -102,7 +192,7 @@ export function selectionRanges(rows, anchor, current) {
         let end;
         if (anchor.row === current.row) {
             start = Math.min(anchor.col, current.col);
-            end = Math.max(anchor.col, current.col);
+            end = Math.max(anchor.col, current.col) + 1;
         }
         else if (r === anchor.row) {
             if (anchor.row < current.row) {
@@ -111,13 +201,13 @@ export function selectionRanges(rows, anchor, current) {
             }
             else {
                 start = 0;
-                end = anchor.col;
+                end = anchor.col + 1;
             }
         }
         else if (r === current.row) {
             if (anchor.row < current.row) {
                 start = 0;
-                end = current.col;
+                end = current.col + 1;
             }
             else {
                 start = current.col;
@@ -128,7 +218,9 @@ export function selectionRanges(rows, anchor, current) {
             start = 0;
             end = width;
         }
-        result[r] = { start: Math.max(0, start), end };
+        start = Math.max(0, start);
+        if (end > start)
+            result[r] = { start, end };
     }
     return result;
 }