fix(desktop): repair inline math rendering for LLM output

[lightfront]

Fix: Inline math rendering for LLM output

Problem

LaTeX source was being rendered as raw text (with red KaTeX errors) in several common scenarios:

1. Block math $$ glued to prose without blank lines
2. Single digits ($1$, $2$) and multi-digit numbers rejected as currency
3. Single uppercase letters ($S$, $A$) rejected as English words
4. One-sided comparisons (< B, A <) not recognized as math
5. $ symbols inside code blocks causing KaTeX parse errors
6. Malformed single-line code blocks not protected
7. Prose currency like "cost $5 and $6" had dollar signs converted to HTML entities

Solution

1. Block math blank-line repair (mathNormalize.ts Step 2.5)

When $$ appears after prose (letter or punctuation) without a blank line, insert \n\n before it. This satisfies CommonMark's requirement that block math be separated from surrounding content.

Example:

# Before (broken)
decomposes as$$
\mathbf{6}\otimes...

# After (fixed)
decomposes as

$$
\mathbf{6}\otimes...

2. Improved math classifier (mathClassify.ts)

Added recognition for common minimal-LaTeX patterns:

Pure numbers and letters:

• $1$, $2$, $42$, $2.5$ → math (counts, indices, values)
• $S$, $A$, $I$ → math (set/algebra/group names)

Number combinations:

• Comma-separated: A, B, 1, 2, 3, (A, B) → math (tuples, pairs)
• With variables: $2.5x$, $3y^2$ → math (implicit multiplication)
• With LaTeX: $10\%$, $5\cdot3$ → math (math operators)

One-sided comparisons:

• < B, <= 0, A <, B <= → math (implicit operand)

Example:

"$1$ 和 $2$ 之间有无穷多有理数" → math (1 and 2)
"$S$ 非空" → math (set S)
"把 $(A, B)$ 整体" → math (ordered pair)
"A 的每个元素 $< B$" → math (comparison)
"$2.5x + 3$" → math (number with variable)

3. Code block $ protection (mathNormalize.ts)

Escape $ to $ inside code blocks and inline code to prevent KaTeX from attempting to parse them as math. The restoration step does NOT unescape $ back to $, keeping the HTML entities in the final output.

Example:

// Input
`r = r.replace(/\$\$/, ...)`

// After normalization
`r = r.replace(/$$/, ...)`

// Final HTML renders as
r = r.replace(/\$\$/, ...)

4. Lenient fenced code detection (mathNormalize.ts)

Removed the requirement that ``` must appear after a newline. Now accepts ``` anywhere in the text, handling malformed code blocks that are all on one line.

5. Single-line code block fix (mathNormalize.ts)

When the entire document is on one line (no newlines), treat ``` as a simple toggle: first occurrence is opening, second is closing. This handles pasted documentation where code blocks are inline.

6. Preserve prose currency (mathNormalize.ts Step 5)

Changed the regex to non-greedy matching and removed HTML entity conversion for non-math pairs. Now "These two apples cost $5 and $6" preserves its dollar signs unchanged instead of converting them to $5 and $6.

Before:

Input:  "These two apples cost $5 and $6"
Output: "These two apples cost $5 and $6"

After:

Input:  "These two apples cost $5 and $6"
Output: "These two apples cost $5 and $6" (unchanged)

Changes

Files modified

1. desktop/frontend/src/components/mathNormalize.ts

   • Added Step 2.5: blank-line insertion before glued $$
   • Modified protectMarkdownCode: escape $ to $ in code segments
   • Modified restoration: do NOT unescape $ back to $
   • Modified fencedCodeEnd: removed newline requirement, added single-line toggle logic
   • Modified Step 5: non-greedy regex, preserve original text for non-math pairs

2. desktop/frontend/src/components/mathClassify.ts

   • Accept all pure numbers (single, multi-digit, decimals, percentages) as math
   • Accept numbers with variables ($2.5x$) or LaTeX ($10\%$) as math
   • Accept comma-separated lists as math
   • Accept one-sided comparisons as math
   • Accept single uppercase letters as math

3. desktop/frontend/src/__tests__/math-golden.test.ts

   • Added "minimal LaTeX patterns (regression)" test section
   • Added tests for single digits, uppercase letters, comma-separated lists, one-sided comparisons
   • Added tests for single-line code blocks with $ symbols
   • Updated currency tests to reflect new behavior (dollars preserved)

Test coverage

• All 122 tests passing (108 + 8 + 6)
• Coverage includes real-world examples from user-reported issues
• Currency handling now preserves dollar signs in prose

Trade-offs and limitations

Orphan $$ (model-side issue)

Problem: Model outputs $$... without closing $$, causing the parser to swallow everything until the next $$.

Why not fixed: Every attempt to rescue orphan $$ from the renderer side made the output worse (whole prose paragraphs wrapped in $…$).

Right fix: Upstream—better LLM prompting or post-generation lint.

Testing

All existing tests pass, plus new regression tests covering:

• Pure numbers: $1$, $42$, $2.5$ → math
• Numbers with variables: $2.5x$ → math
• Numbers with LaTeX: $10\%$ → math
• Comma-separated lists: A, B, (A, B) → math
• One-sided comparisons: < B, A < → math
• Single uppercase letters: $S$, $A$ → math
• Single-line code blocks with $ → protected
• Prose currency: "cost $5 and $6" → dollars preserved

Run tests:

cd desktop/frontend
npm test

Real-world examples

These examples from user reports now render correctly:

### Chinese math text
$1$ 和 $2$ 之间有无穷多有理数
→ Both 1 and 2 render as math

$S$ 非空
→ S renders as math (set name)

把 $(A, B)$ 整体当作一个新对象
→ (A, B) renders as math (ordered pair)

A 的每个元素 $< B$ 的每个元素
→ < B renders as math (comparison)

### Math with numbers
$2.5x + 3$
→ Entire expression renders as math

$10\%$ increase
→ 10\% renders as math

$42$ elements
→ 42 renders as math

### Currency in prose
costs $5 and $6
→ Dollar signs preserved unchanged

costs $5$ today
→ $5$ renders as math (pure number)

price is $10.50$
→ $10.50$ renders as math (decimal)

### Code blocks
```javascript
r = r.replace(/\$\$/, ...);

→ No KaTeX errors, $ symbols protected