@deepseek-harness-tui/dsh-tui 0.11.0 → 0.11.2

package/lib/types/terminal-utils/markdown.d.ts

@@ -24,7 +24,9 @@ export declare function stripPromptXMLTags(content: string): string;
  * Configure the shared `marked` instance once. Strikethrough parsing is
  * disabled so that `~100` renders literally instead of as deleted text —
  * models use `~` far more often for "approximate" than for real
- * strikethrough.
+ * strikethrough. LaTeX math becomes `math`/`mathBlock` tokens (see
+ * math.ts). Every lexer caller — Markdown and StreamingMarkdown's boundary
+ * lex — must run this first so both agree on block boundaries.
  */
 export declare function configureMarked(): void;
 /**

package/lib/types/terminal-utils/markdown.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"markdown.d.ts","sourceRoot":"","sources":["../../../src/terminal-utils/markdown.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;GAYG;AAGH,OAAO,EAA4B,KAAK,KAAK,EAAe,MAAM,QAAQ,CAAA;AAO1E,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,mBAAmB,CAAA;AA6BrD;;;;;GAKG;AACH,wBAAgB,kBAAkB,CAAC,OAAO,EAAE,MAAM,GAAG,MAAM,CAO1D;AAID;;;;;GAKG;AACH,wBAAgB,eAAe,IAAI,IAAI,CAWtC;AA0ED;;;;;;;;GAQG;AACH,wBAAgB,WAAW,CACzB,KAAK,EAAE,KAAK,EACZ,SAAS,SAAI,EACb,iBAAiB,GAAE,MAAM,GAAG,IAAW,EACvC,MAAM,GAAE,KAAK,GAAG,IAAW,EAC3B,SAAS,GAAE,YAAY,GAAG,IAAW,GACpC,MAAM,CAER;AAED;;;;;GAKG;AACH,wBAAgB,aAAa,CAC3B,OAAO,EAAE,MAAM,EACf,SAAS,GAAE,YAAY,GAAG,IAAW,GACpC,MAAM,CAgBR;AA2SD;;;;;;;;;GASG;AACH,wBAAgB,UAAU,CACxB,OAAO,EAAE,MAAM,EACf,YAAY,EAAE,MAAM,EACpB,WAAW,EAAE,MAAM,EACnB,KAAK,EAAE,MAAM,GAAG,QAAQ,GAAG,OAAO,GAAG,IAAI,GAAG,SAAS,GACpD,MAAM,CAUR"}
+{"version":3,"file":"markdown.d.ts","sourceRoot":"","sources":["../../../src/terminal-utils/markdown.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;GAYG;AAGH,OAAO,EAA4B,KAAK,KAAK,EAAe,MAAM,QAAQ,CAAA;AAO1E,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,mBAAmB,CAAA;AAqCrD;;;;;GAKG;AACH,wBAAgB,kBAAkB,CAAC,OAAO,EAAE,MAAM,GAAG,MAAM,CAO1D;AAID;;;;;;;GAOG;AACH,wBAAgB,eAAe,IAAI,IAAI,CAYtC;AA0ED;;;;;;;;GAQG;AACH,wBAAgB,WAAW,CACzB,KAAK,EAAE,KAAK,EACZ,SAAS,SAAI,EACb,iBAAiB,GAAE,MAAM,GAAG,IAAW,EACvC,MAAM,GAAE,KAAK,GAAG,IAAW,EAC3B,SAAS,GAAE,YAAY,GAAG,IAAW,GACpC,MAAM,CAER;AAED;;;;;GAKG;AACH,wBAAgB,aAAa,CAC3B,OAAO,EAAE,MAAM,EACf,SAAS,GAAE,YAAY,GAAG,IAAW,GACpC,MAAM,CAgBR;AA+TD;;;;;;;;;GASG;AACH,wBAAgB,UAAU,CACxB,OAAO,EAAE,MAAM,EACf,YAAY,EAAE,MAAM,EACpB,WAAW,EAAE,MAAM,EACnB,KAAK,EAAE,MAAM,GAAG,QAAQ,GAAG,OAAO,GAAG,IAAI,GAAG,SAAS,GACpD,MAAM,CAUR"}

package/lib/types/terminal-utils/markdown.js

@@ -22,6 +22,8 @@ import { buildSyntaxTheme } from './syntaxTheme.js';
 import { logForDebugging } from '../utils/debug.js';
 import { createHyperlink } from './hyperlink.js';
 import { fileLinkUrl, linkifyFilePaths, looksLikeFilePath } from '../utils/fileTarget.js';
+import { getMathRendering } from '../tuiDisplayPrefs.js';
+import { isMathBlockToken, isMathToken, MATH_MARKDOWN_EXTENSIONS, renderInlineMath, } from './math.js';
 // '\n' is used unconditionally — os.EOL is '\r\n' on Windows, and the stray
 // '\r' breaks the character-to-segment mapping in applyStylesToWrappedText,
 // shifting styled text to the right.
@@ -60,7 +62,9 @@ let markedInitialized = false;
  * Configure the shared `marked` instance once. Strikethrough parsing is
  * disabled so that `~100` renders literally instead of as deleted text —
  * models use `~` far more often for "approximate" than for real
- * strikethrough.
+ * strikethrough. LaTeX math becomes `math`/`mathBlock` tokens (see
+ * math.ts). Every lexer caller — Markdown and StreamingMarkdown's boundary
+ * lex — must run this first so both agree on block boundaries.
  */
 export function configureMarked() {
     if (markedInitialized)
@@ -72,6 +76,7 @@ export function configureMarked() {
                 return undefined;
             },
         },
+        extensions: [...MATH_MARKDOWN_EXTENSIONS],
     });
 }
 /** Inline code is painted with the active theme's permission accent. */
@@ -201,6 +206,12 @@ function dispatch(token, state) {
         return renderTable(token, state);
     if (isToken(token, 'escape'))
         return token.text;
+    if (isMathToken(token))
+        return renderInlineMathToken(token);
+    // Top-level math blocks are standalone MathBlock nodes; this path only
+    // sees blocks nested in list items / blockquotes (or formatToken callers).
+    if (isMathBlockToken(token))
+        return renderNestedMathBlock(token);
     if (isToken(token, 'def') || isToken(token, 'del') || isToken(token, 'html')) {
         // Link definitions, strikethrough, and raw HTML carry no ANSI
         // representation.
@@ -209,6 +220,20 @@ function dispatch(token, state) {
     // Unknown / extension token types render as nothing.
     return '';
 }
+/** Inline math as single-line Unicode; the exact source when it has none
+ *  or rendering is switched off. */
+function renderInlineMathToken(token) {
+    return (getMathRendering() !== 'source' ? renderInlineMath(token.text) : undefined) ?? token.raw;
+}
+/**
+ * A math block inside a list item or blockquote has no width of its own to
+ * lay out a 2D formula against (and would be cut by the container prefix),
+ * so it gets the single-line form, else its source.
+ */
+function renderNestedMathBlock(token) {
+    const rendered = getMathRendering() !== 'source' && !token.pending ? renderInlineMath(token.text) : undefined;
+    return (rendered ?? token.raw.trim()) + EOL;
+}
 function renderBlockquote(token, state) {
     const inner = token.tokens.map(child => dispatch(child, fresh(state))).join('');
     // Dim gutter bar per line; keep the text italic but at normal brightness —

package/lib/types/terminal-utils/math.d.ts

@@ -0,0 +1,66 @@
+/**
+ * LaTeX math in replies: delimiter recognition for the shared `marked`
+ * instance and the render policy around the vendored Unicode renderer
+ * (./latex.ts).
+ *
+ * Math is recognized at lex time as its own token, before marked's escape
+ * handling can eat `\{`, `\,` or `\\` and before `*`/`_` inside a formula
+ * turn into emphasis. That keeps the exact source available for every
+ * fallback: a formula that is unsupported, too long, too wide, still
+ * streaming, or switched off in settings shows its original text, never a
+ * half-rendered or backslash-stripped one.
+ *
+ * Lexing does not depend on the settings switch — tokens are cached by
+ * content, so only rendering reads it.
+ *
+ * Delimiters: `$…$`, `\(…\)` inline; `$$…$$`, `\[…\]` as a block when the
+ * opener starts a line and the closer ends one, inline otherwise; a line
+ * opening a display environment (`\begin{align}` …) is a block too. The `$`
+ * rules follow Pi's markdown tokenizer and Codex's TUI math scanner so that
+ * prices, shell variables and PIDs stay prose.
+ */
+import type { TokenizerExtension, Tokens } from 'marked';
+/** Which delimiter introduced a formula. */
+export type MathDelimiter = 'dollar' | 'double-dollar' | 'paren' | 'bracket' | 'environment';
+/** A recognized formula. `text` is the TeX between the delimiters (for an
+ *  environment, the whole `\begin…\end`), `raw` the full source span. */
+export interface MathToken extends Tokens.Generic {
+    type: 'math' | 'mathBlock';
+    raw: string;
+    text: string;
+    /** TeX display style (`$$`, `\[…\]`, environments) — how it typesets. */
+    display: boolean;
+    /** Owns its Markdown lines (a `mathBlock`) — how it lays out. `foo $$x$$
+     *  bar` is display but not standalone. */
+    standalone: boolean;
+    delimiter: MathDelimiter;
+    /** Block only: the closer has not arrived yet (streaming, or an unclosed
+     *  block at the end of a reply). Always shown as source. */
+    pending?: boolean;
+}
+/**
+ * Single-line Unicode for a formula, or undefined when it has none. Inline
+ * math sits inside wrapped prose, so a multi-line result (cases, matrices,
+ * aligned rows) would be torn apart by wrapping — those keep their source.
+ */
+export declare function renderInlineMath(text: string): string | undefined;
+/** Display-mode layout (stacked fractions, operator limits) as lines. */
+export declare function renderDisplayMath(text: string): string[] | undefined;
+export declare function isMathToken(token: {
+    type: string;
+}): token is MathToken;
+export declare function isMathBlockToken(token: {
+    type: string;
+}): token is MathToken;
+/**
+ * Whether a block formula lexed right after `paragraph` is still provisional
+ * in a streaming reply: the paragraph leaves a backtick run open, and no
+ * blank line in `following` (the source after the paragraph) has ended it
+ * yet, so a closer may still arrive and turn the paragraph, the formula and
+ * the text up to the closer into one code span. A streaming renderer must
+ * not seal the paragraph until this is false.
+ */
+export declare function mayBecomeCodeSpan(paragraph: string, following: string): boolean;
+/** Tokenizer extensions for `marked.use({ extensions })`. */
+export declare const MATH_MARKDOWN_EXTENSIONS: readonly TokenizerExtension[];
+//# sourceMappingURL=math.d.ts.map

package/lib/types/terminal-utils/math.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"math.d.ts","sourceRoot":"","sources":["../../../src/terminal-utils/math.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;GAoBG;AAEH,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,EAAE,MAAM,QAAQ,CAAA;AAGxD,4CAA4C;AAC5C,MAAM,MAAM,aAAa,GAAG,QAAQ,GAAG,eAAe,GAAG,OAAO,GAAG,SAAS,GAAG,aAAa,CAAA;AAE5F;yEACyE;AACzE,MAAM,WAAW,SAAU,SAAQ,MAAM,CAAC,OAAO;IAC/C,IAAI,EAAE,MAAM,GAAG,WAAW,CAAA;IAC1B,GAAG,EAAE,MAAM,CAAA;IACX,IAAI,EAAE,MAAM,CAAA;IACZ,yEAAyE;IACzE,OAAO,EAAE,OAAO,CAAA;IAChB;8CAC0C;IAC1C,UAAU,EAAE,OAAO,CAAA;IACnB,SAAS,EAAE,aAAa,CAAA;IACxB;gEAC4D;IAC5D,OAAO,CAAC,EAAE,OAAO,CAAA;CAClB;AAoBD;;;;GAIG;AACH,wBAAgB,gBAAgB,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM,GAAG,SAAS,CAGjE;AAED,yEAAyE;AACzE,wBAAgB,iBAAiB,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM,EAAE,GAAG,SAAS,CAEpE;AAED,wBAAgB,WAAW,CAAC,KAAK,EAAE;IAAE,IAAI,EAAE,MAAM,CAAA;CAAE,GAAG,KAAK,IAAI,SAAS,CAEvE;AAED,wBAAgB,gBAAgB,CAAC,KAAK,EAAE;IAAE,IAAI,EAAE,MAAM,CAAA;CAAE,GAAG,KAAK,IAAI,SAAS,CAE5E;AA6ND;;;;;;;GAOG;AACH,wBAAgB,iBAAiB,CAAC,SAAS,EAAE,MAAM,EAAE,SAAS,EAAE,MAAM,GAAG,OAAO,CAK/E;AAED,6DAA6D;AAC7D,eAAO,MAAM,wBAAwB,EAAE,SAAS,kBAAkB,EAiCjE,CAAA"}

package/lib/types/terminal-utils/math.js

@@ -0,0 +1,337 @@
+/**
+ * LaTeX math in replies: delimiter recognition for the shared `marked`
+ * instance and the render policy around the vendored Unicode renderer
+ * (./latex.ts).
+ *
+ * Math is recognized at lex time as its own token, before marked's escape
+ * handling can eat `\{`, `\,` or `\\` and before `*`/`_` inside a formula
+ * turn into emphasis. That keeps the exact source available for every
+ * fallback: a formula that is unsupported, too long, too wide, still
+ * streaming, or switched off in settings shows its original text, never a
+ * half-rendered or backslash-stripped one.
+ *
+ * Lexing does not depend on the settings switch — tokens are cached by
+ * content, so only rendering reads it.
+ *
+ * Delimiters: `$…$`, `\(…\)` inline; `$$…$$`, `\[…\]` as a block when the
+ * opener starts a line and the closer ends one, inline otherwise; a line
+ * opening a display environment (`\begin{align}` …) is a block too. The `$`
+ * rules follow Pi's markdown tokenizer and Codex's TUI math scanner so that
+ * prices, shell variables and PIDs stay prose.
+ */
+import { renderLatex } from './latex.js';
+/**
+ * Formulas longer than this keep their source. Real equations are far
+ * shorter; anything this long is a paste, and the parser walks it
+ * recursively. Same order as Codex's 4096-byte budget.
+ */
+const MATH_SOURCE_LIMIT = 4096;
+/** Render TeX through the vendored parser; any failure means "keep the source". */
+function renderTex(text, display) {
+    if (text.length > MATH_SOURCE_LIMIT)
+        return undefined;
+    try {
+        const rendered = renderLatex(text, { display });
+        return rendered === undefined || rendered.trim() === '' ? undefined : rendered;
+    }
+    catch {
+        return undefined;
+    }
+}
+/**
+ * Single-line Unicode for a formula, or undefined when it has none. Inline
+ * math sits inside wrapped prose, so a multi-line result (cases, matrices,
+ * aligned rows) would be torn apart by wrapping — those keep their source.
+ */
+export function renderInlineMath(text) {
+    const rendered = renderTex(text, false);
+    return rendered === undefined || rendered.includes('\n') ? undefined : rendered;
+}
+/** Display-mode layout (stacked fractions, operator limits) as lines. */
+export function renderDisplayMath(text) {
+    return renderTex(text, true)?.split('\n');
+}
+export function isMathToken(token) {
+    return token.type === 'math';
+}
+export function isMathBlockToken(token) {
+    return token.type === 'mathBlock';
+}
+function isEscaped(source, index) {
+    let backslashes = 0;
+    for (let position = index - 1; position >= 0 && source[position] === '\\'; position--) {
+        backslashes++;
+    }
+    return backslashes % 2 === 1;
+}
+function findClosingDelimiter(source, closing, start) {
+    let index = source.indexOf(closing, start);
+    while (index >= 0 && isEscaped(source, index)) {
+        // A literal \$ can sit directly before $$, so candidate pairs may overlap.
+        index = source.indexOf(closing, index + 1);
+    }
+    return index;
+}
+/** TeX commands or operators: what an unclosed `$$` block needs to hold
+ *  before it is treated as a formula in progress rather than prose. */
+function looksLikeMath(source) {
+    return /\\[A-Za-z]+|[_^=+*/<>()[\]|±≤≥≠≈∈→⇒∞∫∑√-]/.test(source);
+}
+/**
+ * Reasons a `$`/`$$` pair is prose, not math:
+ * - body starts or ends with whitespace (`$5 and $10`, `echo $$ … $$`);
+ * - `${…}` shell expansion;
+ * - closer glued to an ASCII letter or digit (`$x$y`, `$1$2`) — CJK text may
+ *   touch the closer, since Chinese prose does not space around math;
+ * - a backtick inside (the pair straddles a code span);
+ * - a bare number or an all-caps word (`$5,$`, `$HOME$`);
+ * - an env-var-like body followed by another identifier (`$HOME/$USER`).
+ */
+function isDollarProse(body, after) {
+    if (/^\s|\s$/.test(body) || body.startsWith('{'))
+        return true;
+    if (/^[A-Za-z0-9]/.test(after))
+        return true;
+    if (body.includes('`'))
+        return true;
+    if (/^\d/.test(body) && !/[\\^_=+\-*/<>]/.test(body))
+        return true;
+    if (body.length > 1 && /^[A-Z]+$/.test(body))
+        return true;
+    return /^[A-Z_][A-Z0-9_]*[^A-Za-z0-9_\s]?$/.test(body) && /^[A-Za-z_]/.test(after);
+}
+const INLINE_DELIMITERS = [
+    ['$$', '$$', 'double-dollar'],
+    ['\\(', '\\)', 'paren'],
+    ['\\[', '\\]', 'bracket'],
+    ['$', '$', 'dollar'],
+];
+/**
+ * Inline math. Unlike Pi, an unclosed inline opener is NOT held as pending:
+ * doing so swallows the rest of the paragraph as source, and in a finished
+ * reply (`costs $5 + tax, **note**`) that silently drops real formatting.
+ * The only cost is that a formula's interior may briefly show as markdown
+ * while its closing `$` streams in.
+ */
+function tokenizeInlineMath(source) {
+    const delimiter = INLINE_DELIMITERS.find(([opening]) => source.startsWith(opening));
+    if (delimiter === undefined)
+        return undefined;
+    const [opening, closing, kind] = delimiter;
+    const closingIndex = findClosingDelimiter(source, closing, opening.length);
+    if (closingIndex < 0)
+        return undefined;
+    const text = source.slice(opening.length, closingIndex);
+    if (text.trim() === '' || text.includes('\n'))
+        return undefined;
+    if (opening.startsWith('$') && isDollarProse(text, source.slice(closingIndex + closing.length))) {
+        return undefined;
+    }
+    return {
+        type: 'math',
+        raw: source.slice(0, closingIndex + closing.length),
+        text,
+        display: kind === 'double-dollar' || kind === 'bracket',
+        standalone: false,
+        delimiter: kind,
+    };
+}
+/**
+ * Block math: the opener starts a line (up to three spaces of indent, like
+ * any CommonMark block) and the closer ends one. An opener whose closer
+ * appears later on a line with trailing text is left to the inline rule; a
+ * block is pending only while no closer exists at all.
+ */
+const BLOCK_OPENER = /^ {0,3}(\$\$|\\\[)/;
+/**
+ * Display environments models write without `$$` around them. Their bodies
+ * carry `\\` row breaks and `&` alignment that Markdown would otherwise
+ * mangle into prose, so a line opening one starts a block like `$$` does.
+ */
+const ENVIRONMENT_OPENER = /^ {0,3}\\begin\{((?:equation|align|alignat|gather|multline|flalign|eqnarray|displaymath|aligned|gathered)\*?)\}/;
+function tokenizeEnvironmentBlock(source, opener) {
+    const name = opener[1];
+    const begin = `\\begin{${name}}`;
+    const end = `\\end{${name}}`;
+    let depth = 0;
+    let index = opener[0].length - begin.length;
+    while (index < source.length) {
+        const nextBegin = source.indexOf(begin, index);
+        const nextEnd = source.indexOf(end, index);
+        if (nextEnd < 0)
+            break;
+        if (nextBegin >= 0 && nextBegin < nextEnd) {
+            depth += 1;
+            index = nextBegin + begin.length;
+            continue;
+        }
+        depth -= 1;
+        index = nextEnd + end.length;
+        if (depth > 0)
+            continue;
+        const trailing = /^[ \t]*(?:\n|$)/.exec(source.slice(index));
+        // Prose after the closing \end on the same line: not a block of its own.
+        if (trailing === null)
+            return undefined;
+        const raw = source.slice(0, index + trailing[0].length);
+        return { type: 'mathBlock', raw, text: raw.trim(), display: true, standalone: true, delimiter: 'environment' };
+    }
+    // No closing \end yet: a formula in progress (or never closed) stays source.
+    return { type: 'mathBlock', raw: source, text: source.trim(), display: true, standalone: true, delimiter: 'environment', pending: true };
+}
+/**
+ * The source the block tokenizer last saw. marked tries block extensions at
+ * each block position before cutting a paragraph, then calls `start` with
+ * that same source minus its first character; `start` needs the whole
+ * paragraph (its first character may open a code span).
+ */
+let lastBlockSource = '';
+function tokenizeBlockMath(source) {
+    lastBlockSource = source;
+    const environment = ENVIRONMENT_OPENER.exec(source);
+    if (environment !== null)
+        return tokenizeEnvironmentBlock(source, environment);
+    const opener = BLOCK_OPENER.exec(source);
+    if (opener === null)
+        return undefined;
+    const dollar = opener[1] === '$$';
+    const closing = dollar ? '$$' : '\\]';
+    const closingIndex = findClosingDelimiter(source, closing, opener[0].length);
+    if (closingIndex >= 0) {
+        const end = closingIndex + closing.length;
+        const trailing = /^[ \t]*(?:\n|$)/.exec(source.slice(end));
+        const text = source.slice(opener[0].length, closingIndex).trim();
+        // The first closer decides the boundary. Looking for a later line-ending
+        // closer would swallow intervening prose and the next formula.
+        if (trailing === null || text === '')
+            return undefined;
+        return {
+            type: 'mathBlock',
+            raw: source.slice(0, end + trailing[0].length),
+            text,
+            display: true,
+            standalone: true,
+            delimiter: dollar ? 'double-dollar' : 'bracket',
+        };
+    }
+    const body = source.slice(opener[0].length).replace(/^[ \t]*\n?/, '');
+    // An opener with nothing after it yet is held too, so a streaming block
+    // does not flip from prose to a block node when its first command arrives.
+    if (dollar && body.trim() !== '' && !looksLikeMath(body))
+        return undefined;
+    return {
+        type: 'mathBlock',
+        raw: source,
+        text: body,
+        display: true,
+        standalone: true,
+        delimiter: dollar ? 'double-dollar' : 'bracket',
+        pending: true,
+    };
+}
+/**
+ * Backtick runs that can act as CommonMark code-span delimiters, in order.
+ * A run preceded by an odd number of backslashes is escaped and stays literal
+ * text, so it neither opens nor closes a span.
+ */
+function backtickRuns(text) {
+    const runs = [];
+    for (const match of text.matchAll(/`+/g)) {
+        const start = match.index;
+        let backslashes = 0;
+        while (start - backslashes - 1 >= 0 && text[start - backslashes - 1] === '\\')
+            backslashes++;
+        if (backslashes % 2 === 0)
+            runs.push(match[0]);
+    }
+    return runs;
+}
+/**
+ * Lengths of the backtick runs in `text` that no later run of the same
+ * length closes (CommonMark: such a run is literal text, for now).
+ */
+function unmatchedBacktickRuns(text) {
+    const runs = backtickRuns(text);
+    const unmatched = [];
+    for (let open = 0; open < runs.length; open++) {
+        let close = open + 1;
+        while (close < runs.length && runs[close].length !== runs[open].length)
+            close++;
+        if (close < runs.length)
+            open = close;
+        else
+            unmatched.push(runs[open].length);
+    }
+    return unmatched;
+}
+/**
+ * Whether position `at` of `text` (a candidate block opener) lies inside a
+ * code span: a backtick run opens a span only when a run of exactly the same
+ * length closes it later in the same paragraph (CommonMark); a run with no
+ * closer is literal text and opens nothing.
+ */
+function insideOpenCodeSpan(text, at) {
+    const paragraphStart = text.lastIndexOf('\n\n', at);
+    const before = text.slice(paragraphStart < 0 ? 0 : paragraphStart + 2, at);
+    const open = unmatchedBacktickRuns(before);
+    if (open.length === 0)
+        return false;
+    const rest = text.slice(at);
+    const paragraphEnd = rest.search(/\n[ \t]*\n/);
+    const after = paragraphEnd < 0 ? rest : rest.slice(0, paragraphEnd);
+    const closers = new Set(backtickRuns(after).map(run => run.length));
+    return open.some(length => closers.has(length));
+}
+/**
+ * Whether a block formula lexed right after `paragraph` is still provisional
+ * in a streaming reply: the paragraph leaves a backtick run open, and no
+ * blank line in `following` (the source after the paragraph) has ended it
+ * yet, so a closer may still arrive and turn the paragraph, the formula and
+ * the text up to the closer into one code span. A streaming renderer must
+ * not seal the paragraph until this is false.
+ */
+export function mayBecomeCodeSpan(paragraph, following) {
+    if (/\n[ \t]*\n\s*$/.test(paragraph))
+        return false;
+    const paragraphStart = paragraph.lastIndexOf('\n\n');
+    if (unmatchedBacktickRuns(paragraphStart < 0 ? paragraph : paragraph.slice(paragraphStart + 2)).length === 0)
+        return false;
+    return !/\n[ \t]*\n/.test(following);
+}
+/** Tokenizer extensions for `marked.use({ extensions })`. */
+export const MATH_MARKDOWN_EXTENSIONS = [
+    {
+        name: 'mathBlock',
+        level: 'block',
+        start(source) {
+            // Same block position: exactly one character longer (a full string
+            // comparison here would cost O(remaining text) per paragraph).
+            const paragraph = lastBlockSource.length === source.length + 1 ? lastBlockSource : source;
+            const offset = paragraph.length - source.length;
+            const opener = /(?:^|\n) {0,3}(?:\$\$|\\\[|\\begin\{)/g;
+            for (let match = opener.exec(source); match !== null; match = opener.exec(source)) {
+                const index = match.index + (match[0].startsWith('\n') ? 1 : 0);
+                // A code span may run across lines; a block opener inside one is
+                // code, and cutting the paragraph there would split the span.
+                if (!insideOpenCodeSpan(paragraph, index + offset))
+                    return index;
+            }
+            return undefined;
+        },
+        tokenizer: tokenizeBlockMath,
+    },
+    {
+        name: 'math',
+        level: 'inline',
+        start(source) {
+            let first = -1;
+            for (const marker of ['$', '\\(', '\\[']) {
+                const index = source.indexOf(marker);
+                if (index >= 0 && (first < 0 || index < first))
+                    first = index;
+            }
+            return first >= 0 ? first : undefined;
+        },
+        tokenizer: tokenizeInlineMath,
+    },
+];

package/lib/types/tips.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"tips.d.ts","sourceRoot":"","sources":["../../src/tips.ts"],"names":[],"mappings":"AAAA;;;;;;;;;GASG;AAEH,MAAM,MAAM,QAAQ,GAAG,MAAM,GAAG,UAAU,GAAG,UAAU,GAAG,SAAS,GAAG,UAAU,CAAA;AAEhF,MAAM,WAAW,GAAG;IAClB,EAAE,EAAE,MAAM,CAAA;IACV,KAAK,EAAE,QAAQ,CAAA;IACf,EAAE,EAAE,MAAM,CAAA;IACV,EAAE,EAAE,MAAM,CAAA;CACX;AAED,eAAO,MAAM,gBAAgB,EAAE,MAAM,CAAC,QAAQ,EAAE;IAAE,EAAE,EAAE,MAAM,CAAC;IAAC,EAAE,EAAE,MAAM,CAAA;CAAE,CAMzE,CAAA;AAED,eAAO,MAAM,IAAI,EAAE,SAAS,GAAG,EA02B9B,CAAA;AAED;;;GAGG;AACH,wBAAgB,aAAa,CAAC,MAAM,GAAE,MAAM,MAAoB,GAAG,GAAG,CAErE;AAED,0CAA0C;AAC1C,wBAAgB,WAAW,CAAC,KAAK,EAAE,QAAQ,GAAG,GAAG,EAAE,CAElD"}
+{"version":3,"file":"tips.d.ts","sourceRoot":"","sources":["../../src/tips.ts"],"names":[],"mappings":"AAAA;;;;;;;;;GASG;AAEH,MAAM,MAAM,QAAQ,GAAG,MAAM,GAAG,UAAU,GAAG,UAAU,GAAG,SAAS,GAAG,UAAU,CAAA;AAEhF,MAAM,WAAW,GAAG;IAClB,EAAE,EAAE,MAAM,CAAA;IACV,KAAK,EAAE,QAAQ,CAAA;IACf,EAAE,EAAE,MAAM,CAAA;IACV,EAAE,EAAE,MAAM,CAAA;CACX;AAED,eAAO,MAAM,gBAAgB,EAAE,MAAM,CAAC,QAAQ,EAAE;IAAE,EAAE,EAAE,MAAM,CAAC;IAAC,EAAE,EAAE,MAAM,CAAA;CAAE,CAMzE,CAAA;AAED,eAAO,MAAM,IAAI,EAAE,SAAS,GAAG,EAg3B9B,CAAA;AAED;;;GAGG;AACH,wBAAgB,aAAa,CAAC,MAAM,GAAE,MAAM,MAAoB,GAAG,GAAG,CAErE;AAED,0CAA0C;AAC1C,wBAAgB,WAAW,CAAC,KAAK,EAAE,QAAQ,GAAG,GAAG,EAAE,CAElD"}

package/lib/types/tips.js

@@ -535,6 +535,12 @@ export const TIPS = [
         zh: '问卷选项行直接打字 = 选项 + 自定义文本一起提交',
         en: 'Typing on a question row submits option + custom text',
     },
+    {
+        id: 'flow-question-arrows',
+        group: 'workflow',
+        zh: '多题问卷用 ←/→ 换题，不提交；输入行要先把光标移到行首或行尾',
+        en: 'In a multi-question ask, ←/→ switches questions without submitting; on the input row the caret must already be at the edge',
+    },
     {
         id: 'flow-question-fold',
         group: 'workflow',

package/lib/types/tuiDisplayPrefs.d.ts

@@ -46,4 +46,71 @@ export declare const applyPageMargin: (value: unknown) => PageMarginSetting;
 export declare const subscribeMermaidDiagrams: (listener: () => void) => () => void;
 export declare const getMermaidDiagrams: () => boolean;
 export declare const applyMermaidDiagrams: (value: unknown) => boolean;
+/**
+ * How LaTeX math in replies renders (settings `dsh-tui.mathRendering`):
+ * `auto` picks the best available backend (today the Unicode renderer),
+ * `image` typesets complete block formulas as terminal images where the
+ * terminal supports graphics (Unicode everywhere else; opt-in until it has
+ * been validated across terminals, after which `auto` adopts it),
+ * `unicode` pins the Unicode renderer, `source` always shows the TeX.
+ */
+export type MathRendering = 'auto' | 'image' | 'unicode' | 'source';
+export declare function normalizeMathRendering(value: unknown): MathRendering;
+/**
+ * Resolve the effective mode across the settings user layer and cordis.yml.
+ * `latexMath` predates `mathRendering` (unreleased main builds wrote it): at a
+ * layer without `mathRendering`, `false` means `source` and `true` means
+ * `auto`, and either one overrides the layers below.
+ */
+export declare function resolveMathRendering(user: {
+    mathRendering?: unknown;
+    latexMath?: unknown;
+}, config: {
+    mathRendering?: unknown;
+    latexMath?: unknown;
+}): MathRendering;
+export declare const subscribeMathRendering: (listener: () => void) => () => void;
+export declare const getMathRendering: () => MathRendering;
+export declare const applyMathRendering: (value: unknown) => MathRendering;
+/**
+ * How large a display formula is set when it renders as an image (settings
+ * `dsh-tui.mathImageScale`): `auto` matches the body text, `large` and
+ * `xlarge` set display math bigger. Size is the only sharpness lever a
+ * terminal image has — the raster is drawn one device pixel per pixel, so a
+ * larger formula is literally more pixels per stroke. Inline formulas keep the
+ * base scale: their single row of cells caps the resolution.
+ */
+export type MathImageScale = 'auto' | 'large' | 'xlarge';
+export declare function normalizeMathImageScale(value: unknown): MathImageScale;
+export declare const subscribeMathImageScale: (listener: () => void) => () => void;
+export declare const getMathImageScale: () => MathImageScale;
+export declare const applyMathImageScale: (value: unknown) => MathImageScale;
+/**
+ * What sits behind a formula image (settings `dsh-tui.mathImageBacking`):
+ * `transparent` paints only the formula's own pixels, so the terminal
+ * background (a wallpaper included) shows through; `terminal` composites it
+ * onto the terminal's background colour first, which is the calmer choice on
+ * busy backgrounds and the only one that keeps soft anti-aliased edges smooth
+ * (Sixel has no partial alpha).
+ */
+export type MathImageBacking = 'transparent' | 'terminal';
+export declare function normalizeMathImageBacking(value: unknown): MathImageBacking;
+export declare const subscribeMathImageBacking: (listener: () => void) => () => void;
+export declare const getMathImageBacking: () => MathImageBacking;
+export declare const applyMathImageBacking: (value: unknown) => MathImageBacking;
+/**
+ * What sits behind a transcript photo or illustration (settings
+ * `dsh-tui.imageBacking`): `transparent` paints only the raster's own
+ * pixels, so the terminal background (a wallpaper included) shows through
+ * at anti-aliased edges and transparent corners — Sixel's binary alpha
+ * drops their softest pixels, so edges trade a little smoothness for the
+ * float; `terminal` composites onto the terminal's background colour
+ * first (smooth edges on any background). Photographs are mostly opaque,
+ * so the visible difference lives at the edges.
+ */
+export type ImageBacking = 'transparent' | 'terminal';
+export declare function normalizeImageBacking(value: unknown): ImageBacking;
+export declare const subscribeImageBacking: (listener: () => void) => () => void;
+export declare const getImageBacking: () => ImageBacking;
+export declare const applyImageBacking: (value: unknown) => ImageBacking;
 //# sourceMappingURL=tuiDisplayPrefs.d.ts.map

package/lib/types/tuiDisplayPrefs.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"tuiDisplayPrefs.d.ts","sourceRoot":"","sources":["../../src/tuiDisplayPrefs.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,cAAc,EAAE,gBAAgB,EAAE,iBAAiB,EAAE,cAAc,EAAE,cAAc,EAAE,eAAe,EAAE,MAAM,oCAAoC,CAAA;AAC9J,YAAY,EAAE,cAAc,EAAE,gBAAgB,EAAE,iBAAiB,EAAE,cAAc,EAAE,cAAc,EAAE,eAAe,EAAE,MAAM,oCAAoC,CAAA;AAG9J,qEAAqE;AACrE,eAAO,MAAM,kBAAkB,EAAE,QAAQ,CAAC,eAAe,CAuBvD,CAAA;AAMF,0EAA0E;AAC1E,wBAAgB,uBAAuB,CAAC,KAAK,EAAE,OAAO,GAAG,cAAc,CAItE;AAED,4EAA4E;AAC5E,wBAAgB,qBAAqB,CAAC,KAAK,EAAE,OAAO,GAAG,gBAAgB,CAItE;AAED,0EAA0E;AAC1E,wBAAgB,kBAAkB,CAAC,KAAK,EAAE,OAAO,GAAG,eAAe,CASlE;AASD;;;GAGG;AACH,wBAAgB,kBAAkB,CAChC,IAAI,EAAE,MAAM,GAAG,SAAS,EACxB,aAAa,EAAE,MAAM,GAAG,SAAS,EACjC,OAAO,UAAO,GACb,MAAM,GAAG,SAAS,CASpB;AAED;;4CAE4C;AAC5C,eAAO,MAAM,mBAAmB,EAAE,QAAQ,CAAC,MAAM,CAAC,cAAc,EAAE;IAAE,QAAQ,CAAC,CAAC,EAAE,MAAM,CAAC;IAAC,QAAQ,CAAC,CAAC,EAAE,MAAM,CAAA;CAAE,CAAC,CAK3G,CAAA;AAEF,eAAO,MAAM,mBAAmB,EAAE,cAAyB,CAAA;AAE3D;4CAC4C;AAC5C,eAAO,MAAM,iBAAiB,IAAI,CAAA;AAClC,eAAO,MAAM,iBAAiB,IAAI,CAAA;AAQlC,wBAAgB,gBAAgB,CAAC,KAAK,EAAE,MAAM,GAAG,KAAK,IAAI,cAAc,CAEvE;AAED;wBACwB;AACxB,wBAAgB,mBAAmB,CAAC,IAAI,EAAE,MAAM,GAAG,cAAc,GAAG,SAAS,CAO5E;AAED;;kCAEkC;AAClC,wBAAgB,mBAAmB,CAAC,KAAK,EAAE,OAAO,GAAG,iBAAiB,CAOrE;AAED;2EAC2E;AAC3E,wBAAgB,iBAAiB,CAAC,OAAO,EAAE,iBAAiB,GAAG;IAAE,QAAQ,CAAC,CAAC,EAAE,MAAM,CAAC;IAAC,QAAQ,CAAC,CAAC,EAAE,MAAM,CAAA;CAAE,CAWxG;AAyCD,eAAO,MAAM,mBAAmB,aA5BR,MAAM,IAAI,KAAK,MAAM,IA4Be,CAAA;AAC5D,eAAO,MAAM,oBAAoB,yBAAsB,CAAA;AACvD,wFAAwF;AACxF,eAAO,MAAM,eAAe,UA3BX,OAAO,sBA2B4B,CAAA;AAMpD,eAAO,MAAM,wBAAwB,aArCb,MAAM,IAAI,KAAK,MAAM,IAqCyB,CAAA;AACtE,eAAO,MAAM,kBAAkB,eAA2B,CAAA;AAC1D,eAAO,MAAM,oBAAoB,UAnChB,OAAO,YAmCsC,CAAA"}
+{"version":3,"file":"tuiDisplayPrefs.d.ts","sourceRoot":"","sources":["../../src/tuiDisplayPrefs.ts"],"names":[],"mappings":"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"}

package/lib/types/tuiDisplayPrefs.js

@@ -166,3 +166,62 @@ const mermaidDiagramsStore = createLiveSetting(true, value => value !== false);
 export const subscribeMermaidDiagrams = mermaidDiagramsStore.subscribe;
 export const getMermaidDiagrams = mermaidDiagramsStore.get;
 export const applyMermaidDiagrams = mermaidDiagramsStore.apply;
+const MATH_RENDERING_MODES = new Set(['auto', 'image', 'unicode', 'source']);
+export function normalizeMathRendering(value) {
+    return typeof value === 'string' && MATH_RENDERING_MODES.has(value)
+        ? value
+        : 'auto';
+}
+/**
+ * Resolve the effective mode across the settings user layer and cordis.yml.
+ * `latexMath` predates `mathRendering` (unreleased main builds wrote it): at a
+ * layer without `mathRendering`, `false` means `source` and `true` means
+ * `auto`, and either one overrides the layers below.
+ */
+export function resolveMathRendering(user, config) {
+    for (const layer of [user, config]) {
+        if (layer.mathRendering !== undefined)
+            return normalizeMathRendering(layer.mathRendering);
+        // An explicit legacy switch overrides lower layers either way: a user who
+        // turned math back on over a cordis.yml `false` keeps it on.
+        if (typeof layer.latexMath === 'boolean')
+            return layer.latexMath ? 'auto' : 'source';
+    }
+    return 'auto';
+}
+/** Read at render time, so settled transcript blocks re-render on change. */
+const mathRenderingStore = createLiveSetting('auto', normalizeMathRendering);
+export const subscribeMathRendering = mathRenderingStore.subscribe;
+export const getMathRendering = mathRenderingStore.get;
+export const applyMathRendering = mathRenderingStore.apply;
+const MATH_IMAGE_SCALES = new Set(['auto', 'large', 'xlarge']);
+export function normalizeMathImageScale(value) {
+    return typeof value === 'string' && MATH_IMAGE_SCALES.has(value)
+        ? value
+        : 'auto';
+}
+/** Read at render time, so settled transcript blocks re-render on change. */
+const mathImageScaleStore = createLiveSetting('auto', normalizeMathImageScale);
+export const subscribeMathImageScale = mathImageScaleStore.subscribe;
+export const getMathImageScale = mathImageScaleStore.get;
+export const applyMathImageScale = mathImageScaleStore.apply;
+const MATH_IMAGE_BACKINGS = new Set(['transparent', 'terminal']);
+export function normalizeMathImageBacking(value) {
+    return typeof value === 'string' && MATH_IMAGE_BACKINGS.has(value)
+        ? value
+        : 'transparent';
+}
+const mathImageBackingStore = createLiveSetting('transparent', normalizeMathImageBacking);
+export const subscribeMathImageBacking = mathImageBackingStore.subscribe;
+export const getMathImageBacking = mathImageBackingStore.get;
+export const applyMathImageBacking = mathImageBackingStore.apply;
+const IMAGE_BACKINGS = new Set(['transparent', 'terminal']);
+export function normalizeImageBacking(value) {
+    return typeof value === 'string' && IMAGE_BACKINGS.has(value)
+        ? value
+        : 'transparent';
+}
+const imageBackingStore = createLiveSetting('transparent', normalizeImageBacking);
+export const subscribeImageBacking = imageBackingStore.subscribe;
+export const getImageBacking = imageBackingStore.get;
+export const applyImageBacking = imageBackingStore.apply;