@tianmucreations/jeeves 0.3.0 → 0.3.2

package/dist/components/OpenRouterConnect.js

@@ -0,0 +1,114 @@
+import { Fragment as _Fragment, jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { useEffect, useRef, useState } from 'react';
+import { Box, Text, useInput } from 'ink';
+import { signInWithOpenRouter, WAITING_STEPS } from '../providers/openrouter-signin.js';
+import { noCreditNote } from '../providers/openrouter.js';
+import { storeOpenRouterKey, refreshCredit } from '../providers/index.js';
+import { keyLooksValid } from '../commands/keys.js';
+import { isMouseSequence } from '../ink/mouse.js';
+import { KEY_STORE, KEY_STORE_SUBJECT } from '../platform/wording.js';
+const CHOICES = [
+    { title: 'Sign in with OpenRouter (recommended)', detail: 'Your browser opens. Log in, or make a free account, then click Authorize and come back. No key to copy.' },
+    { title: 'Paste a key I already have', detail: 'For people who already made a key at openrouter.ai/keys.' },
+];
+export function OpenRouterConnect({ hasKey, onDone, onBack }) {
+    const [step, setStep] = useState('choose');
+    const [cursor, setCursor] = useState(0);
+    const [pasted, setPasted] = useState('');
+    const [note, setNote] = useState('');
+    const [address, setAddress] = useState('');
+    const signingIn = useRef(null);
+    useEffect(() => () => signingIn.current?.abort(), []);
+    async function saveKey(key, how) {
+        if (!(await storeOpenRouterKey(key))) {
+            setStep('choose');
+            setNote(`${KEY_STORE_SUBJECT} was not reachable - please try again.`);
+            return;
+        }
+        void refreshCredit();
+        const credit = await noCreditNote(key);
+        const saved = how === 'signed-in'
+            ? `Connected - Jeeves is signed in to OpenRouter, and the key is saved securely in ${KEY_STORE}.`
+            : `Your OpenRouter key is saved securely in ${KEY_STORE}. You will not be asked for it again.`;
+        onDone(credit ? `${saved} ${credit}` : saved);
+    }
+    function signIn() {
+        const controller = new AbortController();
+        signingIn.current = controller;
+        setStep('waiting');
+        setNote('');
+        setAddress('');
+        void signInWithOpenRouter({ signal: controller.signal, onUrl: setAddress }).then((result) => {
+            signingIn.current = null;
+            if (result.ok) {
+                void saveKey(result.key, 'signed-in');
+                return;
+            }
+            setStep('choose');
+            if (result.reason === 'cancelled')
+                return;
+            setNote(result.reason === 'timeout'
+                ? 'No approval arrived after fifteen minutes, so I stopped waiting. Choose Sign in to try again.'
+                : "OpenRouter didn't complete the sign-in. Choose Sign in to try again, or paste a key.");
+        });
+    }
+    useInput((input, key) => {
+        if (isMouseSequence(input))
+            return;
+        if (step === 'waiting') {
+            if (key.escape)
+                signingIn.current?.abort();
+            return;
+        }
+        if (step === 'paste') {
+            if (key.escape) {
+                setStep('choose');
+                setPasted('');
+                setNote('');
+                return;
+            }
+            if (key.return) {
+                const value = pasted.trim();
+                if (!value) {
+                    setNote('Paste your key first - or press Esc to go back and choose Sign in instead.');
+                    return;
+                }
+                if (!keyLooksValid(value, 'openrouter')) {
+                    setPasted('');
+                    setNote('That does not look like an OpenRouter key (they start with sk-or-) - paste it again.');
+                    return;
+                }
+                void saveKey(value, 'pasted');
+                return;
+            }
+            if (key.backspace || key.delete) {
+                setPasted((current) => current.slice(0, -1));
+                return;
+            }
+            if (!input || key.ctrl || key.meta)
+                return;
+            setNote('');
+            setPasted((current) => current + input.replace(/[\r\n]/g, ''));
+            return;
+        }
+        // step: choose
+        if (key.escape)
+            return onBack();
+        if (key.upArrow || key.downArrow) {
+            setCursor((current) => (current === 0 ? 1 : 0));
+            return;
+        }
+        if (input === '1' || input === '2') {
+            setCursor(Number(input) - 1);
+        }
+        if (key.return || input === '1' || input === '2') {
+            const choice = input === '1' ? 0 : input === '2' ? 1 : cursor;
+            setNote('');
+            if (choice === 0)
+                signIn();
+            else
+                setStep('paste');
+        }
+    });
+    return (_jsxs(Box, { flexDirection: "column", flexGrow: 1, children: [_jsx(Text, { dimColor: true, children: "Connect Jeeves to OpenRouter" }), _jsxs(Box, { flexDirection: "column", flexGrow: 1, justifyContent: "center", children: [step === 'choose' && (_jsxs(_Fragment, { children: [_jsx(Text, { children: "OpenRouter runs the AI models Jeeves thinks with. One account gives you hundreds of models, and you pay only for what you use." }), hasKey ? _jsx(Text, { color: "yellow", children: "You already have an OpenRouter key saved. A new one replaces it - same account, same credit." }) : null, _jsx(Text, { children: " " }), CHOICES.map((choice, index) => (_jsxs(Box, { flexDirection: "column", marginBottom: 1, children: [_jsx(Text, { inverse: index === cursor, children: ` ${index + 1}. ${choice.title} ` }), _jsx(Box, { paddingLeft: 4, children: _jsx(Text, { dimColor: true, children: choice.detail }) })] }, choice.title)))] })), step === 'waiting' && (_jsxs(_Fragment, { children: [WAITING_STEPS.map((line) => (_jsx(Text, { children: line }, line))), _jsx(Text, { children: " " }), address ? _jsx(Text, { dimColor: true, children: `Browser didn't open? Go to: ${address}` }) : null] })), step === 'paste' && (_jsxs(_Fragment, { children: [_jsxs(Text, { children: [_jsx(Text, { children: "Paste your OpenRouter key (it stays hidden): " }), _jsx(Text, { dimColor: true, children: pasted ? `${pasted.length} characters ` : '' }), _jsx(Text, { inverse: true, children: " " })] }), _jsx(Text, { dimColor: true, children: "Keys start with sk-or- and are made at openrouter.ai/keys." })] }))] }), note ? (_jsx(Text, { color: "yellow", children: note })) : (_jsx(Text, { dimColor: true, children: step === 'choose' ? '↑↓ or 1 / 2 choose · Enter continue · Esc back' : step === 'waiting' ? 'Esc stop waiting' : 'paste the key · Enter save · Esc back' }))] }));
+}

package/dist/components/ProjectPicker.js

@@ -6,10 +6,11 @@ import { existsSync } from 'node:fs';
 import { mkdir } from 'node:fs/promises';
 import path from 'node:path';
 import { session, useSession } from '../state/session.js';
-import { setRecentProjects } from '../platform/config.js';
+import { setRecentProjects, getAddress, getDefaultModel } from '../platform/config.js';
 import { homeLocations, listSubfolders, displayPath, projectNameProblem } from '../platform/paths.js';
-import { hasCredentials } from '../providers/index.js';
+import { hasCredentials, keysRead } from '../providers/index.js';
 import { isMouseSequence } from '../ink/mouse.js';
+import { ensureChatFolder, chatNotice } from '../platform/chat-folder.js';
 // The cursor skips header lines; every other row is selectable.
 function resolveIndex(items, cursor) {
     const start = cursor < 0 ? 0 : cursor;
@@ -57,7 +58,8 @@ export function ProjectPicker({ rows, columns }) {
     const items = useMemo(() => {
         if (mode === 'list') {
             const recents = s.recentProjects.filter((folder) => existsSync(folder));
-            const out = [];
+            // First, for anyone who only wants to ask something: no project needed.
+            const out = [{ kind: 'chat' }];
             if (recents.length > 0) {
                 out.push({ kind: 'header', label: 'Recent projects' });
                 for (const folder of recents)
@@ -96,24 +98,46 @@ export function ProjectPicker({ rows, columns }) {
     const half = Math.floor(listHeight / 2);
     const start = Math.max(0, Math.min(items.length - listHeight, resolved - half));
     const visible = items.slice(start, start + listHeight);
-    function startProject(folder) {
+    function startChat() {
+        const folder = ensureChatFolder();
+        if (!folder) {
+            setNote("The Jeeves Chats folder couldn't be made in Documents - pick a project instead.");
+            return;
+        }
+        startProject(folder, false);
+    }
+    function startProject(folder, remember = true) {
         try {
             process.chdir(folder);
         }
         catch {
             // Staying in the current folder is the safe fallback.
         }
-        const updated = [folder, ...session.recentProjects.filter((p) => p !== folder)].slice(0, 10);
-        session.setRecentProjects(updated);
-        setRecentProjects(updated);
-        session.launchComplete();
-        session.addNotice(`Now working in ${displayPath(folder)}.`);
-        if (!hasCredentials()) {
-            session.startWizard(true);
+        // The chat folder is not a project, so it never joins the recent list.
+        if (remember) {
+            const updated = [folder, ...session.recentProjects.filter((p) => p !== folder)].slice(0, 10);
+            session.setRecentProjects(updated);
+            setRecentProjects(updated);
         }
-        else {
-            session.openPicker();
+        const switching = session.switchingFolder;
+        session.launchComplete();
+        session.addNotice(remember ? `Now working in ${displayPath(folder)}.` : chatNotice(getAddress() ?? 'Sir'));
+        if (switching) {
+            // The conversation carries on in the new folder; the model is told it moved.
+            session.pendingContextNote = `[The person moved Jeeves to ${remember ? `the folder ${folder}` : `the chat folder ${folder}`}. Files mentioned earlier may not be here - look again before relying on them.]`;
+            return;
         }
+        // Only once the saved keys have been read can "no key yet" be true.
+        void keysRead().then(() => {
+            if (!hasCredentials()) {
+                session.startWizard(true);
+            }
+            else if (!getDefaultModel()) {
+                // The model list only when no model has been chosen yet - not every morning
+                // (Claude Code starts straight in the conversation; /model changes it).
+                session.openPicker();
+            }
+        });
     }
     async function createProject(folder) {
         try {
@@ -209,7 +233,13 @@ export function ProjectPicker({ rows, columns }) {
         }
         if (key.escape) {
             if (mode === 'list') {
-                startProject(process.cwd());
+                // From /folder: back to the conversation, nothing changed. On first launch:
+                // Just chat - never the folder Jeeves happened to start in, which for most
+                // people is their whole home folder.
+                if (session.switchingFolder)
+                    session.launchComplete();
+                else
+                    startChat();
                 return;
             }
             if (mode === 'create-location') {
@@ -241,6 +271,8 @@ export function ProjectPicker({ rows, columns }) {
             const item = items[resolved];
             if (!item)
                 return;
+            if (item.kind === 'chat')
+                startChat();
             if (item.kind === 'recent')
                 startProject(item.folder);
             if (item.kind === 'browse') {
@@ -283,7 +315,9 @@ export function ProjectPicker({ rows, columns }) {
         }
     });
     const title = mode === 'list'
-        ? 'Choose a project'
+        ? session.switchingFolder
+            ? 'Change folder - or Just chat'
+            : 'Just chat, or choose a project'
         : mode === 'create-name'
             ? 'Create a new project'
             : mode === 'create-location'
@@ -296,7 +330,9 @@ export function ProjectPicker({ rows, columns }) {
                             ? `Open a folder - now in ${displayPath(current)}`
                             : 'Open a folder - where do you keep your projects?';
     const hint = mode === 'list'
-        ? '↑↓ move · Enter choose · Esc current folder'
+        ? session.switchingFolder
+            ? '↑↓ move · Enter choose · Esc back to the conversation'
+            : '↑↓ move · Enter choose · Esc just chat'
         : mode === 'create-name'
             ? 'type a name · Enter continue · Esc cancel'
             : mode === 'create-location'
@@ -314,6 +350,9 @@ export function ProjectPicker({ rows, columns }) {
                             const name = path.basename(item.folder);
                             return (_jsxs(Text, { inverse: selected, wrap: "truncate-middle", children: [` ${name}`.padEnd(26), _jsx(Text, { dimColor: true, children: displayPath(item.folder) })] }, `r${item.folder}`));
                         }
+                        if (item.kind === 'chat') {
+                            return (_jsxs(Text, { inverse: selected, children: [_jsx(Text, { color: "#c9a96a", bold: true, children: ' Just chat' }), _jsx(Text, { dimColor: true, children: ' - no project needed' })] }, "chat"));
+                        }
                         if (item.kind === 'browse') {
                             return (_jsx(Text, { inverse: selected, children: ' Browse for a folder →' }, `b${absoluteIndex}`));
                         }

package/dist/components/Transcript.js

@@ -1,8 +1,37 @@
-import { jsx as _jsx } from "react/jsx-runtime";
+import { Fragment as _Fragment, jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
 import { useEffect, useMemo, useRef } from 'react';
 import { Box, Text, useBoxMetrics, useStdout } from 'ink';
 import { session, useSession } from '../state/session.js';
-import { buildDisplayLines } from './transcript-layout.js';
+import { buildDisplayLines, OWN_MESSAGE_BACKGROUND, OWN_MESSAGE_TEXT } from './transcript-layout.js';
+import { selectedRange } from '../ink/selection.js';
+// A formatted line cut into pieces wherever the style or the selection changes.
+function styledSegments(text, spans, selected) {
+    const cuts = new Set([0, text.length]);
+    for (const span of spans) {
+        cuts.add(span.from);
+        cuts.add(span.to);
+    }
+    if (selected) {
+        cuts.add(selected[0]);
+        cuts.add(selected[1]);
+    }
+    const points = [...cuts].filter((n) => n >= 0 && n <= text.length).sort((a, b) => a - b);
+    const pieces = [];
+    for (let i = 0; i < points.length - 1; i++) {
+        const [from, to] = [points[i], points[i + 1]];
+        if (from === to)
+            continue;
+        const style = spans.filter((span) => span.from <= from && span.to >= to);
+        pieces.push(_jsx(Text, { bold: style.some((span) => span.bold), italic: style.some((span) => span.italic), color: style.some((span) => span.code) ? CODE_COLOUR : undefined, inverse: selected !== null && from >= selected[0] && to <= selected[1], children: text.slice(from, to) }, from));
+    }
+    return pieces;
+}
+// Inline code in Tianmu gold, as Claude Code gives it its own colour.
+const CODE_COLOUR = '#c9a96a';
+// Where the conversation sits on screen (1-based): below the top border and the
+// header row, one column in past the border and one of padding (app.tsx).
+const VIEW_TOP = 3;
+const VIEW_LEFT = 3;
 // Claude Code's ScrollBox pattern (ch13-14-terminal-ui.md): the outer box clips at
 // the viewport with overflow="hidden" and flexGrow={1}, so the transcript fills
 // every row left over by the fixed header, input, and footer slots - no dead space.
@@ -34,5 +63,13 @@ export function Transcript({ width }) {
     useEffect(() => {
         session.setTranscriptScrollMax(maxScroll);
     }, [maxScroll]);
-    return (_jsx(Box, { flexDirection: "column", overflow: "hidden", flexGrow: 1, justifyContent: "flex-end", ref: outer, children: _jsx(Box, { flexDirection: "column", flexShrink: 0, marginBottom: -scrollTop, ref: inner, children: lines.map((line, index) => (_jsx(Text, { color: line.color, dimColor: line.dim, children: line.text }, index))) }) }));
+    // The mouse turns a screen position into a line and character with this.
+    session.transcriptView = { top: VIEW_TOP, left: VIEW_LEFT, height: viewport.height, lines: lines.map((line) => line.text), scrollTop };
+    return (_jsx(Box, { flexDirection: "column", overflow: "hidden", flexGrow: 1, justifyContent: "flex-end", ref: outer, children: _jsx(Box, { flexDirection: "column", flexShrink: 0, marginBottom: -scrollTop, ref: inner, children: lines.map((line, index) => {
+                // Selected text is drawn reversed, as a terminal's own selection is.
+                const range = s.selection ? selectedRange(index, line.text.length) : null;
+                if (line.spans)
+                    return _jsx(Text, { children: styledSegments(line.text, line.spans, range) }, index);
+                return (_jsx(Text, { color: line.own ? OWN_MESSAGE_TEXT : line.color, backgroundColor: line.own ? OWN_MESSAGE_BACKGROUND : undefined, dimColor: line.dim, children: range ? (_jsxs(_Fragment, { children: [line.text.slice(0, range[0]), _jsx(Text, { inverse: true, children: line.text.slice(range[0], range[1]) }), line.text.slice(range[1])] })) : (line.text) }, index));
+            }) }) }));
 }

package/dist/components/input-layout.js

@@ -32,3 +32,164 @@ export function inputView(value, rowWidth) {
 export function dropLastChar(value) {
     return Array.from(value).slice(0, -1).join('');
 }
+// Wraps at word boundaries (a space at the edge ends the row and is not drawn),
+// remembering where each row starts in the message so the cursor and clicks can
+// be placed. Pasted line breaks start new rows.
+function wrapLines(chars, maxWidth) {
+    const lines = [];
+    let paragraphStart = 0;
+    const value = chars.join('');
+    for (const paragraph of value.split('\n')) {
+        const pchars = Array.from(paragraph);
+        let line = '';
+        let lineStart = paragraphStart;
+        pchars.forEach((ch, i) => {
+            const at = paragraphStart + i;
+            if (stringWidth(line + ch) <= maxWidth) {
+                line += ch;
+                return;
+            }
+            if (ch === ' ') {
+                // A space at the edge ends the row; the next word starts the next row.
+                lines.push({ text: line, start: lineStart });
+                line = '';
+                lineStart = at + 1;
+                return;
+            }
+            const lineChars = Array.from(line);
+            const lastSpace = lineChars.lastIndexOf(' ');
+            if (lastSpace > 0) {
+                lines.push({ text: lineChars.slice(0, lastSpace).join(''), start: lineStart });
+                line = lineChars.slice(lastSpace + 1).join('') + ch;
+                lineStart = lineStart + lastSpace + 1;
+            }
+            else {
+                lines.push({ text: line, start: lineStart });
+                line = ch;
+                lineStart = at;
+            }
+        });
+        lines.push({ text: line, start: lineStart });
+        paragraphStart += pchars.length + 1;
+    }
+    return lines;
+}
+// Which row a character position is on: the last row starting at or before it.
+function lineOf(lines, position) {
+    let found = 0;
+    lines.forEach((line, index) => {
+        if (line.start <= position)
+            found = index;
+    });
+    return found;
+}
+// The input box grows as the message does (as in Claude Code): the text wraps at
+// word boundaries onto new rows, up to maxRows, then the oldest rows scroll away so
+// the end of the message - where the typing is - shows. A message taller than the
+// box can be read back: scrollUp moves the view towards the start (Claude Code's
+// Up/Down move through a message that spans more than one line), and a dim line
+// at the top or bottom says how many lines are out of view. Pasted line breaks
+// start new rows. One column is kept spare so the cursor stays inside the box.
+// This keeps inputView's two rules: every keystroke still changes what is drawn (a
+// wrap adds a row, which resizes the box), and the last row's trailing spaces are
+// returned apart so they can be styled.
+// cursor: the cursor's place in the message in characters, or null for the end.
+// Inside the text it is drawn as a highlighted character, as Claude Code draws it,
+// which also keeps every cursor move a visible change.
+export function inputLayout(value, rowWidth, maxRows = 6, scrollUp = 0, cursor = null) {
+    const maxWidth = Math.max(1, rowWidth - 1);
+    const chars = Array.from(value);
+    const lines = wrapLines(chars, maxWidth);
+    const inside = cursor !== null && cursor < chars.length;
+    const cursorLine = inside ? lineOf(lines, cursor) : lines.length - 1;
+    const mark = (line, index, row) => {
+        if (!inside || index !== cursorLine)
+            return row;
+        return { ...row, cursorAt: Math.min(cursor - line.start, Array.from(line.text).length) };
+    };
+    if (lines.length <= maxRows) {
+        const rows = lines.map((line, index) => {
+            if (index < lines.length - 1 || inside)
+                return mark(line, index, { text: line.text, trailingSpaces: '', start: line.start });
+            const text = line.text.replace(/ +$/, '');
+            return { text, trailingSpaces: line.text.slice(text.length), start: line.start };
+        });
+        return { rows, cursorX: stringWidth(lines[lines.length - 1]?.text ?? ''), scrollUp: 0, maxScrollUp: 0, cursorVisible: true, cursorLine };
+    }
+    // Too tall for the box. Scrolled all the way back, the first maxRows-1 lines show
+    // above a "below" hint; at the end, a hint above the last maxRows-1 lines.
+    const maxScrollUp = lines.length - (maxRows - 1);
+    const up = Math.max(0, Math.min(scrollUp, maxScrollUp));
+    const end = lines.length - up;
+    const slots = maxRows - (up > 0 ? 1 : 0);
+    const start = end - slots <= 0 ? 0 : end - (slots - 1);
+    const rows = [];
+    // A hint never wraps: in a narrow window it is cut to the row.
+    const hint = (text) => ({ text: Array.from(text).slice(0, maxWidth).join(''), trailingSpaces: '', hint: true });
+    if (start > 0)
+        rows.push(hint(`↑ ${start} more line${start === 1 ? '' : 's'} above - ↑ ↓ to read`));
+    lines.slice(start, end).forEach((line, offset, shown) => {
+        const index = start + offset;
+        if (up > 0 || inside || offset < shown.length - 1) {
+            rows.push(mark(line, index, { text: line.text, trailingSpaces: '', start: line.start }));
+            return;
+        }
+        const text = line.text.replace(/ +$/, '');
+        rows.push({ text, trailingSpaces: line.text.slice(text.length), start: line.start });
+    });
+    if (up > 0)
+        rows.push(hint(`↓ ${up} more line${up === 1 ? '' : 's'} below - ↓ or keep typing to return`));
+    return {
+        rows,
+        cursorX: stringWidth(lines[lines.length - 1]?.text ?? ''),
+        scrollUp: up,
+        maxScrollUp,
+        cursorVisible: cursorLine >= start && cursorLine < end,
+        cursorLine,
+    };
+}
+// The scroll position that brings a cursor inside the text into view, keeping the
+// current one when it already shows.
+export function scrollToShowCursor(value, rowWidth, maxRows, scrollUp, cursor) {
+    const first = inputLayout(value, rowWidth, maxRows, scrollUp, cursor);
+    if (first.cursorVisible || first.maxScrollUp === 0)
+        return first.scrollUp;
+    for (let up = 0; up <= first.maxScrollUp; up++) {
+        if (inputLayout(value, rowWidth, maxRows, up, cursor).cursorVisible)
+            return up;
+    }
+    return first.scrollUp;
+}
+// Word jumps (Option + arrows): to the start of the previous word, or the end of the next.
+export function previousWordStart(value, cursor) {
+    const chars = Array.from(value);
+    let i = Math.min(cursor, chars.length);
+    while (i > 0 && /\s/.test(chars[i - 1]))
+        i--;
+    while (i > 0 && !/\s/.test(chars[i - 1]))
+        i--;
+    return i;
+}
+export function nextWordEnd(value, cursor) {
+    const chars = Array.from(value);
+    let i = cursor;
+    while (i < chars.length && /\s/.test(chars[i]))
+        i++;
+    while (i < chars.length && !/\s/.test(chars[i]))
+        i++;
+    return i;
+}
+// A burst of typed characters can arrive together with Enter (when Jeeves is busy
+// and the keyboard runs ahead). The text before the first line break is typed text,
+// and the break itself is Enter. Measured 18 Sept: the break was otherwise stored in
+// the message as a carriage return, which pushed the text over the window's border.
+export function splitTypedBurst(input) {
+    const match = /\r\n|\r|\n/.exec(input);
+    if (!match)
+        return { typed: input, enter: false, rest: '' };
+    return { typed: input.slice(0, match.index), enter: true, rest: input.slice(match.index + match[0].length).replace(/\r\n|\r/g, '\n') };
+}
+// Pasted text keeps its line breaks (as newlines) and never sends by itself.
+export function cleanPaste(text) {
+    return text.replace(/\r\n|\r/g, '\n').replace(/\t/g, '  ');
+}

package/dist/components/markdown.js

@@ -0,0 +1,185 @@
+import { marked } from 'marked';
+let configured = false;
+function configure() {
+    if (configured)
+        return;
+    configured = true;
+    // As Claude Code: no strikethrough - "~100" means "about 100", not crossed out.
+    marked.use({ tokenizer: { del: () => undefined } });
+}
+class Builder {
+    text = '';
+    spans = [];
+    add(value, style) {
+        if (!value)
+            return;
+        if (style && (style.bold || style.italic || style.code)) {
+            this.spans.push({ from: this.text.length, to: this.text.length + value.length, ...style });
+        }
+        this.text += value;
+    }
+    newline() {
+        this.text += '\n';
+    }
+    // One blank line between blocks, never more.
+    endBlock() {
+        if (!this.text)
+            return;
+        if (!this.text.endsWith('\n'))
+            this.text += '\n';
+        if (!this.text.endsWith('\n\n'))
+            this.text += '\n';
+    }
+}
+function inline(b, tokens, style = {}) {
+    for (const token of tokens ?? []) {
+        switch (token.type) {
+            case 'strong':
+                inline(b, token.tokens, { ...style, bold: true });
+                break;
+            case 'em':
+                inline(b, token.tokens, { ...style, italic: true });
+                break;
+            case 'codespan':
+                b.add(token.text, { ...style, code: true });
+                break;
+            case 'link': {
+                const link = token;
+                const start = b.text.length;
+                inline(b, link.tokens, style);
+                const shown = b.text.slice(start);
+                // The address is shown too when the words don't already say it.
+                if (link.href && shown !== link.href && !link.href.startsWith('mailto:'))
+                    b.add(` (${link.href})`, style);
+                break;
+            }
+            case 'br':
+                b.newline();
+                break;
+            case 'image':
+                b.add(token.href, style);
+                break;
+            case 'text': {
+                const text = token;
+                if (text.tokens)
+                    inline(b, text.tokens, style);
+                else
+                    b.add(decode(text.text), style);
+                break;
+            }
+            default:
+                b.add(decode(token.text ?? token.raw), style);
+        }
+    }
+}
+function block(b, token, indent = '') {
+    switch (token.type) {
+        case 'space':
+            break;
+        case 'heading':
+            b.endBlock();
+            b.add(indent);
+            inline(b, token.tokens, { bold: true });
+            b.endBlock();
+            break;
+        case 'paragraph':
+            b.add(indent);
+            inline(b, token.tokens);
+            b.endBlock();
+            break;
+        case 'list': {
+            const list = token;
+            list.items.forEach((item, index) => {
+                const marker = list.ordered ? `${Number(list.start || 1) + index}. ` : '- ';
+                b.add(indent + marker);
+                let first = true;
+                for (const part of item.tokens) {
+                    if (part.type === 'list') {
+                        if (!b.text.endsWith('\n'))
+                            b.newline();
+                        block(b, part, indent + '  ');
+                        continue;
+                    }
+                    if (!first && !b.text.endsWith('\n'))
+                        b.newline();
+                    if (!first)
+                        b.add(indent + '  ');
+                    if (part.type === 'text' || part.type === 'paragraph')
+                        inline(b, part.tokens ?? [part]);
+                    else
+                        inline(b, [part]);
+                    first = false;
+                }
+                if (!b.text.endsWith('\n'))
+                    b.newline();
+            });
+            b.endBlock();
+            break;
+        }
+        case 'blockquote': {
+            const inner = new Builder();
+            for (const part of token.tokens)
+                block(inner, part);
+            for (const line of inner.text.replace(/\n+$/, '').split('\n')) {
+                b.add(`${indent}│ `);
+                b.add(line, { italic: true });
+                b.newline();
+            }
+            b.endBlock();
+            break;
+        }
+        case 'code':
+            for (const line of token.text.split('\n')) {
+                b.add(indent + line, { code: true });
+                b.newline();
+            }
+            b.endBlock();
+            break;
+        case 'hr':
+            b.add(indent + '---');
+            b.endBlock();
+            break;
+        case 'table': {
+            const table = token;
+            const cell = (c) => {
+                const t = new Builder();
+                inline(t, c.tokens);
+                return t.text;
+            };
+            const rows = [table.header.map(cell), ...table.rows.map((row) => row.map(cell))];
+            const widths = rows[0].map((_, i) => Math.max(3, ...rows.map((row) => (row[i] ?? '').length)));
+            rows.forEach((row, r) => {
+                const line = `| ${row.map((c, i) => c.padEnd(widths[i])).join(' | ')} |`;
+                b.add(indent + line, r === 0 ? { bold: true } : undefined);
+                b.newline();
+                if (r === 0) {
+                    b.add(`${indent}|${widths.map((w) => '-'.repeat(w + 2)).join('|')}|`);
+                    b.newline();
+                }
+            });
+            b.endBlock();
+            break;
+        }
+        default:
+            b.add(indent + decode(token.text ?? token.raw));
+            b.endBlock();
+    }
+}
+// marked keeps HTML escapes (& " ') in its text; the screen wants the characters.
+function decode(text) {
+    return text.replace(/&(amp|lt|gt|quot|#39);/g, (_, name) => ({ amp: '&', lt: '<', gt: '>', quot: '"', '#39': "'" })[name] ?? _);
+}
+export function renderMarkdown(source) {
+    configure();
+    const b = new Builder();
+    try {
+        for (const token of marked.lexer(source))
+            block(b, token);
+    }
+    catch {
+        // Anything the reader can't follow is shown exactly as written.
+        return { text: source, spans: [] };
+    }
+    const text = b.text.replace(/\n+$/, '');
+    return { text, spans: b.spans.filter((span) => span.from < text.length).map((span) => ({ ...span, to: Math.min(span.to, text.length) })) };
+}