@itookit/dsht 0.3.0 → 0.3.3

package/dist/{export.d.ts → session/export.d.ts}

@@ -1,4 +1,4 @@
-import type { Client } from './client.ts';
+import type { Client } from '../transport/client.ts';
 /** Save an archive without overwriting an existing file or retaining a partial download.
  * @param client - Authenticated host transport.
  * @param sessionId - Selected session to export.

package/dist/{export.js → session/export.js}

@@ -1,6 +1,6 @@
 /** Stream authenticated session archives to exclusive local files. */
-import { open, unlink } from 'node:fs/promises';
 import { resolve } from 'node:path';
+import { writeExclusiveStream } from "../storage/index.js";
 /** Save an archive without overwriting an existing file or retaining a partial download.
  * @param client - Authenticated host transport.
  * @param sessionId - Selected session to export.
@@ -10,14 +10,12 @@ import { resolve } from 'node:path';
  */
 export async function saveSessionLog(client, sessionId, destination, signal) {
     const path = resolve(destination ?? `session-${sessionId.replace(/[^a-zA-Z0-9_-]/g, '_')}-${Date.now()}.zip`);
-    const file = await open(path, 'wx', 0o600);
-    let complete = false;
-    try {
+    await writeExclusiveStream(path, async () => {
         const response = await client.sessionLog(sessionId, signal);
         if (!response.body)
             throw new Error('Session log export has no body');
         const reader = response.body.getReader();
-        async function* chunks() {
+        return (async function* chunks() {
             try {
                 while (true) {
                     const chunk = await reader.read();
@@ -34,19 +32,7 @@ export async function saveSessionLog(client, sessionId, destination, signal) {
                     reader.releaseLock();
                 }
             }
-        }
-        await file.writeFile(chunks(), { signal });
-        signal.throwIfAborted();
-        complete = true;
-        return path;
-    }
-    finally {
-        try {
-            await file.close();
-        }
-        finally {
-            if (!complete)
-                await unlink(path);
-        }
-    }
+        })();
+    }, signal);
+    return path;
 }

package/dist/{history.d.ts → session/history.d.ts}

@@ -1,4 +1,5 @@
 import { type Message, type MessagePart, type Transcript } from './transcript.ts';
+import { type MarkdownSpan } from './markdown.ts';
 /** Default fold mode; individual sequence overrides are view state, never stored content. */
 export type Reasoning = 'row' | 'full';
 /** Color semantics are independent of the selected terminal palette. */
@@ -9,11 +10,27 @@ export interface HistoryRow {
     kind: RowKind;
     bold?: boolean;
     seq?: number;
+    spans?: MarkdownSpan[];
 }
 /** Drop all terminal rows and layout metadata for an evicted or inactive transcript.
  * @param transcript - Transcript whose previously returned layout is no longer used.
  */
 export declare function releaseHistoryLayout(transcript: Transcript): void;
+/** Report what one transcript's layout still holds, for memory samples and diagnostics.
+ *
+ * The row cache is the only structure that grows with expanded reasoning and Markdown rows, and
+ * its byte bound counts neither the span objects nor the incremental live-tail state.
+ * @param transcript - Transcript whose layout should be measured.
+ * @returns Cache and live-tail counters, or undefined when no layout was built yet.
+ */
+export declare function layoutStats(transcript: Transcript): {
+    rows: number;
+    cacheBytes: number;
+    spans: number;
+    spanChars: number;
+    liveWraps: number;
+    liveMarkdown: number;
+} | undefined;
 /** Lay out an indexed conversation without concatenating its historical rows on every stream frame.
  * @param transcript - Selected session's semantic content and unfinished assistant output.
  * @param width - Available terminal columns.

package/dist/{history.js → session/history.js}

@@ -1,6 +1,7 @@
 /** Indexed semantic history with bounded terminal-row caching and viewport-only materialization. */
 import wrapAnsi from 'wrap-ansi';
 import { toolLine } from "./transcript.js";
+import { hasMarkdown, markdownRows } from "./markdown.js";
 /** A session owns one layout cache; dropped sessions release their entire cache. */
 class LayoutIndex {
     width;
@@ -15,6 +16,9 @@ class LayoutIndex {
     // Bound both row objects and long rows. Full semantic content remains available for search.
     maxRows = 2048;
     heights = new WeakMap();
+    /** Incremental wrapping state for the growing live tail, keyed by each live part's identity. */
+    liveWraps = new Map();
+    liveMarkdown = new Map();
     constructor(width, reasoning, overrides) {
         this.width = width;
         this.reasoning = reasoning;
@@ -51,8 +55,26 @@ class LayoutIndex {
         this.cacheSize = 0;
         this.length = 0;
         this.heights = new WeakMap();
+        this.liveWraps.clear();
+        this.liveMarkdown.clear();
     }
     get cachedRowCount() { return this.cacheSize; }
+    /** Measure what the row cache actually holds, including the style spans the byte bound ignores.
+     * @returns Cached rows, their accounted characters, and the span objects inside them.
+     */
+    stats() {
+        let cacheBytes = 0, spans = 0, spanChars = 0;
+        for (const { rows } of this.cache.values()) {
+            for (const row of rows) {
+                cacheBytes += row.text.length;
+                for (const span of row.spans ?? []) {
+                    spans++;
+                    spanChars += span.text.length;
+                }
+            }
+        }
+        return { rows: this.cacheSize, cacheBytes, spans, spanChars };
+    }
     get assistantSeen() { return this.segments.at(-1)?.assistantSeen ?? false; }
     update(messages) {
         if (messages === this.messages)
@@ -111,6 +133,108 @@ class LayoutIndex {
     }
 }
 const liveRows = new WeakMap();
+/** Wrap text into rows with the per-kind trimming rule.
+ * @param text - Text to wrap.
+ * @param width - Available terminal columns.
+ * @param kind - Part kind, which decides whether wrapped lines are trimmed.
+ * @param seq - Durable sequence, for committed parts.
+ * @returns The wrapped rows.
+ */
+function wrapRows(text, width, kind, seq) {
+    return wrapAnsi(text, width, { hard: true, trim: !['tool', 'success', 'error'].includes(kind) })
+        .split('\n').map(text => ({ text, kind, seq }));
+}
+/** Bound the source inspected for a folded row, which renders only the first `width` columns.
+ * @param text - Complete live text.
+ * @param width - Available terminal columns.
+ * @returns A prefix that cannot change the folded row.
+ */
+function foldedSource(text, width) {
+    let limit = width * 4 + 64;
+    while (limit < text.length && toolLine(text.slice(0, limit), width).length < width)
+        limit *= 2;
+    return limit >= text.length ? text : text.slice(0, limit);
+}
+/** Locate the start of one rendered row inside the source it was wrapped from.
+ *
+ * Trim removes the whitespace runs at both ends of a row, so a rendered row is not a contiguous
+ * slice; matching it backwards while skipping source whitespace recovers where it began. The scan
+ * gives up once it would have to skip more than `limit` characters, which sends the caller back to
+ * a whole-text wrap instead of scanning an unbounded whitespace run.
+ * @param pending - Source text the row was wrapped from.
+ * @param row - One rendered row from that wrap.
+ * @param limit - Maximum characters the backward scan may skip.
+ * @returns The row's start offset, or undefined when it cannot be located.
+ */
+function rawStart(pending, row, limit) {
+    let source = pending.length - 1;
+    let target = row.length - 1;
+    const floor = pending.length - limit;
+    while (target >= 0 && source >= floor) {
+        if (pending[source] === row[target]) {
+            source--;
+            target--;
+            continue;
+        }
+        if (/\s/u.test(pending[source])) {
+            source--;
+            continue;
+        }
+        return undefined;
+    }
+    return target < 0 ? source + 1 : undefined;
+}
+/** Wrap one live part incrementally, re-wrapping only rows that can still change plus the new delta.
+ *
+ * A streaming part only grows, so every row before its last non-empty one is final. The state keeps
+ * those rows plus the raw source of the unfinished remainder, and re-anchors from the whole text
+ * only when that remainder cannot be located or outgrows a few widths.
+ * @param part - One live part carrying a stable `key`.
+ * @param state - Per-layout state keyed by that identity.
+ * @param width - Available terminal columns.
+ * @param reasoning - Fold mode for completed live reasoning.
+ * @returns The part's rows.
+ */
+function livePartRows(part, state, width, reasoning) {
+    const key = part.key;
+    if (key === undefined)
+        return partRows([part], width, reasoning);
+    if (part.kind === 'reasoning' && reasoning === 'row' && (part.closed || width < 60)) {
+        state.delete(key);
+        return wrapRows(toolLine(`◇ /think live · ${foldedSource(part.text, width).slice(2)}`, width), width, 'reasoning');
+    }
+    const previous = state.get(key);
+    const extend = previous !== undefined && previous.width === width && previous.reasoning === reasoning
+        && previous.kind === part.kind && part.text.length >= previous.length;
+    const trim = !['tool', 'success', 'error'].includes(part.kind);
+    const limit = width * 8 + 512;
+    const attempt = (source, prior) => {
+        const wrapped = wrapAnsi(source, width, { hard: true, trim }).split('\n');
+        const filled = wrapped.reduce((found, text, index) => text === '' ? found : index, -1);
+        if (filled < 0)
+            return { rows: [], tail: wrapped, carry: source };
+        const start = rawStart(source, wrapped[filled], limit);
+        if (start === undefined)
+            return undefined;
+        return {
+            rows: [...prior, ...wrapped.slice(0, filled).map(text => ({ text, kind: part.kind }))],
+            tail: wrapped.slice(filled),
+            // The last non-empty row and everything after it, including trailing empty rows, stay unfinished.
+            carry: source.slice(start),
+        };
+    };
+    let result = attempt(extend ? previous.carry + part.text.slice(previous.length) : part.text, extend ? previous.rows : []);
+    if (result === undefined || result.carry.length > width * 4 + 64)
+        result = attempt(part.text, []);
+    // Recovery can fail on text whose last row cannot be located; the plain one-shot wrap is the fallback.
+    if (result === undefined) {
+        state.delete(key);
+        return partRows([part], width, reasoning);
+    }
+    const rows = [...result.rows, ...result.tail.map(text => ({ text, kind: part.kind }))];
+    state.set(key, { width, reasoning, kind: part.kind, length: part.text.length, rows: result.rows, carry: result.carry });
+    return rows;
+}
 function partRows(parts, width, reasoning, seq) {
     return parts.flatMap(part => {
         const cached = seq === undefined ? liveRows.get(part) : undefined;
@@ -118,7 +242,8 @@ function partRows(parts, width, reasoning, seq) {
             return cached.rows;
         const fold = part.kind === 'reasoning' && reasoning === 'row' && (seq !== undefined || part.closed || width < 60);
         const text = fold ? toolLine(`◇ /think${seq === undefined ? ' live' : ` ${seq}`} · ${part.text.slice(2)}`, width) : part.text;
-        const rows = wrapAnsi(text, width, { hard: true, trim: !['tool', 'success', 'error'].includes(part.kind) }).split('\n').map(text => ({ text, kind: part.kind, seq }));
+        const rows = part.kind === 'text' ? markdownRows(text, width).map(row => ({ ...row, kind: part.kind, seq }))
+            : wrapRows(text, width, part.kind, seq);
         if (seq === undefined)
             liveRows.set(part, { width, reasoning, rows });
         return rows;
@@ -142,6 +267,19 @@ export function releaseHistoryLayout(transcript) {
     indexes.get(transcript)?.dispose();
     indexes.delete(transcript);
 }
+/** Report what one transcript's layout still holds, for memory samples and diagnostics.
+ *
+ * The row cache is the only structure that grows with expanded reasoning and Markdown rows, and
+ * its byte bound counts neither the span objects nor the incremental live-tail state.
+ * @param transcript - Transcript whose layout should be measured.
+ * @returns Cache and live-tail counters, or undefined when no layout was built yet.
+ */
+export function layoutStats(transcript) {
+    const index = indexes.get(transcript);
+    if (!index)
+        return undefined;
+    return { ...index.stats(), liveWraps: index.liveWraps.size, liveMarkdown: index.liveMarkdown.size };
+}
 /** Lay out an indexed conversation without concatenating its historical rows on every stream frame.
  * @param transcript - Selected session's semantic content and unfinished assistant output.
  * @param width - Available terminal columns.
@@ -158,9 +296,32 @@ export function historyLayout(transcript, width, reasoning = 'row', overrides =
     }
     index.update(transcript.messagesForWidth(width));
     const live = transcript.liveParts(width);
+    const keys = new Set(live.map(part => part.key));
+    for (const key of index.liveWraps.keys())
+        if (!keys.has(key))
+            index.liveWraps.delete(key);
+    for (const key of index.liveMarkdown.keys())
+        if (!keys.has(key))
+            index.liveMarkdown.delete(key);
     const streamed = live.length ? [
         ...(transcript.liveToolOnly || index.assistantSeen ? [] : [{ text: '✦ Assistant · streaming', kind: 'assistant', bold: true }]),
-        ...partRows(live, width, liveReasoning),
+        ...live.flatMap(part => {
+            if (part.kind === 'text') {
+                const previous = part.key === undefined ? undefined : index.liveMarkdown.get(part.key);
+                const extendsPrevious = previous && part.text.length >= previous.length;
+                // Include the preceding line so a split list marker or blank line can change Markdown parsing.
+                const start = extendsPrevious ? part.text.lastIndexOf('\n', Math.max(0, previous.length - 2)) + 1 : 0;
+                const rich = !!(extendsPrevious && previous.rich) || hasMarkdown(part.text.slice(start));
+                if (part.key !== undefined)
+                    index.liveMarkdown.set(part.key, { length: part.text.length, rich });
+                if (rich) {
+                    if (part.key !== undefined)
+                        index.liveWraps.delete(part.key);
+                    return partRows([part], width, liveReasoning);
+                }
+            }
+            return livePartRows(part, index.liveWraps, width, liveReasoning);
+        }),
     ] : [];
     const committed = index;
     const length = committed.length + streamed.length;

package/dist/session/index.d.ts

@@ -0,0 +1,17 @@
+/** Session domain: the selected session, its transcript, layout, telemetry and navigation. */
+export { SessionController } from './controller.ts';
+export { contentText, toolLine, Transcript } from './transcript.ts';
+export type { LivePhase, Message, MessagePart, ThoughtEntry } from './transcript.ts';
+export { historyLayout, layoutStats, releaseHistoryLayout } from './history.ts';
+export { markdownCacheStats } from './markdown.ts';
+export type { HistoryRow, Reasoning, RowKind } from './history.ts';
+export { Telemetry } from './telemetry.ts';
+export type { QueuedInput } from './telemetry.ts';
+export { DEFAULT_HISTORY_LIMITS, historyLimits } from './memory.ts';
+export type { HistoryLimits } from './memory.ts';
+export { navigationCommand, resolveTarget, sessionLabel } from './navigation.ts';
+export { activeReference, fileMention, fileReferences } from './references.ts';
+export type { FileReference } from './references.ts';
+export { saveSessionLog } from './export.ts';
+export type { HistorySearch, RemovalTarget } from './types.ts';
+export type { ConnectionView } from './connection-view.ts';

package/dist/session/index.js

@@ -0,0 +1,10 @@
+/** Session domain: the selected session, its transcript, layout, telemetry and navigation. */
+export { SessionController } from "./controller.js";
+export { contentText, toolLine, Transcript } from "./transcript.js";
+export { historyLayout, layoutStats, releaseHistoryLayout } from "./history.js";
+export { markdownCacheStats } from "./markdown.js";
+export { Telemetry } from "./telemetry.js";
+export { DEFAULT_HISTORY_LIMITS, historyLimits } from "./memory.js";
+export { navigationCommand, resolveTarget, sessionLabel } from "./navigation.js";
+export { activeReference, fileMention, fileReferences } from "./references.js";
+export { saveSessionLog } from "./export.js";

package/dist/session/markdown.d.ts

@@ -0,0 +1,39 @@
+/** Local styles only; remote control sequences never become terminal instructions. */
+export interface MarkdownSpan {
+    text: string;
+    bold?: boolean;
+    italic?: boolean;
+    underline?: boolean;
+    strikethrough?: boolean;
+    inverse?: boolean;
+}
+/** A measured row retains plain text for searching, copying and row geometry. */
+export interface MarkdownRow {
+    text: string;
+    spans?: MarkdownSpan[];
+}
+/** Report the bounded math and diagram cache, so a memory sample can tell churn from retention.
+ * @returns Cached entries, their accounted characters, and lookup counters.
+ */
+export declare function markdownCacheStats(): {
+    entries: number;
+    chars: number;
+    hits: number;
+    misses: number;
+};
+/** Whether a source can contain Markdown constructs; false preserves incremental plain-text wrapping.
+ * @param source - Complete text or a delta with its preceding line.
+ * @returns Whether Markdown lexing is required.
+ */
+export declare function hasMarkdown(source: string): boolean;
+/** Parse GFM and TeX into styled rows whose widths match the terminal viewport.
+ * @param source - Model or user message; remote terminal controls are removed.
+ * @param width - Available terminal columns.
+ * @returns Terminal rows, with literal source for invalid or unsupported rich blocks.
+ */
+export declare function markdownRows(source: string, width: number): MarkdownRow[];
+/** Render safe, offline HTML with Mermaid SVG images and MathJax-generated MathML.
+ * @param source - Markdown source, never trusted as executable HTML.
+ * @returns An HTML fragment that requires no scripts or remote assets.
+ */
+export declare function markdownHtml(source: string): string;

package/dist/session/markdown.js

@@ -0,0 +1,255 @@
+/** Markdown becomes terminal rows before viewport indexing; source text remains in the transcript. */
+import { Marked } from 'marked';
+import { renderMermaidASCII, renderMermaidSVG } from 'beautiful-mermaid';
+import stringWidth from 'string-width';
+import wrapAnsi from 'wrap-ansi';
+import { stripVTControlCharacters } from 'node:util';
+import { decodeHTML } from 'entities';
+import { safeText } from "../transport/wire.js";
+import { renderMath } from "./math.js";
+const parser = new Marked({ gfm: true });
+// Math is tokenized before Markdown escapes, but after fenced and inline code have claimed their source.
+function mathToken(source, block) {
+    const match = block
+        ? /^(?:\$\$([\s\S]+?)\$\$|\\\[([\s\S]+?)\\\])(?:[ \t]*\n|$)/.exec(source)
+        : /^(?:\$\$([^\n]+?)\$\$|\$(?![\s$])((?:\\.|[^$\n\\])+?)(?<!\s)\$(?!\d)|\\\(([^\n]+?)\\\)|\\\[([^\n]+?)\\\])/.exec(source);
+    if (!match)
+        return undefined;
+    return { type: 'math', raw: match[0], text: match.slice(1).find(value => value !== undefined),
+        display: block || source.startsWith('$$') || source.startsWith('\\[') };
+}
+for (const level of ['block', 'inline'])
+    parser.use({ extensions: [{
+                name: 'math', level,
+                start: source => { const index = source.search(level === 'block' ? /\$\$|\\\[/ : /\$|\\[([]/); return index < 0 ? undefined : index; },
+                tokenizer: source => mathToken(source, level === 'block'),
+                renderer: token => mathHtml(token),
+            }] });
+const rendered = new Map();
+let cachedChars = 0;
+let cacheHits = 0;
+let cacheMisses = 0;
+function cached(key, render) {
+    const existing = rendered.get(key);
+    if (existing !== undefined) {
+        cacheHits++;
+        return existing;
+    }
+    cacheMisses++;
+    const result = render();
+    const size = key.length + result.length;
+    if (size <= 64 * 1024) {
+        while (rendered.size >= 128 || cachedChars + size > 256 * 1024) {
+            const oldest = rendered.keys().next().value;
+            cachedChars -= oldest.length + rendered.get(oldest).length;
+            rendered.delete(oldest);
+        }
+        rendered.set(key, result);
+        cachedChars += size;
+    }
+    return result;
+}
+/** Report the bounded math and diagram cache, so a memory sample can tell churn from retention.
+ * @returns Cached entries, their accounted characters, and lookup counters.
+ */
+export function markdownCacheStats() {
+    return { entries: rendered.size, chars: cachedChars, hits: cacheHits, misses: cacheMisses };
+}
+function mathText(token) {
+    return cached(`math:${token.display}:${token.text}`, () => renderMath(token.text, token.display)?.text ?? token.raw.trimEnd());
+}
+function mathHtml(token) {
+    return renderMath(token.text, token.display)?.html ?? `<code>${escapeHtml(token.raw)}</code>`;
+}
+function style(text, open, close) {
+    return `\x1b[${open}m${text.replaceAll(`\x1b[${close}m`, `\x1b[${close}m\x1b[${open}m`)}\x1b[${close}m`;
+}
+function plain(text) { return safeText(text).replace(/\t/g, '    '); }
+function inline(tokens) {
+    return tokens.map(token => {
+        switch (token.type) {
+            case 'strong': return style(inline(token.tokens), 1, 22);
+            case 'em': return style(inline(token.tokens), 3, 23);
+            case 'del': return style(inline(token.tokens), 9, 29);
+            case 'codespan': return style(plain(token.text), 7, 27);
+            case 'link': {
+                const label = inline(token.tokens);
+                const href = plain(token.href);
+                return style(label, 4, 24) + (stripVTControlCharacters(label) === href ? '' : ` (${href})`);
+            }
+            case 'image': return `${inline(token.tokens)} (${plain(token.href)})`;
+            case 'br': return '\n';
+            case 'math': return mathText(token);
+            case 'html': return /^<br\s*\/?\s*>$/i.test(token.raw) ? '\n' : plain(token.raw);
+            case 'escape': return plain(token.text);
+            default: return 'tokens' in token && token.tokens ? inline(token.tokens)
+                : plain(decodeHTML('text' in token && typeof token.text === 'string' ? token.text : token.raw));
+        }
+    }).join('');
+}
+function wrap(text, width, trim = true) {
+    return wrapAnsi(text, Math.max(1, width), { hard: true, trim }).split('\n');
+}
+function table(token, width) {
+    const cells = [token.header, ...token.rows].map(row => row.map(cell => inline(cell.tokens)));
+    const count = token.header.length;
+    const available = width - 3 * count - 1;
+    // Narrow screens show each record vertically instead of squeezing columns into unreadable fragments.
+    if (available < 12 * count) {
+        if (cells.length === 1)
+            return cells[0].flatMap(cell => wrap(style(cell, 1, 22), width));
+        return cells.slice(1).flatMap((row, index) => [
+            ...(index ? ['─'.repeat(Math.min(width, 20))] : []),
+            ...row.flatMap((cell, column) => wrap(`${cells[0][column] ? style(cells[0][column], 1, 22) + ': ' : ''}${cell}`, width)),
+        ]);
+    }
+    const widths = Array.from({ length: count }, (_, column) => Math.max(3, ...cells.map(row => Math.max(...row[column].split('\n').map(line => stringWidth(line))))));
+    while (widths.reduce((sum, value) => sum + value, 0) > available) {
+        const column = widths.indexOf(Math.max(...widths));
+        widths[column]--;
+    }
+    const border = (left, middle, right) => left + widths.map(size => '─'.repeat(size + 2)).join(middle) + right;
+    const output = [border('┌', '┬', '┐')];
+    cells.forEach((row, index) => {
+        const lines = row.map((cell, column) => wrap(index === 0 ? style(cell, 1, 22) : cell, widths[column]));
+        for (let line = 0; line < Math.max(...lines.map(cell => cell.length)); line++) {
+            output.push('│ ' + lines.map((cell, column) => {
+                const value = cell[line] ?? '';
+                const padding = widths[column] - stringWidth(value);
+                const align = token.align[column];
+                const before = align === 'right' ? padding : align === 'center' ? Math.floor(padding / 2) : 0;
+                return ' '.repeat(Math.max(0, before)) + value + ' '.repeat(Math.max(0, padding - before));
+            }).join(' │ ') + ' │');
+        }
+        if (index === 0)
+            output.push(border('├', '┼', '┤'));
+    });
+    output.push(border('└', '┴', '┘'));
+    return output;
+}
+function diagram(source, width) {
+    if (source.length > 16 * 1024)
+        return undefined;
+    try {
+        const text = cached(`mermaid:${source}`, () => {
+            // The ASCII renderer measures code units. Reserve one extra cell for each wide BMP character.
+            const padding = Array.from({ length: 256 }, (_, i) => String.fromCharCode(0xe000 + i)).find(c => !source.includes(c));
+            if (!padding)
+                throw new Error('No available diagram padding character');
+            const measured = [...source].map(c => c + padding.repeat(Math.max(0, stringWidth(c) - c.length))).join('');
+            return plain(renderMermaidASCII(measured, { colorMode: 'none' }).replaceAll(padding, ''));
+        });
+        const lines = text.trimEnd().split('\n').map(line => line.trimEnd());
+        return lines.every(line => stringWidth(line) <= width) ? lines : undefined;
+    }
+    catch {
+        return undefined; /* Unsupported or unfinished diagrams retain their source. */
+    }
+}
+function blocks(tokens, width) {
+    return tokens.flatMap(token => {
+        switch (token.type) {
+            case 'space': return [''];
+            case 'def': return [];
+            case 'heading': return wrap(style(inline(token.tokens), 1, 22), width);
+            case 'paragraph':
+            case 'text': return wrap(token.tokens ? inline(token.tokens) : plain(token.text), width);
+            case 'hr': return ['─'.repeat(width)];
+            case 'table': return table(token, width);
+            case 'blockquote': return blocks(token.tokens, Math.max(1, width - 2)).map(line => width > 2 ? `│ ${line}` : line);
+            case 'list': return token.items.flatMap((item, index) => {
+                const marker = item.task ? item.checked ? '[x] ' : '[ ] ' : token.ordered ? `${Number(token.start) + index}. ` : '• ';
+                const prefix = width > marker.length + 1 ? marker : '';
+                return blocks(item.tokens.filter(child => child.type !== 'checkbox'), Math.max(1, width - prefix.length))
+                    .map((line, row) => `${row === 0 ? prefix : ' '.repeat(prefix.length)}${line}`);
+            });
+            case 'code': {
+                const language = plain(token.lang ?? '').split(/\s/)[0];
+                // An open fence is source, even when its current contents form a parseable partial diagram.
+                const closed = /(?:^|\n) {0,3}(`{3,}|~{3,})[ \t]*(?:\n)?$/.test(token.raw);
+                const graph = language === 'mermaid' && closed ? diagram(token.text, width) : undefined;
+                if (graph)
+                    return graph;
+                if (['math', 'latex', 'tex', 'mathjax'].includes(language) && closed) {
+                    return wrap(mathText({ type: 'math', text: token.text, raw: token.text, display: true }), width, false);
+                }
+                return [...wrap(`┌ ${language || 'code'}`, width, false), ...wrap(plain(token.text), width, false), '└'];
+            }
+            case 'math': return wrap(mathText(token), width, false);
+            default: return wrap(plain(token.raw), width);
+        }
+    });
+}
+// Decode only locally generated style codes after wrap-ansi has balanced styles across line breaks.
+function row(text) {
+    const spans = [];
+    let current = {};
+    let start = 0;
+    const properties = { 1: 'bold', 3: 'italic', 4: 'underline', 7: 'inverse', 9: 'strikethrough',
+        22: 'bold', 23: 'italic', 24: 'underline', 27: 'inverse', 29: 'strikethrough' };
+    for (const match of text.matchAll(/\x1b\[(\d+)m/g)) {
+        if (match.index > start)
+            spans.push({ text: text.slice(start, match.index), ...current });
+        const code = Number(match[1]);
+        if (code === 0)
+            current = {};
+        else if (code in properties)
+            current[properties[code]] = code < 20;
+        start = match.index + match[0].length;
+    }
+    if (start < text.length)
+        spans.push({ text: text.slice(start), ...current });
+    return { text: spans.map(span => span.text).join(''), ...(text.includes('\x1b') ? { spans } : {}) };
+}
+/** Whether a source can contain Markdown constructs; false preserves incremental plain-text wrapping.
+ * @param source - Complete text or a delta with its preceding line.
+ * @returns Whether Markdown lexing is required.
+ */
+export function hasMarkdown(source) {
+    return /[*_`~\[\]<>|$\\#&\t]|(?:^|\n)(?: {4}| {0,3}(?:[-+=]{1,}|\d+[.)])(?:\s|$))|\n\s*\n/.test(source);
+}
+/** Parse GFM and TeX into styled rows whose widths match the terminal viewport.
+ * @param source - Model or user message; remote terminal controls are removed.
+ * @param width - Available terminal columns.
+ * @returns Terminal rows, with literal source for invalid or unsupported rich blocks.
+ */
+export function markdownRows(source, width) {
+    width = Math.max(1, width);
+    if (!hasMarkdown(source))
+        return wrap(plain(source), width).map(row);
+    return blocks(parser.lexer(plain(source)), width).map(row);
+}
+function escapeHtml(text) {
+    return text.replace(/&/g, '&amp;').replace(/</g, '&lt;').replace(/>/g, '&gt;').replace(/"/g, '&quot;').replace(/'/g, '&#39;');
+}
+function safeLink(href) {
+    return /^(?:https?:|mailto:)/i.test(href) && !/[\u0000-\u0020]/.test(href) ? escapeHtml(href) : undefined;
+}
+parser.use({ renderer: {
+        html: token => escapeHtml(token.text),
+        link(token) {
+            const label = this.parser.parseInline(token.tokens);
+            const href = safeLink(token.href);
+            return href ? `<a href="${href}" rel="noreferrer">${label}</a>` : `${label} (${escapeHtml(token.href)})`;
+        },
+        image: token => `${escapeHtml(token.text)} (${escapeHtml(token.href)})`,
+        code(token) {
+            const language = (token.lang ?? '').split(/\s/)[0];
+            if (language === 'mermaid' && token.text.length <= 16 * 1024) {
+                try {
+                    const svg = renderMermaidSVG(token.text);
+                    // SVG image documents cannot run script or load external resources in the exported page.
+                    return `<img alt="Mermaid diagram" src="data:image/svg+xml;base64,${Buffer.from(svg).toString('base64')}">`;
+                }
+                catch { /* Unsupported Mermaid syntax remains readable in a code block. */ }
+            }
+            if (['math', 'latex', 'tex', 'mathjax'].includes(language ?? ''))
+                return mathHtml({ type: 'math', text: token.text, raw: token.text, display: true });
+            return `<pre><code>${escapeHtml(token.text)}</code></pre>`;
+        },
+    } });
+/** Render safe, offline HTML with Mermaid SVG images and MathJax-generated MathML.
+ * @param source - Markdown source, never trusted as executable HTML.
+ * @returns An HTML fragment that requires no scripts or remote assets.
+ */
+export function markdownHtml(source) { return parser.parse(safeText(source), { async: false }); }

package/dist/session/math.d.ts

@@ -0,0 +1,11 @@
+import '@mathjax/src/js/input/tex/base/BaseConfiguration.js';
+import '@mathjax/src/js/input/tex/ams/AmsConfiguration.js';
+/** Convert one TeX expression, without extension autoloads, network access or shared macro state.
+ * @param source - TeX without delimiters.
+ * @param display - Block rather than inline mathematics.
+ * @returns Unicode approximation and MathJax-generated MathML, or undefined for invalid TeX.
+ */
+export declare function renderMath(source: string, display: boolean): {
+    text: string;
+    html: string;
+} | undefined;