herm-tui 1.0.0-dev.1

package/src/utils/math-unicode.ts

@@ -0,0 +1,818 @@
+// Best-effort LaTeX → Unicode for inline / display math captured by the
+// markdown renderer. The terminal can't typeset LaTeX, but Unicode covers
+// most of what models actually emit: Greek letters, blackboard / fraktur /
+// calligraphic capitals, set theory + logic operators, common arrows,
+// sub/superscripts, and `\frac{a}{b}` collapsed to `a/b`.
+//
+// Ported from hermes-agent ui-tui/src/lib/mathUnicode.ts (c3d39feb3 +
+// cb039ac00). Single divergence: `\boxed` / `\fbox` emit markdown-level
+// `**X**` instead of U+0001 / U+0002 sentinels, because herm feeds this
+// output directly to OpenTUI's <markdown> component which has no
+// sentinel-split hook. Upstream's React renderer uses the sentinels to
+// apply inverse+bold; we trade that visual for plain bold and keep the
+// pipeline single-pass.
+//
+// Design rules:
+//   • Pure regex pipeline. Anything we don't recognise is preserved
+//     verbatim (so a `\foo{bar}` we've never heard of still survives).
+//     A real LaTeX parser would be more correct but throws on partial
+//     input — terminal users would rather see the raw command than a
+//     parse-error placeholder.
+//   • Longest-match-first ordering on commands so `\le` doesn't shadow
+//     `\leq`, `\sub` doesn't shadow `\subseteq`, etc.
+//   • Word-boundary lookahead `(?![A-Za-z])` after each command so
+//     `\pix` (made-up command) doesn't get partially substituted as `π`.
+//   • `\mathbb{X}`, `\mathcal{X}`, `\mathfrak{X}` only handle a single
+//     letter argument — multi-letter `\mathbb{NN}` is rare and would
+//     need a real parser to do correctly.
+//   • Sub/super scripts only convert if EVERY character has a Unicode
+//     equivalent. Mixed content like `^{n+1}` falls back to the raw
+//     LaTeX so we don't emit `ⁿ+¹` (which has no `+` superscript glyph
+//     in some fonts and reads worse than the source).
+
+const SYMBOLS: Record<string, string> = {
+  // Greek lowercase
+  '\\alpha': 'α',
+  '\\beta': 'β',
+  '\\gamma': 'γ',
+  '\\delta': 'δ',
+  '\\epsilon': 'ε',
+  '\\varepsilon': 'ε',
+  '\\zeta': 'ζ',
+  '\\eta': 'η',
+  '\\theta': 'θ',
+  '\\vartheta': 'ϑ',
+  '\\iota': 'ι',
+  '\\kappa': 'κ',
+  '\\lambda': 'λ',
+  '\\mu': 'μ',
+  '\\nu': 'ν',
+  '\\xi': 'ξ',
+  '\\pi': 'π',
+  '\\varpi': 'ϖ',
+  '\\rho': 'ρ',
+  '\\varrho': 'ϱ',
+  '\\sigma': 'σ',
+  '\\varsigma': 'ς',
+  '\\tau': 'τ',
+  '\\upsilon': 'υ',
+  '\\phi': 'φ',
+  '\\varphi': 'φ',
+  '\\chi': 'χ',
+  '\\psi': 'ψ',
+  '\\omega': 'ω',
+
+  // Greek uppercase
+  '\\Gamma': 'Γ',
+  '\\Delta': 'Δ',
+  '\\Theta': 'Θ',
+  '\\Lambda': 'Λ',
+  '\\Xi': 'Ξ',
+  '\\Pi': 'Π',
+  '\\Sigma': 'Σ',
+  '\\Upsilon': 'Υ',
+  '\\Phi': 'Φ',
+  '\\Psi': 'Ψ',
+  '\\Omega': 'Ω',
+
+  // Big operators
+  '\\sum': '∑',
+  '\\prod': '∏',
+  '\\coprod': '∐',
+  '\\int': '∫',
+  '\\iint': '∬',
+  '\\iiint': '∭',
+  '\\oint': '∮',
+  '\\bigcup': '⋃',
+  '\\bigcap': '⋂',
+  '\\bigvee': '⋁',
+  '\\bigwedge': '⋀',
+  '\\bigoplus': '⨁',
+  '\\bigotimes': '⨂',
+
+  // Calculus
+  '\\partial': '∂',
+  '\\nabla': '∇',
+  '\\sqrt': '√',
+
+  // Sets
+  '\\emptyset': '∅',
+  '\\varnothing': '∅',
+  '\\infty': '∞',
+  '\\in': '∈',
+  '\\notin': '∉',
+  '\\ni': '∋',
+  '\\subset': '⊂',
+  '\\supset': '⊃',
+  '\\subseteq': '⊆',
+  '\\supseteq': '⊇',
+  '\\subsetneq': '⊊',
+  '\\supsetneq': '⊋',
+  '\\cup': '∪',
+  '\\cap': '∩',
+  '\\setminus': '∖',
+  '\\complement': '∁',
+
+  // Logic
+  '\\forall': '∀',
+  '\\exists': '∃',
+  '\\nexists': '∄',
+  '\\land': '∧',
+  '\\lor': '∨',
+  '\\lnot': '¬',
+  '\\neg': '¬',
+  '\\therefore': '∴',
+  '\\because': '∵',
+
+  // Relations
+  '\\le': '≤',
+  '\\leq': '≤',
+  '\\ge': '≥',
+  '\\geq': '≥',
+  '\\ne': '≠',
+  '\\neq': '≠',
+  '\\ll': '≪',
+  '\\gg': '≫',
+  '\\approx': '≈',
+  '\\equiv': '≡',
+  '\\cong': '≅',
+  '\\sim': '∼',
+  '\\simeq': '≃',
+  '\\propto': '∝',
+  '\\perp': '⊥',
+  '\\parallel': '∥',
+  '\\models': '⊨',
+  '\\vdash': '⊢',
+  '\\mid': '∣',
+  '\\nmid': '∤',
+  '\\divides': '∣',
+
+  // Common standalone glyphs
+  '\\blacksquare': '■',
+  '\\square': '□',
+  '\\Box': '□',
+  '\\qed': '∎',
+  '\\bigstar': '★',
+
+  // Modular arithmetic — the `\pmod{p}` form (with arg) is handled below;
+  // the bare `\bmod` / `\mod` commands are simple text substitutions.
+  '\\bmod': 'mod',
+  '\\mod': 'mod',
+
+  // Brackets / fences (named delimiter commands; the `\left\X` / `\right\X`
+  // unwrapping below leaves these behind for the symbol pass to resolve).
+  '\\langle': '⟨',
+  '\\rangle': '⟩',
+  '\\lceil': '⌈',
+  '\\rceil': '⌉',
+  '\\lfloor': '⌊',
+  '\\rfloor': '⌋',
+  '\\|': '‖',
+
+  // Arrows
+  '\\to': '→',
+  '\\rightarrow': '→',
+  '\\leftarrow': '←',
+  '\\leftrightarrow': '↔',
+  '\\Rightarrow': '⇒',
+  '\\Leftarrow': '⇐',
+  '\\Leftrightarrow': '⇔',
+  '\\implies': '⟹',
+  '\\impliedby': '⟸',
+  '\\iff': '⟺',
+  '\\mapsto': '↦',
+  '\\hookrightarrow': '↪',
+  '\\hookleftarrow': '↩',
+  '\\uparrow': '↑',
+  '\\downarrow': '↓',
+  '\\updownarrow': '↕',
+
+  // Binary operators
+  '\\cdot': '⋅',
+  '\\cdots': '⋯',
+  '\\ldots': '…',
+  '\\dots': '…',
+  '\\dotsb': '…',
+  '\\dotsc': '…',
+  '\\vdots': '⋮',
+  '\\ddots': '⋱',
+  '\\times': '×',
+  '\\div': '÷',
+  '\\pm': '±',
+  '\\mp': '∓',
+  '\\circ': '∘',
+  '\\bullet': '•',
+  '\\star': '⋆',
+  '\\ast': '∗',
+  '\\oplus': '⊕',
+  '\\ominus': '⊖',
+  '\\otimes': '⊗',
+  '\\odot': '⊙',
+  '\\diamond': '⋄',
+  '\\angle': '∠',
+  '\\triangle': '△',
+
+  // Spacing — collapse to varying widths of regular space
+  '\\,': ' ',
+  '\\;': ' ',
+  '\\:': ' ',
+  '\\!': '',
+  '\\ ': ' ',
+  '\\quad': '  ',
+  '\\qquad': '    ',
+
+  // Functions (LaTeX renders these in roman; we just keep the name)
+  '\\sin': 'sin',
+  '\\cos': 'cos',
+  '\\tan': 'tan',
+  '\\cot': 'cot',
+  '\\sec': 'sec',
+  '\\csc': 'csc',
+  '\\arcsin': 'arcsin',
+  '\\arccos': 'arccos',
+  '\\arctan': 'arctan',
+  '\\sinh': 'sinh',
+  '\\cosh': 'cosh',
+  '\\tanh': 'tanh',
+  '\\log': 'log',
+  '\\ln': 'ln',
+  '\\exp': 'exp',
+  '\\det': 'det',
+  '\\dim': 'dim',
+  '\\ker': 'ker',
+  '\\lim': 'lim',
+  '\\liminf': 'liminf',
+  '\\limsup': 'limsup',
+  '\\sup': 'sup',
+  '\\inf': 'inf',
+  '\\max': 'max',
+  '\\min': 'min',
+  '\\arg': 'arg',
+  '\\gcd': 'gcd',
+
+  // Escaped literals — model occasionally emits these for display
+  '\\&': '&',
+  '\\%': '%',
+  '\\$': '$',
+  '\\#': '#',
+  '\\_': '_',
+  '\\{': '{',
+  '\\}': '}'
+}
+
+const BB: Record<string, string> = {
+  A: '𝔸',
+  B: '𝔹',
+  C: 'ℂ',
+  D: '𝔻',
+  E: '𝔼',
+  F: '𝔽',
+  G: '𝔾',
+  H: 'ℍ',
+  I: '𝕀',
+  J: '𝕁',
+  K: '𝕂',
+  L: '𝕃',
+  M: '𝕄',
+  N: 'ℕ',
+  O: '𝕆',
+  P: 'ℙ',
+  Q: 'ℚ',
+  R: 'ℝ',
+  S: '𝕊',
+  T: '𝕋',
+  U: '𝕌',
+  V: '𝕍',
+  W: '𝕎',
+  X: '𝕏',
+  Y: '𝕐',
+  Z: 'ℤ'
+}
+
+const CAL: Record<string, string> = {
+  A: '𝒜',
+  B: 'ℬ',
+  C: '𝒞',
+  D: '𝒟',
+  E: 'ℰ',
+  F: 'ℱ',
+  G: '𝒢',
+  H: 'ℋ',
+  I: 'ℐ',
+  J: '𝒥',
+  K: '𝒦',
+  L: 'ℒ',
+  M: 'ℳ',
+  N: '𝒩',
+  O: '𝒪',
+  P: '𝒫',
+  Q: '𝒬',
+  R: 'ℛ',
+  S: '𝒮',
+  T: '𝒯',
+  U: '𝒰',
+  V: '𝒱',
+  W: '𝒲',
+  X: '𝒳',
+  Y: '𝒴',
+  Z: '𝒵'
+}
+
+const FRAK: Record<string, string> = {
+  A: '𝔄',
+  B: '𝔅',
+  C: 'ℭ',
+  D: '𝔇',
+  E: '𝔈',
+  F: '𝔉',
+  G: '𝔊',
+  H: 'ℌ',
+  I: 'ℑ',
+  J: '𝔍',
+  K: '𝔎',
+  L: '𝔏',
+  M: '𝔐',
+  N: '𝔑',
+  O: '𝔒',
+  P: '𝔓',
+  Q: '𝔔',
+  R: 'ℜ',
+  S: '𝔖',
+  T: '𝔗',
+  U: '𝔘',
+  V: '𝔙',
+  W: '𝔚',
+  X: '𝔛',
+  Y: '𝔜',
+  Z: 'ℨ'
+}
+
+const SUPERSCRIPT: Record<string, string> = {
+  '0': '⁰',
+  '1': '¹',
+  '2': '²',
+  '3': '³',
+  '4': '⁴',
+  '5': '⁵',
+  '6': '⁶',
+  '7': '⁷',
+  '8': '⁸',
+  '9': '⁹',
+  '+': '⁺',
+  '-': '⁻',
+  '=': '⁼',
+  '(': '⁽',
+  ')': '⁾',
+  a: 'ᵃ',
+  b: 'ᵇ',
+  c: 'ᶜ',
+  d: 'ᵈ',
+  e: 'ᵉ',
+  f: 'ᶠ',
+  g: 'ᵍ',
+  h: 'ʰ',
+  i: 'ⁱ',
+  j: 'ʲ',
+  k: 'ᵏ',
+  l: 'ˡ',
+  m: 'ᵐ',
+  n: 'ⁿ',
+  o: 'ᵒ',
+  p: 'ᵖ',
+  r: 'ʳ',
+  s: 'ˢ',
+  t: 'ᵗ',
+  u: 'ᵘ',
+  v: 'ᵛ',
+  w: 'ʷ',
+  x: 'ˣ',
+  y: 'ʸ',
+  z: 'ᶻ'
+}
+
+const SUBSCRIPT: Record<string, string> = {
+  '0': '₀',
+  '1': '₁',
+  '2': '₂',
+  '3': '₃',
+  '4': '₄',
+  '5': '₅',
+  '6': '₆',
+  '7': '₇',
+  '8': '₈',
+  '9': '₉',
+  '+': '₊',
+  '-': '₋',
+  '=': '₌',
+  '(': '₍',
+  ')': '₎',
+  a: 'ₐ',
+  e: 'ₑ',
+  h: 'ₕ',
+  i: 'ᵢ',
+  j: 'ⱼ',
+  k: 'ₖ',
+  l: 'ₗ',
+  m: 'ₘ',
+  n: 'ₙ',
+  o: 'ₒ',
+  p: 'ₚ',
+  r: 'ᵣ',
+  s: 'ₛ',
+  t: 'ₜ',
+  u: 'ᵤ',
+  v: 'ᵥ',
+  x: 'ₓ'
+}
+
+// Markers for `\boxed` / `\fbox` regions. Upstream hermes-agent uses
+// non-printable U+0001 / U+0002 sentinels and its React renderer
+// splits on them to apply inverse+bold. Herm feeds the converted
+// string directly to OpenTUI's <markdown> component, which doesn't
+// have a split-and-style hook — so we emit markdown-level `**X**`
+// instead, and let the markdown renderer turn it into bold on its
+// own. This trades the inverse-video visual for standard bold but
+// keeps the pipeline hook-free.
+const BOX_WRAP_OPEN = "**"
+const BOX_WRAP_CLOSE = "**"
+
+const escapeRe = (s: string) => s.replace(/[.*+?^${}()|[\]\\]/g, '\\$&')
+
+// Pre-compile two symbol regexes: one for letter-ending commands (`\pi`,
+// `\sum`) which need a `(?![A-Za-z])` lookahead so they don't partially
+// match `\pix` or `\summa`, and one for punctuation-ending commands
+// (`\{`, `\,`, `\|`) which must NOT have the lookahead — otherwise
+// `\{p` would refuse to substitute because `p` is a letter.
+//
+// Longest commands first inside each group so `\leq` beats `\le`.
+const splitByEnding = (keys: string[]) => {
+  const letter: string[] = []
+  const punct: string[] = []
+
+  for (const k of keys) {
+    if (/[A-Za-z]$/.test(k)) {
+      letter.push(k)
+    } else {
+      punct.push(k)
+    }
+  }
+
+  return { letter, punct }
+}
+
+const buildAlt = (cmds: string[]) =>
+  cmds
+    .sort((a, b) => b.length - a.length)
+    .map(escapeRe)
+    .join('|')
+
+const { letter: LETTER_CMDS, punct: PUNCT_CMDS } = splitByEnding(Object.keys(SYMBOLS))
+
+const SYMBOL_LETTER_RE = new RegExp('(?:' + buildAlt(LETTER_CMDS) + ')(?![A-Za-z])', 'g')
+const SYMBOL_PUNCT_RE = new RegExp('(?:' + buildAlt(PUNCT_CMDS) + ')', 'g')
+
+const convertScript = (input: string, table: Record<string, string>, sigil: '^' | '_'): string => {
+  let out = ''
+  let allMapped = true
+
+  for (const ch of input) {
+    const mapped = table[ch]
+
+    if (!mapped) {
+      allMapped = false
+
+      break
+    }
+
+    out += mapped
+  }
+
+  if (allMapped) {
+    return out
+  }
+
+  // Fallback: if the body is a single visible character (e.g. `∞` after
+  // earlier symbol substitution), render it without braces — `^∞` reads
+  // far better than `^{∞}` in a terminal. Multi-char bodies that don't
+  // fully convert use parens (`e^(iπ)`) instead of braces (`e^{iπ}`)
+  // because parens are normal punctuation while braces look like
+  // unrendered LaTeX.
+  const trimmed = input.trim()
+
+  if ([...trimmed].length === 1) {
+    return `${sigil}${trimmed}`
+  }
+
+  return `${sigil}(${trimmed})`
+}
+
+// Walk the string and parse `{...}` honouring nested braces. Unlike a
+// `\{[^{}]*\}` regex this survives `\frac{|t|^{p-1}|P(t)|^p}{...}` where
+// the numerator contains its own braces from a superscript. Returns the
+// inner content (without the outer braces) and the offset just past the
+// closing `}`. Returns null if there is no balanced brace at `start`.
+const readBraced = (s: string, start: number): { content: string; end: number } | null => {
+  if (s[start] !== '{') {
+    return null
+  }
+
+  let depth = 1
+  let i = start + 1
+
+  while (i < s.length && depth > 0) {
+    const c = s[i]
+
+    // Skip escapes — `\{` and `\}` inside a body are literal braces and
+    // should not change the brace counter.
+    if (c === '\\' && i + 1 < s.length) {
+      i += 2
+      continue
+    }
+
+    if (c === '{') {
+      depth++
+    } else if (c === '}') {
+      depth--
+    }
+
+    if (depth > 0) {
+      i++
+    }
+  }
+
+  if (depth !== 0) {
+    return null
+  }
+
+  return { content: s.slice(start + 1, i), end: i + 1 }
+}
+
+// Replace every occurrence of `\command{arg}` using balanced-brace parsing
+// (so `\boxed{x^{n+1}}` works where a `[^{}]*` regex would fail). The
+// `render` callback receives the inner content already recursed-into, so
+// `\boxed{\boxed{x}}` resolves outside-in cleanly. Unmatched `\command`
+// (no following `{...}`) is preserved verbatim.
+const replaceBracedCommand = (input: string, command: string, render: (content: string) => string): string => {
+  const cmdLen = command.length
+  let out = ''
+  let i = 0
+
+  while (i < input.length) {
+    const idx = input.indexOf(command, i)
+
+    if (idx < 0) {
+      out += input.slice(i)
+
+      return out
+    }
+
+    const after = input[idx + cmdLen]
+
+    if (after && /[A-Za-z]/.test(after)) {
+      out += input.slice(i, idx + cmdLen)
+      i = idx + cmdLen
+      continue
+    }
+
+    out += input.slice(i, idx)
+
+    let p = idx + cmdLen
+
+    while (input[p] === ' ' || input[p] === '\t') p++
+
+    const arg = readBraced(input, p)
+
+    if (!arg) {
+      out += input.slice(idx, p + 1)
+      i = p + 1
+      continue
+    }
+
+    out += render(replaceBracedCommand(arg.content, command, render))
+    i = arg.end
+  }
+
+  return out
+}
+
+// Replace every `\frac{num}{den}` with `num/den` (parens around either
+// side when its precedence demands it). The recursion handles nested
+// fractions naturally: `\frac{1}{\frac{1}{x}}` collapses to `1/(1/x)`
+// because we recurse into `den` before deciding whether to parenthesise.
+const replaceFracs = (input: string): string => {
+  let out = ''
+  let i = 0
+
+  while (i < input.length) {
+    const idx = input.indexOf('\\frac', i)
+
+    if (idx < 0) {
+      out += input.slice(i)
+
+      return out
+    }
+
+    const after = input[idx + 5]
+
+    // `(?![A-Za-z])` — protect hypothetical commands like `\fraction`.
+    if (after && /[A-Za-z]/.test(after)) {
+      out += input.slice(i, idx + 5)
+      i = idx + 5
+      continue
+    }
+
+    out += input.slice(i, idx)
+
+    let p = idx + 5
+
+    while (input[p] === ' ' || input[p] === '\t') p++
+
+    const num = readBraced(input, p)
+
+    if (!num) {
+      out += input.slice(idx, p + 1)
+      i = p + 1
+      continue
+    }
+
+    p = num.end
+
+    while (input[p] === ' ' || input[p] === '\t') p++
+
+    const den = readBraced(input, p)
+
+    if (!den) {
+      out += input.slice(idx, p + 1)
+      i = p + 1
+      continue
+    }
+
+    out += `${wrapForFrac(replaceFracs(num.content))}/${wrapForFrac(replaceFracs(den.content))}`
+    i = den.end
+  }
+
+  return out
+}
+
+// Wrap multi-token expressions in parens so `\frac{a+b}{c}` becomes
+// `(a+b)/c` rather than `a+b/c`. We wrap whenever inline `/` would
+// change the meaning — that's any binary operator (`+`, `-`, `*`, `/`)
+// or whitespace separating tokens. `*` and `/` matter because nested
+// fractions and products like `\frac{a*b}{c}` and `\frac{1/x}{y}` would
+// otherwise read as `a*b/c` (right-associative ambiguity) and `1/x/y`.
+// Atomic factors like `n!`, `x^2`, `\sin x` don't trigger any of these
+// and stay un-parenthesised — wrapping them just clutters the output.
+const wrapForFrac = (expr: string) => {
+  const trimmed = expr.trim()
+
+  if (!trimmed) {
+    return trimmed
+  }
+
+  if (/^\(.*\)$/.test(trimmed)) {
+    return trimmed
+  }
+
+  if (/[+\-/*]|\s/.test(trimmed)) {
+    return `(${trimmed})`
+  }
+
+  return trimmed
+}
+
+export function texToUnicode(input: string): string {
+  let s = input
+
+  s = s.replace(/\\mathbb\s*\{([A-Za-z])\}/g, (raw, c: string) => BB[c] ?? raw)
+  s = s.replace(/\\mathcal\s*\{([A-Za-z])\}/g, (raw, c: string) => CAL[c] ?? raw)
+  s = s.replace(/\\mathfrak\s*\{([A-Za-z])\}/g, (raw, c: string) => FRAK[c] ?? raw)
+  s = s.replace(/\\mathbf\s*\{([^{}]+)\}/g, (_, c: string) => c)
+  s = s.replace(/\\mathit\s*\{([^{}]+)\}/g, (_, c: string) => c)
+  s = s.replace(/\\mathrm\s*\{([^{}]+)\}/g, (_, c: string) => c)
+  s = s.replace(/\\text\s*\{([^{}]+)\}/g, (_, c: string) => c)
+  s = s.replace(/\\operatorname\s*\{([^{}]+)\}/g, (_, c: string) => c)
+
+  s = s.replace(/\\overline\s*\{([^{}]+)\}/g, (_, c: string) => `${c}\u0305`)
+  s = s.replace(/\\hat\s*\{([^{}]+)\}/g, (_, c: string) => `${c}\u0302`)
+  s = s.replace(/\\bar\s*\{([^{}]+)\}/g, (_, c: string) => `${c}\u0304`)
+  s = s.replace(/\\tilde\s*\{([^{}]+)\}/g, (_, c: string) => `${c}\u0303`)
+  s = s.replace(/\\vec\s*\{([^{}]+)\}/g, (_, c: string) => `${c}\u20D7`)
+  s = s.replace(/\\dot\s*\{([^{}]+)\}/g, (_, c: string) => `${c}\u0307`)
+  s = s.replace(/\\ddot\s*\{([^{}]+)\}/g, (_, c: string) => `${c}\u0308`)
+
+  s = replaceFracs(s)
+
+  // `\boxed{X}` / `\fbox{X}` highlight a final answer. Terminals can't
+  // draw a real box, so we wrap the content in U+0001 / U+0002 control
+  // characters — non-printable, never present in real text — and let the
+  // markdown renderer split on them and apply a highlight style (inverse
+  // video) to the bracketed region. This keeps `texToUnicode` pure-string
+  // while letting the React layer do the actual visual emphasis.
+  // Argument is parsed with balanced braces so nested `{...}` from
+  // superscripts / fractions inside the box survive.
+  s = replaceBracedCommand(s, '\\boxed', body => `${BOX_WRAP_OPEN}${body.trim()}${BOX_WRAP_CLOSE}`)
+  s = replaceBracedCommand(s, '\\fbox', body => `${BOX_WRAP_OPEN}${body.trim()}${BOX_WRAP_CLOSE}`)
+
+  // `\xrightarrow{label}` / `\xleftarrow{label}` collapse to an arrow with
+  // the label inline. LaTeX renders the label above the arrow; in monospace
+  // we put it adjacent — `─label→` is the closest readable approximation.
+  // Run before the symbol pass so the label can still pick up Greek and
+  // operator substitutions afterwards.
+  s = s.replace(/\\xrightarrow\s*\{([^{}]*)\}/g, (_, label: string) => `─${label.trim()}→`)
+  s = s.replace(/\\xleftarrow\s*\{([^{}]*)\}/g, (_, label: string) => `←${label.trim()}─`)
+  s = s.replace(/\\Longrightarrow/g, '⟹')
+  s = s.replace(/\\Longleftarrow/g, '⟸')
+  s = s.replace(/\\Longleftrightarrow/g, '⟺')
+
+  // `\pmod{p}` → ` (mod p)` (LaTeX adds parens automatically); `\pod{p}`
+  // is a paren-less variant; `\tag{n}` is the equation-number annotation
+  // shown to the right of an equation. Collapse to a single-space-prefixed
+  // bracketed form. The leading `\s*` in the pattern absorbs any whitespace
+  // already in the source so we don't end up with `b  (mod p)` (double
+  // space) when the user wrote `b \pmod{p}`.
+  s = s.replace(/\s*\\pmod\s*\{([^{}]*)\}/g, (_, p: string) => ` (mod ${p.trim()})`)
+  s = s.replace(/\s*\\pod\s*\{([^{}]*)\}/g, (_, p: string) => ` (${p.trim()})`)
+  s = s.replace(/\s*\\tag\s*\{([^{}]*)\}/g, (_, n: string) => ` (${n.trim()})`)
+
+  // `\big`, `\Big`, `\bigg`, `\Bigg` (with optional `l`/`r`/`m` suffix)
+  // are sizing wrappers analogous to `\left`/`\right` but without the
+  // automatic-pairing semantics. Strip them and leave whatever delimiter
+  // follows. The trailing `(?![A-Za-z])` protects `\bigtriangleup` and
+  // any other letter-continuation command from being shaved.
+  s = s.replace(/\\(?:Bigg|bigg|Big|big)[lrm]?(?![A-Za-z])/g, '')
+
+  // Style / size hints that don't typeset any glyph and only affect how
+  // things would be sized in a real LaTeX engine. In a terminal every
+  // glyph is one monospace cell, so there's nothing to do — drop them
+  // (with any trailing whitespace) so they don't leak through as raw
+  // `\displaystyle` in the output.
+  s = s.replace(/\\(?:scriptscriptstyle|displaystyle|scriptstyle|textstyle|nolimits|limits)(?![A-Za-z])\s*/g, '')
+
+  // `\left` and `\right` are sizing wrappers around any delimiter — bare
+  // (`\left(`), escaped (`\left\{`), or named (`\left\langle`). Strip the
+  // wrapper unconditionally and let the rest of the pipeline (or the
+  // upcoming symbol pass) handle whatever delimiter follows. The optional
+  // `.?` consumes `\left.` / `\right.` which mean "no delimiter".
+  // Lookahead `(?![A-Za-z])` keeps `\leftarrow` / `\leftrightarrow` safe.
+  s = s.replace(/\\left(?![A-Za-z])\.?/g, '')
+  s = s.replace(/\\right(?![A-Za-z])\.?/g, '')
+
+  // Run symbol substitution BEFORE scripts so a body like `^{\infty}`
+  // becomes `^{∞}` first; convertScript can then either map ∞ to a
+  // superscript (it can't — Unicode lacks one) or fall back to `^∞`
+  // by stripping braces around the now-single-character body.
+  //
+  // Punctuation pass first — these can be followed by letters (`\{p`
+  // is "open-brace then p"), so the letter pass's `(?![A-Za-z])` rule
+  // would wrongly block them.
+  s = s.replace(SYMBOL_PUNCT_RE, m => SYMBOLS[m] ?? m)
+  s = s.replace(SYMBOL_LETTER_RE, m => SYMBOLS[m] ?? m)
+
+  // Bare `^c` / `_c` handles ONLY alphanumerics and `+`/`-`/`=`. Parens
+  // are intentionally excluded because the braced-fallback above can
+  // emit `(...)` and we don't want a second pass to greedily convert
+  // its opening paren into `⁽` and orphan the closing one.
+  s = s.replace(/\^\s*\{([^{}]+)\}/g, (_, body: string) => convertScript(body, SUPERSCRIPT, '^'))
+  s = s.replace(/\^([A-Za-z0-9+\-=])/g, (raw, ch: string) => SUPERSCRIPT[ch] ?? raw)
+  s = s.replace(/_\s*\{([^{}]+)\}/g, (_, body: string) => convertScript(body, SUBSCRIPT, '_'))
+  s = s.replace(/_([A-Za-z0-9+\-=])/g, (raw, ch: string) => SUBSCRIPT[ch] ?? raw)
+
+  return s
+}
+
+// Inline-code spans: 1–2 backticks, non-greedy body, same-length closer.
+// Captured so mathify can step over them without a placeholder dance.
+const CODE_SPAN_RE = /(`{1,2})[^`\n]+?\1/g
+
+// Math delimiters, tightest-to-loosest. `$$…$$` before `$…$` so the
+// single-dollar branch never eats a display-math opener. `$…$` uses the
+// same no-space-adjacent rule upstream uses to dodge `$5 to $10` prose.
+const MATH_SPAN_RE = new RegExp(
+  [
+    String.raw`\$\$([^$]+?)\$\$`,
+    String.raw`\\\[([\s\S]+?)\\\]`,
+    String.raw`\\\(([^\n]+?)\\\)`,
+    String.raw`(?<!\$)\$([^\s$](?:[^$\n]*?[^\s$])?)\$(?!\$)`,
+  ].join('|'),
+  'g',
+)
+
+// Apply texToUnicode only inside math delimiters. texToUnicode is a
+// whole-string transform (it will turn prose `_n` into `ₙ`), so it must
+// never see non-math text. Walk the string, skip inline-code spans
+// verbatim, and rewrite math spans in the gaps.
+export function mathify(md: string): string {
+  if (!/[$\\]/.test(md)) return md
+  let out = ''
+  let i = 0
+  CODE_SPAN_RE.lastIndex = 0
+  for (const m of md.matchAll(CODE_SPAN_RE)) {
+    out += md.slice(i, m.index).replace(MATH_SPAN_RE,
+      (_, a, b, c, d) => texToUnicode(a ?? b ?? c ?? d))
+    out += m[0]
+    i = m.index + m[0].length
+  }
+  out += md.slice(i).replace(MATH_SPAN_RE,
+    (_, a, b, c, d) => texToUnicode(a ?? b ?? c ?? d))
+  return out
+}