Still interested in this fix — inline math rendering breakage is a recurring complaint. Two things before it can land: the branch conflicts with current main-v2 (a lot merged today, including streaming-markdown work in the same area), and the lint job is failing. Please rebase and fix lint; once green I'll review promptly.

Posting the technical specifics now so the rebase round can address everything at once:

1. The $ escape/unescape pair is a no-op as written — protected segments are stored out-of-band and swapped back wholesale, so the escape never matters… except code that legitimately contains the literal text $ gets rewritten to $ on restore (corruption). Delete the dance; the PR description also claims restore does not unescape, which is stale vs the code.
2. Step 5's greedy→non-greedy change does nothing — the char class already excludes $, so the match extent is identical — and its comment describes behavior it doesn't have. Drop both.
3. Mid-line fence detection diverges from CommonMark: prose like "wrap code in blocks" now swallows everything to the next fence/EOF and kills math for the rest of the message, while remark itself won't treat it as code. Restrict to line-start fences or justify the divergence.
4. Verify % survives inside math ($100%$) — KaTeX treats % as a comment char, so unescaped it silently truncates the formula.
5. Comment policy: several 8–12 line essays (one in mathNormalize.ts describes code that no longer exists) and // was: … history notes in tests need to go; also the "\mathbf" test string's backslash isn't escaped, so the test actually exercises mathbf.

Thanks for the detailed review — much clearer than the parenthesised bullet list. Rebased onto current main-v2 (7 commits, single squashed fix commit on top) and addressed all five points:

1. $ escape/unescape dance — dropped. pushSegment no longer touches $, and the restore loop just swaps the segment back wholesale. The header comment is also updated (it claimed restore did not unescape, which didn't match the code). Confirmed that no test relied on the literal $ round-trip.

2. Step 5's +? non-greedy change — dropped. Reverted the regex to + and removed the comment that claimed the change prevents cross-pair matching. Kept the return _m behaviour for non-math pairs (so currency dollars stay visible), with a comment that actually describes what it does.

3. Fence detection — restricted to line-start. Restored if (start !== 0 && s[start - 1] !== "\n") return -1; in fencedCodeEnd. The single-line "next matching fence is the closer" path is still there for malformed one-line docs, but only reachable when the doc has no newlines, so the prose-swallowing regression is gone.

4. % inside math — verified and fixed. Confirmed that $x = 50%$ was indeed silently truncated to x = 50 by KaTeX (with a commentAtEnd warning). Added a top-level case in latexNormalizeForKatex that emits \%; already-escaped \% is handled by the existing 2-char command branch above, so no double-escape. New tests cover $x = 50%$, $100%$, $a%b$, and $10\%$.

5. Comment policy — trimmed. Removed both // was: … notes in the tests, plus the 8-12 line essays in mathNormalize and mathClassify that described code that no longer exists or that the reader can see from the regex. The header still lists the pipeline as a map.

The \mathbf test string is actually \\mathbf{6} (the JS escape is a backslash — verified the runtime string is \mathbf{6} and the assertion checks for \mathbf{6} in the output), so it does test \mathbf rendering through KaTeX. Left it as is.

All 128 math-golden tests + 73 tests across the rest of the frontend suite pass, typecheck clean, and CI is green across ubuntu/macos/windows (including the lint job that was failing before). The branch is now mergeable.

Description updated to reflect the current state of the branch (9 commits, post-review feedback pass + unary +/- + the new comma case).

Key changes from the previous description:

• Removed the stale claim that "restoration does NOT unescape $ back to $" — the $ round-trip was dropped entirely in the review pass.
• Removed the misleading "non-greedy regex prevents cross-pair matching" claim — the +? change was dropped too.
• Added the top-level % escape in latexNormalizeForKatex ($x = 50%$ → $x = 50%$), which was added in the review-feedback commit.
• Added the new comma case (closing $$ after a comma on the same line as content), pinned by a regression test next to the existing closing-bracket test.
• Cumulative changelog at the bottom lists all 9 commits in order, with one-line summaries of what each one actually does (instead of just the original 8).

Also folded the +2, -x unary-plus/minus case into the body of "What this PR fixes" rather than burying it in a separate commit message.

The maintainer's review comments (5 specific issues, all addressed in commit 8c477b5) are now accurately reflected in the body — the old description still claimed the $ round-trip existed, and the +? non-greedy change, which were both dropped.

Here's the exact fix for the step-6 blocker, verified locally — applying this and I'll merge.

The substantive change is one line: step 6's non-math branch goes back to wrapping in $ entities (what step 5 already does) instead of returning the literal $…$. The rest is the test updates — flipping the two golden assertions that were pinning the literal form, and a new render-level section that goes through the real react-markdown + remark-math + rehype-katex path so this can't silently regress again.

I ran the full math-golden suite with this applied: 132 passed, 0 failed, including the three new boundary tests (which fail on the current return _m):

normalizeMath → remark-math render boundary
  PASS  currency '$5 and $6' renders as literal dollars, not math
  PASS  env var $PATH$ renders as literal, not math
  PASS  real inline math $x^2$ still renders as KaTeX

diff --git a/desktop/frontend/src/components/mathNormalize.ts b/desktop/frontend/src/components/mathNormalize.ts
--- a/desktop/frontend/src/components/mathNormalize.ts
+++ b/desktop/frontend/src/components/mathNormalize.ts
@@ -8,7 +8,7 @@
 //   4. Inline `$$` glued to prose gets a blank line inserted before it
 //      (CommonMark requires that block math be paragraph-separated).
 //   5. $$…$$ → display placeholders, $…$ → inline placeholders, gated by
-//      isLikelyInlineMath so currency / env-var tokens pass through.
+//      isLikelyInlineMath; currency / env-var tokens become $ entities.
 //   6. Each recognised math source is run through latexNormalizeForKatex
 //      (text-mode escapes, |→\vert, %→\%).
@@ -81,11 +77,12 @@ function normalizeMathText(s: string): string {
     return `${IM}${latexNormalizeForKatex(m)}${IM}`;
   });
 
-  // Step 6: remaining $…$ → classifier-gated inline math. Non-math
-  // pairs (e.g. currency like "$5 and $6") are left unchanged so the
-  // dollars remain visible; remark-math will not try to parse them.
+  // Step 6: remaining $…$ → classifier-gated inline math. remark-math
+  // parses any literal $…$ it sees, so non-math pairs (currency $5,
+  // env vars $PATH$) are wrapped in $ entities — remark-math never
+  // sees a $, and the decoded entity still renders as a literal dollar.
   r = r.replace(/\$([^$\n]+)\$/g, (_m, m) => {
-    if (!isLikelyInlineMath(m.trim())) return _m;
+    if (!isLikelyInlineMath(m.trim())) return `${DOLLAR}${m}${DOLLAR}`;
     return `${IM}${latexNormalizeForKatex(m)}${IM}`;
   });
diff --git a/desktop/frontend/src/__tests__/math-golden.test.ts b/desktop/frontend/src/__tests__/math-golden.test.ts
--- a/desktop/frontend/src/__tests__/math-golden.test.ts
+++ b/desktop/frontend/src/__tests__/math-golden.test.ts
@@ -6,6 +6,12 @@
 // mathClassify) rather than reimplementing them inline, so this file
 // catches regressions in the actual code path that runs inside <Markdown>.
 
+import { createElement } from "react";
+import { renderToStaticMarkup } from "react-dom/server";
+import ReactMarkdown from "react-markdown";
+import remarkGfm from "remark-gfm";
+import remarkMath from "remark-math";
+import rehypeKatex from "rehype-katex";
 import katex from "katex";
 import { latexNormalizeForKatex, stripMathDelimiters } from "../components/latexNormalize";
 import { isLikelyInlineMath } from "../components/mathClassify";
@@ -238,12 +238,12 @@ console.log("\nnormalizeMath — non-math dollar filtering");
 eq(normalizeMath("costs $1$ today"), "costs $1$ today", "$1$ is math (single-digit index)");
-eq(normalizeMath("env $PATH$ here"), "env $PATH$ here", "$PATH$ not math (env var, dollars preserved)");
+eq(normalizeMath("env $PATH$ here"), "env &#36;PATH&#36; here", "$PATH$ not math (env var → &#36; entities so remark-math leaves it literal)");
 eq(normalizeMath("solve $x^2 + y^2 = z^2$ please"), "solve $x^2 + y^2 = z^2$ please", "$x^2+y^2$ is math");
 eq(normalizeMath("$\\alpha + \\beta$"), "$\\alpha + \\beta$", "$\\alpha+\\beta$ is math");
 eq(normalizeMath("price is $10.50$ each"), "price is $10.50$ each", "$10.50$ is math (decimal number)");
 eq(normalizeMath("$I$ think"), "$I$ think", "$I$ is math (uppercase single letter)");
-eq(normalizeMath("it costs $5 and $10 total"), "it costs $5 and $10 total", "multiple prose $ stays literal (dollars preserved)");
+eq(normalizeMath("it costs $5 and $10 total"), "it costs &#36;5 and &#36;10 total", "multiple prose $ → &#36; entities (dollars preserved, not parsed as math)");
@@ -358,9 +358,6 @@ console.log("\nnormalizeMath — non-math inputs pass through");
 type Passthrough = { src: string; expected: string; label: string };
 const passthrough: Passthrough[] = [
-  // $5$ is filtered to dollar entities so remark-math leaves it literal
-  // and the rendered prose still shows normal dollar signs.
-  // (the previous "costs $5$ today" passthrough case is now a no-op — single-digit $N$ is math)
   { src: "costs $100$ today", expected: "costs $100$ today", label: "multi-digit number is math" },
   { src: "line break \\\\[4pt] here", expected: "line break \\\\[4pt] here", label: "LaTeX line-break spacing" },
   { src: "hello world", expected: "hello world", label: "plain text" },
@@ -366,6 +366,38 @@ for (const { src, expected, label } of passthrough) {
   check(`${label}: ${src}`, () => normalizeMath(src) === expected);
 }
 
+// ── remark-math render boundary ────────────────────────────────────────────────
+// A literal $…$ in normalizeMath output is NOT enough to keep a non-math token
+// out of KaTeX: remark-math parses any $…$ it sees, so the classifier's reject
+// verdict only holds when the $ is hidden as a &#36; entity. These render through
+// the real react-markdown + remark-math + rehype-katex path; the normalizeMath-only
+// golden cases above never cross the prose→parser boundary.
+
+console.log("\nnormalizeMath → remark-math render boundary");
+
+function renderHtml(src: string): string {
+  return renderToStaticMarkup(
+    createElement(ReactMarkdown, {
+      remarkPlugins: [remarkGfm, remarkMath],
+      rehypePlugins: [rehypeKatex],
+      children: normalizeMath(src),
+    }),
+  );
+}
+
+check("currency '$5 and $6' renders as literal dollars, not math", () => {
+  const html = renderHtml("These two apples cost $5 and $6");
+  return !html.includes("katex") && html.includes("$5") && html.includes("$6");
+});
+check("env var $PATH$ renders as literal, not math", () => {
+  const html = renderHtml("env $PATH$ here");
+  return !html.includes("katex") && html.includes("$PATH$");
+});
+check("real inline math $x^2$ still renders as KaTeX", () => {
+  const html = renderHtml("the value $x^2$ here");
+  return html.includes("katex");
+});
+
 // ── Summary ───────────────────────────────────────────────────────────────────

One thing to double-check on your side: the new test imports react-dom/server, react-markdown, remark-gfm, remark-math, rehype-katex — all already in desktop/frontend, so pnpm test picks them up with no dependency change. Ping me when it's pushed and I'll merge.

Done — your step-6 patch applied and pushed. 70bcb8a6 is the new tip.

mathNormalize.ts step 6 now returns `${DOLLAR}${m}${DOLLAR}` for non-math pairs, the file-header comment is updated to match, the two eq assertions for $PATH$ and $5 and $10 are flipped to expect the entity form, the stale $5$ passthrough comment is dropped, and the new render-boundary section runs the real react-markdown + remark-math + rehype-katex path on the three boundary cases (currency, env var, real inline math).

Local results: 132 passed, 0 failed in math-golden.test.ts (was 129; +3 new boundary tests), and all 12 frontend test files green. The three new boundary tests fail on the previous return _m and pass on the new entity form, which is what makes this a real regression net rather than a tautology.

Display math regression fix added

Investigation of a user-reported bug ("math formulas don't render") traced the root cause to the $$ repair regex in mathNormalize.ts Step 3 (introduced in this PR, commit 45482b20, extended in 0fbb9086).

The bug: The regex ([A-Za-z\)\]\>\.。！？,{}])\$\$ was designed to repair opening $$ glued to prose, but it also matched the closing $$ of well-formed $$…$$ display pairs. Every display equation ending in }, ), or , had its closing delimiter split off (}$$ → }\n\n$$), which caused remark-math to parse an empty display block ($$\n\n$$) and leak the equation body as prose.

Symptoms:

• Display equations rendered as blank space (empty KaTeX blocks)
• Inline math showed doubled text on copy-paste (MathML layer + leaked prose)
• User-visible: the proton SU(6) wave function and all $$…$$ equations vanished

The fix (commit d450aec1):

1. Extract $$…$$ pairs as a unit before the repair regex runs, so the closing $$ is never touched
2. When the opening $$ is glued to preceding prose (the original intent), insert \n\n before the extracted pair only
3. Restore display delimiters with newlines ($$\n…\n$$) for remark-math block-math recognition

All 168 golden tests pass. The 15 ket/array tests require PR #4320 (latexNormalize.ts fixes) which is independent.

Two follow-up commits pushed — test suite now fully green

While testing the branch I found that d450aec1 ("repair display math regression") shipped its tests for the array-column-spec and ket-pipe cases but not the latexNormalize.ts implementation they depend on — that implementation lives in a separate commit (2756e7f0 on dev-new-features) that wasn't carried over to this branch. Net result: 15 array/ket tests were red on the PR branch (not from any review-blocking issue, just an incomplete cherry-pick). Pushed two commits to fix that, plus an adjacent gap I hit while testing:

2b090416 — correct pipe handling for array column specs and kets

Brings in the latexNormalize.ts logic that d450aec1's tests were already asserting:

• \begin{array}{c|c} (and tabular) column specs are now copied verbatim — the | means "draw a vertical rule" and must not become \vert. Previously this raised KaTeX "Unknown column alignment: \vert".
• \|uud\rangle ket openers and \langle\psi\| bra closers convert \| → \vert (single bar), while matched \|x\| norms are preserved as the double bar. Kets were rendering as ‖ψ⟩ (parallel-to) instead of |ψ⟩.

Touches only latexNormalize.ts (+229/−1).

eb029d5e — render multi-letter group notation like SO(3,1) as inline math

The classifier's function-call rule only accepted a single letter before the parentheses (f(x), g(x)), so multi-letter group notation — $SO(3,1)$, $SU(2)$, $SL(2)$, $GL(n)$, $Sp(2n)$, $Spin(n)$, $Diff(M)$ — fell through to the prose fallback and rendered as literal $ instead of math. Broadened the identifier to 1–6 letters (in-scope for this PR's classifier work). +9 regression tests.

Test status

The bridge.ts typecheck error is the one noted in the PR description as pre-existing on the branch tip without this PR.

The rebase onto current main-v2 is the only remaining item from your last review note — happy to do that next if helpful.

One more inline-math case: \tfrac12, \sqrt2, \log3 — follow-up fix

While re-reading my own rendered answer I spotted that $\tfrac12$ (and the whole family of a LaTeX command immediately followed by a digit) was rendering as literal $ instead of math.

Root cause: the classifier's backslash-command rule had a \b after the command name:

if (/\\[A-Za-z]+\b/.test(math)) return true;

\b is a word boundary, but \tfrac12 / \frac12 / \sqrt2 / \log3 have no boundary between the name and the trailing digit (c and 1 are both word characters), so the regex rejected them. The fix is to drop the \b — a backslash command is a backslash command regardless of what follows.

-  if (/\\[A-Za-z]+\b/.test(math)) return true;
+  if (/\\[A-Za-z]+/.test(math)) return true;

\alpha, \frac{x}{y}, \cdot 3 (all already passing) are unaffected; the currency / env-var guards further down still catch false-positives. +5 regression tests.

Test status

• math-golden: 182 / 0 (was 177/0)
• typecheck: 0 errors
• branch still rebased on current main-v2

Closing as superseded by #4216.

For this math-rendering area, #4216 is now the retained integration path because it carries the Young diagram/tableau work on top of the same math normalization/rendering surface.

Thank you @lightfront for the substantial inline-math work in this PR. The retained PR includes a contribution note acknowledging #3666 as part of the shared repository contribution behind the final math-rendering track.