nastech-tui 0.0.1

package/src/__tests__/markdown.test.ts

@@ -0,0 +1,331 @@
+import { PassThrough } from 'stream'
+
+import { Box, renderSync } from '@nastechai/ink'
+import React from 'react'
+import { describe, expect, it } from 'vitest'
+
+import { AUDIO_DIRECTIVE_RE, INLINE_RE, Md, MEDIA_LINE_RE, stripInlineMarkup } from '../components/markdown.js'
+import { stripAnsi } from '../lib/text.js'
+import { DEFAULT_THEME } from '../theme.js'
+
+const matches = (text: string) => [...text.matchAll(INLINE_RE)].map(m => m[0])
+const BEL = String.fromCharCode(7)
+const ESC = String.fromCharCode(27)
+const CSI_RE = new RegExp(`${ESC}\\[[0-?]*[ -/]*[@-~]`, 'g')
+const OSC_RE = new RegExp(`${ESC}\\][\\s\\S]*?(?:${BEL}|${ESC}\\\\)`, 'g')
+
+const renderPlain = (node: React.ReactNode) => {
+  const stdout = new PassThrough()
+  const stdin = new PassThrough()
+  const stderr = new PassThrough()
+  let output = ''
+
+  Object.assign(stdout, { columns: 80, isTTY: false, rows: 24 })
+  Object.assign(stdin, { isTTY: false })
+  Object.assign(stderr, { isTTY: false })
+  stdout.on('data', chunk => {
+    output += chunk.toString()
+  })
+
+  const instance = renderSync(node, {
+    patchConsole: false,
+    stderr: stderr as NodeJS.WriteStream,
+    stdin: stdin as NodeJS.ReadStream,
+    stdout: stdout as NodeJS.WriteStream
+  })
+
+  instance.unmount()
+  instance.cleanup()
+
+  return output
+    .replace(OSC_RE, '')
+    .split('\n')
+    .map(line => stripAnsi(line).replace(CSI_RE, '').trimEnd())
+}
+
+describe('INLINE_RE emphasis', () => {
+  it('matches word-boundary italic/bold', () => {
+    expect(matches('say _hi_ there')).toEqual(['_hi_'])
+    expect(matches('very __bold move__ today')).toEqual(['__bold move__'])
+    expect(matches('(_paren_) and [_bracket_]')).toEqual(['_paren_', '_bracket_'])
+  })
+
+  it('keeps intraword underscores literal', () => {
+    const path = '/home/me/.nastech/cache/screenshots/browser_screenshot_ecc1c3feab.png'
+
+    expect(matches(path)).toEqual([])
+    expect(matches('snake_case_var and MY_CONST')).toEqual([])
+    expect(matches('foo__bar__baz')).toEqual([])
+  })
+
+  it('keeps Python dunder identifiers literal', () => {
+    expect(matches('if __name__ == "__main__":')).toEqual([])
+    expect(matches('def __init__(self):')).toEqual([])
+    expect(matches('print(__file__)')).toEqual([])
+  })
+
+  it('still matches asterisk emphasis intraword', () => {
+    expect(matches('a*b*c')).toEqual(['*b*'])
+    expect(matches('a**bold**c')).toEqual(['**bold**'])
+  })
+
+  it('matches short alphanumeric subscript (H~2~O, CO~2~, X~n~)', () => {
+    expect(matches('H~2~O')).toEqual(['~2~'])
+    expect(matches('CO~2~ levels')).toEqual(['~2~'])
+    expect(matches('the X~n~ term')).toEqual(['~n~'])
+  })
+
+  it('ignores kaomoji-style ~! and ~? punctuation', () => {
+    // Kimi / Qwen / GLM emit these as decorators and the whole span between
+    // two tildes used to get collapsed into one dim blob.
+    expect(matches('Aww ~! Building step by step, I love it ~!')).toEqual([])
+    expect(matches('cool ~? yeah ~?')).toEqual([])
+    expect(matches('mixed ~! and ~? flow')).toEqual([])
+  })
+
+  it('ignores tilde spans that contain spaces or punctuation', () => {
+    // Real subscript doesn't contain spaces; a tilde followed by words-then-
+    // tilde is almost always conversational. Matching it swallows text.
+    expect(matches('hello ~good idea~ there')).toEqual([])
+    expect(matches('x ~oh no!~ y')).toEqual([])
+  })
+
+  it('does not let strikethrough eat subscript', () => {
+    expect(matches('~~strike~~ and H~2~O')).toEqual(['~~strike~~', '~2~'])
+  })
+})
+
+describe('stripInlineMarkup', () => {
+  it('strips word-boundary emphasis only', () => {
+    expect(stripInlineMarkup('say _hi_ there')).toBe('say hi there')
+    expect(stripInlineMarkup('browser_screenshot_ecc.png')).toBe('browser_screenshot_ecc.png')
+    expect(stripInlineMarkup('__bold move__ and foo__bar__')).toBe('bold move and foo__bar__')
+  })
+
+  it('preserves Python dunder identifiers', () => {
+    expect(stripInlineMarkup('if __name__ == "__main__":')).toBe('if __name__ == "__main__":')
+    expect(stripInlineMarkup('class X: def __init__(self): pass')).toBe('class X: def __init__(self): pass')
+  })
+
+  it('leaves ~!/~? kaomoji alone and still handles real subscript', () => {
+    expect(stripInlineMarkup('Yay ~! nice work ~!')).toBe('Yay ~! nice work ~!')
+    expect(stripInlineMarkup('H~2~O and CO~2~')).toBe('H_2O and CO_2')
+  })
+
+  it('strips inline math delimiters but keeps the formula text', () => {
+    expect(stripInlineMarkup('$\\mathbb{Z}$ is a ring')).toBe('\\mathbb{Z} is a ring')
+    expect(stripInlineMarkup('see \\(a + b\\) ok')).toBe('see a + b ok')
+  })
+})
+
+describe('INLINE_RE inline math', () => {
+  it('matches single-dollar math and beats emphasis at the same start', () => {
+    // Without math handling, `*b*` would have matched as italics and
+    // corrupted the formula. With math added to INLINE_RE, the leftmost
+    // match at column 0 (`$P=a*b*c$`) wins.
+    expect(matches('$P=a*b*c$')).toEqual(['$P=a*b*c$'])
+    expect(matches('see $\\mathbb{Z}$ here')).toEqual(['$\\mathbb{Z}$'])
+  })
+
+  it('does not match currency-style prose', () => {
+    expect(matches('it costs $5 and $10')).toEqual([])
+    expect(matches('paid $5')).toEqual([])
+  })
+
+  it('does not let inline math swallow a $$ display fence', () => {
+    // `$$x$$` is a display block, not two abutting inline-math spans.
+    expect(matches('$$x$$')).toEqual([])
+  })
+
+  it('matches \\(...\\) inline math', () => {
+    expect(matches('foo \\(x + y\\) bar')).toEqual(['\\(x + y\\)'])
+  })
+
+  it('does not corrupt subscripts/superscripts inside math', () => {
+    // `_n` and `^r` are markdown emphasis/superscript markers in prose, but
+    // inside a `$...$` span the entire formula is captured as a single
+    // inline-math token so the inner regexes never see those characters.
+    expect(matches('$P=a_n x^n + a_0$')).toEqual(['$P=a_n x^n + a_0$'])
+    expect(matches('$\\beta_1,\\dots,\\beta_r$')).toEqual(['$\\beta_1,\\dots,\\beta_r$'])
+  })
+
+  it('places math content in the correct capture group (regression: m[16] is bare URL)', () => {
+    // When `m[16]` was the bare URL group AND the inline-math `$...$`
+    // group simultaneously (because the bare URL pattern lacked its own
+    // capturing parens), MdInline rendered `$\\mathbb{R}$` as an
+    // underlined autolink instead of italic amber math. Lock down the
+    // numbering: math goes in m[17] / m[18], URLs go in m[16].
+    const url = [...'see https://example.com here'.matchAll(INLINE_RE)][0]!
+    const dollarMath = [...'$\\mathbb{R}$'.matchAll(INLINE_RE)][0]!
+    const parenMath = [...'\\(\\pi\\)'.matchAll(INLINE_RE)][0]!
+
+    expect(url[16]).toBe('https://example.com')
+    expect(url[17]).toBeUndefined()
+    expect(url[18]).toBeUndefined()
+
+    expect(dollarMath[16]).toBeUndefined()
+    expect(dollarMath[17]).toBe('\\mathbb{R}')
+    expect(dollarMath[18]).toBeUndefined()
+
+    expect(parenMath[16]).toBeUndefined()
+    expect(parenMath[17]).toBeUndefined()
+    expect(parenMath[18]).toBe('\\pi')
+  })
+})
+
+describe('protocol sentinels', () => {
+  it('captures MEDIA: paths with surrounding quotes or backticks', () => {
+    expect('MEDIA:/tmp/a.png'.match(MEDIA_LINE_RE)?.[1]).toBe('/tmp/a.png')
+    expect('  MEDIA: /home/me/.nastech/cache/screenshots/browser_screenshot_ecc.png  '.match(MEDIA_LINE_RE)?.[1]).toBe(
+      '/home/me/.nastech/cache/screenshots/browser_screenshot_ecc.png'
+    )
+    expect('`MEDIA:/tmp/a.png`'.match(MEDIA_LINE_RE)?.[1]).toBe('/tmp/a.png')
+    expect('"MEDIA:C:\\files\\a.png"'.match(MEDIA_LINE_RE)?.[1]).toBe('C:\\files\\a.png')
+  })
+
+  it('ignores MEDIA: tokens embedded in prose', () => {
+    expect('here is MEDIA:/tmp/a.png for you'.match(MEDIA_LINE_RE)).toBeNull()
+    expect('the media: section is empty'.match(MEDIA_LINE_RE)).toBeNull()
+  })
+
+  it('matches the [[audio_as_voice]] directive', () => {
+    expect(AUDIO_DIRECTIVE_RE.test('[[audio_as_voice]]')).toBe(true)
+    expect(AUDIO_DIRECTIVE_RE.test('  [[audio_as_voice]]  ')).toBe(true)
+    expect(AUDIO_DIRECTIVE_RE.test('audio_as_voice')).toBe(false)
+  })
+})
+
+describe('Md wrapping', () => {
+  it('trims spaces from word-wrap continuation lines', () => {
+    const lines = renderPlain(
+      React.createElement(Box, { width: 5 }, React.createElement(Md, { t: DEFAULT_THEME, text: 'Let me' }))
+    )
+
+    expect(lines).toContain('Let')
+    expect(lines).toContain('me')
+    expect(lines).not.toContain(' me')
+  })
+
+  it('keeps nested list and quote indentation out of trim-sensitive text', () => {
+    const lines = renderPlain(
+      React.createElement(
+        Box,
+        { flexDirection: 'column', width: 24 },
+        React.createElement(Md, { t: DEFAULT_THEME, text: '  - nested bullet' }),
+        React.createElement(Md, { t: DEFAULT_THEME, text: '>> nested quote' })
+      )
+    )
+
+    expect(lines).toContain('  • nested bullet')
+    expect(lines).toContain('  │ nested quote')
+  })
+
+  it('preserves original inline-code edge spaces', () => {
+    const lines = renderPlain(
+      React.createElement(Box, { width: 24 }, React.createElement(Md, { t: DEFAULT_THEME, text: '` hi ` ok' }))
+    )
+
+    expect(lines.some(line => line.startsWith(' hi  ok'))).toBe(true)
+  })
+
+  it('renders Python dunder identifiers literally outside code fences', () => {
+    const lines = renderPlain(
+      React.createElement(
+        Box,
+        { width: 80 },
+        React.createElement(Md, {
+          t: DEFAULT_THEME,
+          text: 'if __name__ == "__main__":\n    obj.__init__()'
+        })
+      )
+    )
+
+    const rendered = lines.join('\n')
+
+    expect(rendered).toContain('if __name__ == "__main__":')
+    expect(rendered).toContain('obj.__init__()')
+  })
+})
+
+describe('Md link labels', () => {
+  it('renders bare URLs with readable slug labels', () => {
+    const lines = renderPlain(
+      React.createElement(
+        Box,
+        { width: 120 },
+        React.createElement(Md, {
+          t: DEFAULT_THEME,
+          text: 'see https://www.expedia.com/things-to-do/puerto-rico-el-yunque-rainforest-adventure for details'
+        })
+      )
+    )
+
+    const rendered = lines.join('\n')
+
+    expect(rendered).toContain('Puerto Rico El Yunque Rainforest Adventure')
+    expect(rendered).not.toContain('https://www.expedia.com/things-to-do/puerto-rico-el-yunque-rainforest-adventure')
+  })
+
+  it('keeps explicit markdown labels as the immediate fallback', () => {
+    const lines = renderPlain(
+      React.createElement(
+        Box,
+        { width: 80 },
+        React.createElement(Md, {
+          t: DEFAULT_THEME,
+          text: '[Trip details](https://www.expedia.com/things-to-do/puerto-rico-el-yunque-rainforest-adventure)'
+        })
+      )
+    )
+
+    expect(lines.join('\n')).toContain('Trip details')
+  })
+})
+
+describe('renderTable CJK width alignment', () => {
+  it('column starts share the same display offset across CJK rows', async () => {
+    const { stringWidth } = await import('@nastechai/ink')
+
+    const md = [
+      '| 配置 | Config | 状态 |',
+      '|------|--------|------|',
+      '| Vicuna (report) | dense | × |',
+      '| ChatGLM | chat | ✓ |',
+      '| 通义千问 | qwen | × |'
+    ].join('\n')
+
+    // Pre-fix bug: ` `.repeat(w - stripInlineMarkup(...).length) used
+    // UTF-16 code units, so a CJK header cell padded to 2 cells while
+    // the body cell padded to 4, drifting subsequent columns by 2
+    // cells per CJK char.
+    //
+    // Post-fix contract: the prefix preceding the start of column N
+    // has the same display width across the header and every body row
+    // (deduped to skip the divider, which renders independently).
+    const lines = renderPlain(
+      React.createElement(Box, null, React.createElement(Md, { compact: true, t: DEFAULT_THEME, text: md }))
+    ).filter(line => line.trim().length > 0)
+
+    // Heuristic: a "data row" line either contains 'Config' (header)
+    // or one of the body labels; a divider is all box-drawing.  Use
+    // the substring 'Config' / 'dense' / 'chat' / 'qwen' as the
+    // unique anchor for column 2's start position on each row.
+    const colStarts = (line: string, anchor: string): number => {
+      const idx = line.indexOf(anchor)
+
+      return idx < 0 ? -1 : stringWidth(line.slice(0, idx))
+    }
+
+    const headerCol2 = lines.map(l => colStarts(l, 'Config')).find(v => v >= 0)
+    const denseCol2 = lines.map(l => colStarts(l, 'dense')).find(v => v >= 0)
+    const chatCol2 = lines.map(l => colStarts(l, 'chat')).find(v => v >= 0)
+    const qwenCol2 = lines.map(l => colStarts(l, 'qwen')).find(v => v >= 0)
+
+    expect(headerCol2).toBeDefined()
+    expect(denseCol2).toBe(headerCol2)
+    expect(chatCol2).toBe(headerCol2)
+    // The CJK row is the one that drifted before the fix.  It must
+    // align with the rest now.
+    expect(qwenCol2).toBe(headerCol2)
+  })
+})

package/src/__tests__/mathUnicode.test.ts

@@ -0,0 +1,293 @@
+import { describe, expect, it } from 'vitest'
+
+import { BOX_CLOSE, BOX_OPEN, BOX_RE, texToUnicode } from '../lib/mathUnicode.js'
+
+const stripBox = (s: string) => s.replace(BOX_RE, '$1')
+
+describe('texToUnicode — symbols', () => {
+  it('substitutes lowercase Greek', () => {
+    expect(texToUnicode('\\alpha + \\beta + \\pi')).toBe('α + β + π')
+    expect(texToUnicode('\\omega')).toBe('ω')
+  })
+
+  it('substitutes uppercase Greek', () => {
+    expect(texToUnicode('\\Sigma \\Omega \\Pi')).toBe('Σ Ω Π')
+  })
+
+  it('substitutes set theory and logic operators', () => {
+    expect(texToUnicode('A \\cup B \\cap C')).toBe('A ∪ B ∩ C')
+    expect(texToUnicode('\\forall x \\in \\emptyset')).toBe('∀ x ∈ ∅')
+    expect(texToUnicode('p \\implies q \\iff r')).toBe('p ⟹ q ⟺ r')
+  })
+
+  it('substitutes relations and arrows', () => {
+    expect(texToUnicode('a \\le b \\ge c \\ne d')).toBe('a ≤ b ≥ c ≠ d')
+    expect(texToUnicode('f: A \\to B')).toBe('f: A → B')
+  })
+
+  it('uses longest-match-first so \\leq beats \\le', () => {
+    expect(texToUnicode('\\leq')).toBe('≤')
+  })
+
+  it('preserves unknown commands that share a prefix with known ones', () => {
+    // `\leqq` is a real LaTeX command (≦) we don't have in our table.
+    // The word-boundary lookahead prevents `\le` from matching, so the
+    // whole thing is preserved verbatim — much better than `≤qq`.
+    expect(texToUnicode('\\leqq')).toBe('\\leqq')
+  })
+
+  it('refuses to substitute a partial command (word boundary)', () => {
+    expect(texToUnicode('\\alphabet')).toBe('\\alphabet')
+    expect(texToUnicode('\\pin')).toBe('\\pin')
+  })
+})
+
+describe('texToUnicode — blackboard / calligraphic / fraktur', () => {
+  it('renders \\mathbb capitals', () => {
+    expect(texToUnicode('\\mathbb{R}')).toBe('ℝ')
+    expect(texToUnicode('\\mathbb{N} \\subset \\mathbb{Z} \\subset \\mathbb{Q} \\subset \\mathbb{R}')).toBe('ℕ ⊂ ℤ ⊂ ℚ ⊂ ℝ')
+  })
+
+  it('renders \\mathcal and \\mathfrak', () => {
+    expect(texToUnicode('\\mathcal{F} \\subset \\mathfrak{A}')).toBe('ℱ ⊂ 𝔄')
+  })
+
+  it('preserves \\mathbb{...} when argument is multi-letter or non-letter', () => {
+    expect(texToUnicode('\\mathbb{NN}')).toBe('\\mathbb{NN}')
+    expect(texToUnicode('\\mathbb{1}')).toBe('\\mathbb{1}')
+  })
+
+  it('strips \\mathbf / \\mathit / \\mathrm / \\text wrappers (no Unicode bold/italic in monospace)', () => {
+    expect(texToUnicode('\\mathbf{x}')).toBe('x')
+    expect(texToUnicode('\\text{if } x > 0')).toBe('if  x > 0')
+    expect(texToUnicode('\\operatorname{rank}(A)')).toBe('rank(A)')
+  })
+})
+
+describe('texToUnicode — sub / superscripts', () => {
+  it('converts simple superscripts', () => {
+    expect(texToUnicode('x^2 + y^2')).toBe('x² + y²')
+    expect(texToUnicode('e^{n}')).toBe('eⁿ')
+  })
+
+  it('converts simple subscripts', () => {
+    expect(texToUnicode('a_1 + a_2 + a_n')).toBe('a₁ + a₂ + aₙ')
+    expect(texToUnicode('x_{0}')).toBe('x₀')
+  })
+
+  it('converts mixed-content scripts when every glyph has a Unicode form', () => {
+    // `+`, digits, and lowercase letters all have superscript glyphs,
+    // so `n+1` → `ⁿ⁺¹`. Comma has no subscript form, so `i,j` falls
+    // back to `_(i,j)` (parens) rather than partially substituting —
+    // parens read as ordinary grouping while braces look like leftover
+    // unrendered LaTeX.
+    expect(texToUnicode('x^{n+1}')).toBe('xⁿ⁺¹')
+    expect(texToUnicode('a_{i,j}')).toBe('a_(i,j)')
+  })
+
+  it('uses parens (not braces) when the body has Greek with no superscript form', () => {
+    // π has no Unicode superscript, so `e^{i\pi}` after symbol pass is
+    // `e^{iπ}` and the script fallback emits `e^(iπ)` — much more
+    // readable than the LaTeX-looking `e^{iπ}`.
+    expect(texToUnicode('e^{i\\pi}')).toBe('e^(iπ)')
+  })
+
+  it('strips braces on script fallback when body collapses to a single char', () => {
+    // `^{\infty}` → symbol pass produces `^{∞}` → convertScript can't
+    // find ∞ in SUPERSCRIPT, but the body is one char so we drop the
+    // braces and emit `^∞` (much more readable than `^{∞}`).
+    expect(texToUnicode('e^{\\infty}')).toBe('e^∞')
+  })
+
+  it('handles a real-world sum', () => {
+    expect(texToUnicode('\\sum_{n=0}^{\\infty} \\frac{1}{n!}')).toBe('∑ₙ₌₀^∞ 1/n!')
+  })
+})
+
+describe('texToUnicode — fractions', () => {
+  it('collapses \\frac to a/b', () => {
+    expect(texToUnicode('\\frac{1}{2}')).toBe('1/2')
+    expect(texToUnicode('\\frac{a}{b}')).toBe('a/b')
+  })
+
+  it('parenthesises multi-token numerator / denominator', () => {
+    expect(texToUnicode('\\frac{n+1}{2}')).toBe('(n+1)/2')
+    expect(texToUnicode('\\frac{a + b}{c - d}')).toBe('(a + b)/(c - d)')
+  })
+
+  it('handles nested fractions', () => {
+    expect(texToUnicode('\\frac{1}{\\frac{1}{x}}')).toBe('1/(1/x)')
+  })
+
+  it('handles braces inside numerator / denominator (regression: regex \\frac couldn\'t)', () => {
+    // The regex-only `\frac` matcher used `[^{}]*` for each arg, which
+    // failed the moment a numerator contained its own braces (here the
+    // `{p-1}` from a superscript). The balanced-brace parser handles it.
+    expect(texToUnicode('\\frac{|t|^{p-1}|P(t)|^p}{(p-1)!}')).toBe('(|t|ᵖ⁻¹|P(t)|ᵖ)/((p-1)!)')
+  })
+
+  it('preserves \\frac when arguments are malformed', () => {
+    expect(texToUnicode('\\frac{a}')).toBe('\\frac{a}')
+    expect(texToUnicode('\\fraction{a}{b}')).toBe('\\fraction{a}{b}')
+  })
+})
+
+describe('texToUnicode — typography no-ops', () => {
+  it('strips \\displaystyle / \\textstyle / \\scriptstyle / \\scriptscriptstyle', () => {
+    expect(texToUnicode('\\displaystyle\\sum_{i=1}^n x_i')).toBe('∑ᵢ₌₁ⁿ xᵢ')
+    expect(texToUnicode('f(x) = \\displaystyle \\frac{1}{2}')).toBe('f(x) = 1/2')
+    expect(texToUnicode('\\textstyle x + y')).toBe('x + y')
+  })
+
+  it('strips \\limits / \\nolimits which only affect bound positioning', () => {
+    expect(texToUnicode('\\sum\\limits_{k=1}^n a_k')).toBe('∑ₖ₌₁ⁿ aₖ')
+    expect(texToUnicode('\\int\\nolimits_0^1 f(x) dx')).toBe('∫₀¹ f(x) dx')
+  })
+
+  it('does not eat letter-continuation commands like \\limit_inf', () => {
+    // The `(?![A-Za-z])` lookahead protects hypothetical commands that
+    // start with `\limit` / `\display` / etc. The bare names are stripped
+    // but anything longer is preserved verbatim.
+    expect(texToUnicode('\\limitinf x')).toBe('\\limitinf x')
+  })
+})
+
+describe('texToUnicode — sizing wrappers', () => {
+  it('strips \\big / \\Big / \\bigg / \\Bigg before delimiters', () => {
+    expect(texToUnicode('\\bigl[ x \\bigr]')).toBe('[ x ]')
+    expect(texToUnicode('\\Big( y \\Big)')).toBe('( y )')
+    expect(texToUnicode('\\bigg| z \\bigg|')).toBe('| z |')
+    expect(texToUnicode('\\Biggl\\{ a \\Biggr\\}')).toBe('{ a }')
+  })
+
+  it('does not eat \\bigtriangleup or other letter-continuations', () => {
+    expect(texToUnicode('A \\bigtriangleup B')).toBe('A \\bigtriangleup B')
+  })
+})
+
+describe('texToUnicode — modular arithmetic and tags', () => {
+  it('renders \\pmod{p} as " (mod p)"', () => {
+    expect(texToUnicode('a \\equiv b \\pmod{p}')).toBe('a ≡ b (mod p)')
+  })
+
+  it('renders \\bmod / \\mod inline', () => {
+    expect(texToUnicode('a \\bmod n')).toBe('a mod n')
+  })
+
+  it('collapses \\tag{n} to " (n)"', () => {
+    expect(texToUnicode('x = y \\tag{24}')).toBe('x = y (24)')
+  })
+})
+
+describe('texToUnicode — newly added symbols', () => {
+  it('renders \\nmid, \\blacksquare, \\qed', () => {
+    expect(texToUnicode('p \\nmid q')).toBe('p ∤ q')
+    expect(texToUnicode('Therefore \\blacksquare')).toBe('Therefore ■')
+    expect(texToUnicode('done \\qed')).toBe('done ∎')
+  })
+})
+
+describe('texToUnicode — \\boxed / \\fbox', () => {
+  // `\boxed` produces non-printable U+0001 / U+0002 sentinels around its
+  // content so the markdown renderer can apply highlight styling. These
+  // tests assert both the sentinel form and the human-readable
+  // strip-fallback (BOX_RE).
+  it('wraps simple boxed content in BOX_OPEN/BOX_CLOSE sentinels', () => {
+    expect(texToUnicode('\\boxed{x = 0}')).toBe(`${BOX_OPEN}x = 0${BOX_CLOSE}`)
+    expect(stripBox(texToUnicode('\\boxed{x = 0}'))).toBe('x = 0')
+    expect(stripBox(texToUnicode('\\fbox{answer}'))).toBe('answer')
+  })
+
+  it('handles boxed expressions with nested braces (regression: regex couldn\'t)', () => {
+    // A `[^{}]*` regex would stop at the first `{` inside the body. The
+    // balanced-brace parser walks past it.
+    expect(stripBox(texToUnicode('\\boxed{x^{n+1}}'))).toBe('xⁿ⁺¹')
+    expect(stripBox(texToUnicode('\\boxed{\\frac{a}{b}}'))).toBe('a/b')
+  })
+
+  it('handles real-world boxed final answer', () => {
+    expect(stripBox(texToUnicode('\\boxed{J = -\\sum_{k=0}^n a_k F(k)}'))).toBe('J = -∑ₖ₌₀ⁿ aₖ F(k)')
+  })
+
+  it('preserves \\boxed without a brace argument', () => {
+    expect(texToUnicode('\\boxed something')).toBe('\\boxed something')
+  })
+})
+
+describe('texToUnicode — combining marks', () => {
+  it('applies \\overline / \\bar / \\hat / \\vec / \\tilde', () => {
+    expect(texToUnicode('\\overline{x}')).toBe('x\u0305')
+    expect(texToUnicode('\\hat{y}')).toBe('y\u0302')
+    expect(texToUnicode('\\vec{v}')).toBe('v\u20D7')
+  })
+})
+
+describe('texToUnicode — left/right delimiters', () => {
+  it('strips \\left and \\right keeping the delimiter character', () => {
+    expect(texToUnicode('\\left( x + y \\right)')).toBe('( x + y )')
+    expect(texToUnicode('\\left| x \\right|')).toBe('| x |')
+  })
+
+  it('handles escaped delimiters \\left\\{ ... \\right\\}', () => {
+    expect(texToUnicode('\\left\\{p/q \\mid q \\neq 0\\right\\}')).toBe('{p/q ∣ q ≠ 0}')
+  })
+
+  it('handles named delimiters via \\left\\langle / \\right\\rangle', () => {
+    expect(texToUnicode('\\left\\langle u, v \\right\\rangle')).toBe('⟨ u, v ⟩')
+  })
+
+  it('drops \\left. and \\right. (which are explicit "no delimiter")', () => {
+    expect(texToUnicode('\\left. f \\right|')).toBe(' f |')
+  })
+
+  it('preserves \\leftarrow / \\rightarrow (word boundary blocks the strip)', () => {
+    expect(texToUnicode('A \\leftarrow B \\rightarrow C')).toBe('A ← B → C')
+  })
+})
+
+describe('texToUnicode — labelled arrows', () => {
+  it('renders \\xrightarrow{label} as ─label→', () => {
+    expect(texToUnicode('a \\xrightarrow{x=1} b')).toBe('a ─x=1→ b')
+  })
+
+  it('renders \\xleftarrow{label} as ←label─', () => {
+    expect(texToUnicode('a \\xleftarrow{n} b')).toBe('a ←n─ b')
+  })
+
+  it('still applies symbol substitution inside the label', () => {
+    expect(texToUnicode('a \\xrightarrow{n \\to \\infty} L')).toBe('a ─n → ∞→ L')
+  })
+})
+
+describe('texToUnicode — punctuation commands without lookahead', () => {
+  it('substitutes \\{ even when immediately followed by a letter', () => {
+    // Regression: with a global `(?![A-Za-z])` lookahead, `\{p` refused
+    // to substitute (because `p` is a letter) and rendered as `\{p`.
+    expect(texToUnicode('\\{p, q\\}')).toBe('{p, q}')
+  })
+
+  it('substitutes thin-space \\, before a letter', () => {
+    expect(texToUnicode('a\\,b')).toBe('a b')
+  })
+})
+
+describe('texToUnicode — round-trip realism', () => {
+  it('renders a typical model-emitted formula', () => {
+    expect(texToUnicode('\\alpha \\in \\mathbb{R}, \\alpha \\notin \\mathbb{Q}')).toBe('α ∈ ℝ, α ∉ ℚ')
+  })
+
+  it('preserves unknown commands verbatim', () => {
+    expect(texToUnicode('\\bigtriangleup \\circledast')).toBe('\\bigtriangleup \\circledast')
+  })
+
+  it('handles commands without delimiters between', () => {
+    // Word-boundary lookahead means `\alpha\beta` doesn't accidentally
+    // match `\alphabeta` as one ungrouped token.
+    expect(texToUnicode('\\alpha\\beta')).toBe('αβ')
+  })
+
+  it('leaves plain text alone', () => {
+    expect(texToUnicode('hello world')).toBe('hello world')
+    expect(texToUnicode('')).toBe('')
+  })
+})