feat(preview): canonicalize single-line $$x$$ alone-on-line to block math

User-observed bug: pasting \`$$ E = mc^2 $$\` (compact, single line)
rendered as inline display math — no \`.katex-display\` node, so the
Math-align toggle had nothing to act on. The user reasonably thought
the toggle was broken when actually the input never crossed the
block-math threshold.

Fix
---
Extend canonicalizeBlockMath's rewriteMath to detect "alone on its
own line" — preceded by start-of-input / \`\n\` (allowing trailing
spaces) AND followed by \`\n\` / end-of-input. When that holds, the
single-line \`$$x$$\` is rewritten to canonical block form
(\`\n\n$$\nx\n$$\n\n\`) just like the existing multi-line and
\`\\begin{env}\` cases.

Mid-line \`text $$x$$ text\` is left alone — that's legitimate inline
display usage. The new condition only kicks in when the user clearly
meant "this fragment is a math block."

Two new unit tests pin the new behavior (alone-on-line + start-of-input)
and the existing mid-line test was clarified. 130 / 130 tests pass.

Combined with the existing \`\\[ \\]\` → \`$$ $$\` translation in
normalize-latex-delimiters, compact LLM shapes like
\`\\[E = mc^2\\]\` on a single line now also become block math.

Co-Authored-By: Claude Opus 4.7 <noreply@anthropic.com>

Author: jay20012024

src/lib/__tests__/canonicalize-block-math.test.ts

@@ -56,13 +56,34 @@ $$`;
     expect(math[0].value).toBe('a + b\n= c');
   });
 
-  it('leaves single-line $$x$$ without an environment alone', () => {
-    // This is "inline display" math; remark-math doesn't parse it as a
-    // math node anyway, but we should not corrupt the source either.
+  it('leaves single-line $$x$$ mid-line alone (inline display)', () => {
+    // Mid-line $$x$$ is "inline display" math. remark-math doesn't
+    // parse it as a block math node, but we shouldn't corrupt the
+    // source either — the user might want literal $$ in prose.
     const src = `before $$E = mc^2$$ after`;
     expect(canonicalizeBlockMath(src)).toBe(src);
   });
 
+  it('rewrites single-line $$x$$ alone on a line to block form', () => {
+    // The common LLM / user-paste shape. remark-math would otherwise
+    // miss it (single-line $$x$$ stays inline), so .katex-display
+    // never gets emitted and math-align has nothing to act on.
+    const src = `text before\n$$ E = mc^2 $$\ntext after`;
+    const out = canonicalizeBlockMath(src);
+    expect(out).toMatch(/\n\$\$\nE = mc\^2\n\$\$\n/);
+    const math = parseToMath(out);
+    expect(math).toHaveLength(1);
+    expect(math[0].value).toBe('E = mc^2');
+  });
+
+  it('rewrites single-line $$x$$ at start of input', () => {
+    const src = `$$E = mc^2$$\nafter`;
+    const out = canonicalizeBlockMath(src);
+    const math = parseToMath(out);
+    expect(math).toHaveLength(1);
+    expect(math[0].value).toBe('E = mc^2');
+  });
+
   it('leaves inline $x$ math untouched', () => {
     const src = `inline $E = mc^2$ here`;
     expect(canonicalizeBlockMath(src)).toBe(src);

src/lib/canonicalize-block-math.ts

@@ -104,12 +104,27 @@ const BLOCK_MATH_PAIR = /\$\$([\s\S]+?)\$\$/g;
 const HAS_ENV = /\\(?:begin|end)\{/;
 
 function rewriteMath(segment: string): string {
-  return segment.replace(BLOCK_MATH_PAIR, (full, inner: string) => {
+  return segment.replace(BLOCK_MATH_PAIR, (full, inner: string, offset: number) => {
     const hasNewline = inner.includes('\n');
     const hasEnv = HAS_ENV.test(inner);
-    if (!hasNewline && !hasEnv) {
-      // Single-line, no env — leave as-is. May be inline display, which
-      // is its own quirk but not what this preprocessor is for.
+
+    // "Alone on its own line" — preceded by start-of-segment or `\n`
+    // (allowing trailing spaces in between), and followed by `\n` or
+    // end-of-segment. This is what the user intends when they paste
+    // `$$ E = mc^2 $$` on a line by itself — remark-math otherwise
+    // treats compact `$$x$$` as inline display, no `.katex-display`
+    // gets emitted, and our math-align toggle has nothing to act on.
+    //
+    // We only normalize the alone-on-line case so legitimate inline
+    // uses like `prefix text $$x$$ suffix text` stay unchanged.
+    const beforeText = segment.slice(0, offset);
+    const afterText = segment.slice(offset + full.length);
+    const aloneOnLine = /(^|\n)[ \t]*$/.test(beforeText) && /^[ \t]*(\n|$)/.test(afterText);
+
+    if (!hasNewline && !hasEnv && !aloneOnLine) {
+      // Mid-line, single-line `$$x$$` — leave as-is. Treated as inline
+      // display by remark-math (which is its own quirk, but not the
+      // preprocessor's job).
       return full;
     }
     // Strip whitespace at the boundaries; remark-math is whitespace-strict