diff --git a/desktop-app/resources/js/preview-worker.js b/desktop-app/resources/js/preview-worker.js
index 989b3566..9a81e6d5 100644
--- a/desktop-app/resources/js/preview-worker.js
+++ b/desktop-app/resources/js/preview-worker.js
@@ -25,19 +25,24 @@ const markedOptions = {
 
 const BLOCK_MATH_MARKER_PATTERN = /^\$\$/m;
 const BLOCK_MATH_PATTERN = /^\$\$[ \t]*\n?([\s\S]*?)\n?\$\$[ \t]*(?:\n|$)/;
+const INLINE_MATH_START_PATTERN = /\\(?:\$|\(|\[)|\$/;
 const DEFINITION_LIST_ITEM_PATTERN = /^:[ \t]+(.*)$/;
 const SUPERSCRIPT_PATTERN = /^\^(?!\s)([^^\n]*?\S)\^(?!\^)/;
 const SUBSCRIPT_PATTERN = /^~(?!~)(?!\s)([^~\n]*?\S)~(?!~)/;
 const HIGHLIGHT_PATTERN = /^==(?=\S)([\s\S]*?\S)==/;
-const MARKDOWN_LIST_MARKER_PATTERN = /^(\s*)(?:[-*+]\s+|\d+\.\s+|>\s+)/;
+const MARKDOWN_LIST_MARKER_PATTERN = /^(\s*)(?:[-*+]\s+|\d{1,9}[.)]\s+|>\s*)/;
+const DEFINITION_LIST_DISALLOWED_TERM_PATTERN = /^(?: {4}|\t|[ \t]{0,3}(?:`{3,}|~{3,}|#{1,6}(?:[ \t]+|$)|(?:[*_-][ \t]*){3,}$|[=-]+[ \t]*$|\[[^\]\n]+\]:[ \t]*\S|<!--|<\?|<![A-Z]|<!\[CDATA\[|<\/?[a-zA-Z][\w:-]*(?:\s|>|\/>)))/;
+const GFM_TABLE_DELIMITER_PATTERN = /^[ \t]*\|?[ \t]*:?-+:?[ \t]*(?:\|[ \t]*:?-+:?[ \t]*)+\|?[ \t]*$/;
 const EMPTY_LINE_PATTERN = /^\s*$/;
 
 let suppressFootnotePreprocess = false;
+let preserveExtendedMarkdownState = false;
 const footnoteDefinitions = new Map();
 const footnoteOrder = [];
 const footnoteRefCounts = new Map();
-const footnoteFirstRefId = new Map();
-let anonymousFootnoteCounter = 0;
+const footnoteSlugs = new Map();
+const usedFootnoteSlugs = new Set();
+const usedHeadingIds = new Set();
 
 function escapeHtml(str) {
   return String(str)
@@ -60,19 +65,40 @@ function resetExtendedMarkdownState() {
   footnoteDefinitions.clear();
   footnoteOrder.length = 0;
   footnoteRefCounts.clear();
-  footnoteFirstRefId.clear();
-  anonymousFootnoteCounter = 0;
+  footnoteSlugs.clear();
+  usedFootnoteSlugs.clear();
+  usedHeadingIds.clear();
 }
 
-function normalizeFootnoteId(id) {
-  const normalized = String(id || "")
+function normalizeFootnoteLabel(id) {
+  return String(id || "")
     .trim()
     .toLowerCase()
-    .replace(/[^a-z0-9_-]+/g, "-")
-    .replace(/^-+|-+$/g, "");
-  if (normalized) return normalized;
-  anonymousFootnoteCounter += 1;
-  return `footnote-${anonymousFootnoteCounter}`;
+    .replace(/\s+/g, " ");
+}
+
+function getFootnoteSlug(label) {
+  if (footnoteSlugs.has(label)) return footnoteSlugs.get(label);
+
+  const baseSlug = String(label || "")
+    .replace(/\s+/g, "-")
+    .replace(/[^\p{L}\p{N}\p{M}_-]+/gu, "-")
+    .replace(/-+/g, "-")
+    .replace(/^-+|-+$/g, "") || "footnote";
+  let slug = baseSlug;
+  let suffix = 1;
+  while (usedFootnoteSlugs.has(slug)) {
+    slug = `${baseSlug}-${suffix}`;
+    suffix += 1;
+  }
+  usedFootnoteSlugs.add(slug);
+  footnoteSlugs.set(label, slug);
+  return slug;
+}
+
+function getFootnoteReferenceId(label, referenceNumber) {
+  const slug = getFootnoteSlug(label);
+  return `fnref-${slug}${referenceNumber > 1 ? `-${referenceNumber}` : ""}`;
 }
 
 function parseInlineWithoutFootnotes(text) {
@@ -104,82 +130,206 @@ function renderDefinitionContent(content, options) {
     .join("");
 }
 
-function extractFootnoteDefinitions(markdown) {
-  const lines = markdown.split("\n");
-  const preservedLines = [];
+function renderFootnotesSection() {
+  const footnotesHtml = footnoteOrder
+    .filter((id) => footnoteDefinitions.has(id))
+    .map((id) => {
+      const slug = getFootnoteSlug(id);
+      const referenceCount = footnoteRefCounts.get(id) || 1;
+      const backRefHtml = Array.from({ length: referenceCount }, (_, index) => {
+        const referenceNumber = index + 1;
+        const backRefId = escapeHtmlAttribute(getFootnoteReferenceId(id, referenceNumber));
+        const occurrenceLabel = referenceNumber > 1 ? ` ${referenceNumber}` : "";
+        const occurrenceMarker = referenceNumber > 1 ? `<sup>${referenceNumber}</sup>` : "";
+        return `<a href="#${backRefId}" class="footnote-backref" aria-label="Back to content${occurrenceLabel}">&#8592;${occurrenceMarker}</a>`;
+      }).join(" ");
+      const noteHtml = renderDefinitionContent(footnoteDefinitions.get(id) || "", { appendHtml: backRefHtml });
+      return `<li id="fn-${escapeHtmlAttribute(slug)}">${noteHtml}</li>`;
+    })
+    .join("");
+
+  return footnotesHtml
+    ? `<section class="footnotes"><hr><ol>${footnotesHtml}</ol></section>`
+    : "";
+}
+
+function isEscapedCharacter(source, index) {
+  let backslashCount = 0;
+  for (let cursor = index - 1; cursor >= 0 && source[cursor] === "\\"; cursor -= 1) {
+    backslashCount += 1;
+  }
+  return backslashCount % 2 === 1;
+}
+
+function findClosingMathDelimiter(source, delimiter, startIndex) {
+  for (let index = startIndex; index <= source.length - delimiter.length; index += 1) {
+    if (source[index] === "\n") return -1;
+    if (source.startsWith(delimiter, index) && !isEscapedCharacter(source, index)) return index;
+  }
+  return -1;
+}
+
+function tokenizeDollarMath(source) {
+  if (source.startsWith("$$")) {
+    const closeIndex = findClosingMathDelimiter(source, "$$", 2);
+    if (closeIndex > 2) {
+      return { type: "inlineMath", raw: source.slice(0, closeIndex + 2), display: true };
+    }
+    return null;
+  }
+  if (source[0] !== "$" || !source[1] || /[\s$]/.test(source[1])) return null;
+  for (let index = 1; index < source.length; index += 1) {
+    if (source[index] === "\n") break;
+    if (source[index] !== "$" || isEscapedCharacter(source, index)) continue;
+    if (/\s/.test(source[index - 1]) || /\d/.test(source[index + 1] || "")) return null;
+    return { type: "inlineMath", raw: source.slice(0, index + 1), display: false };
+  }
+  return null;
+}
+
+function readBalancedTexGroup(source, startIndex) {
+  if (source[startIndex] !== "{") return null;
+  let depth = 0;
+  for (let index = startIndex; index < source.length; index += 1) {
+    if (isEscapedCharacter(source, index)) continue;
+    if (source[index] === "{") {
+      depth += 1;
+    } else if (source[index] === "}") {
+      depth -= 1;
+      if (depth === 0) {
+        return { endIndex: index, content: source.slice(startIndex + 1, index) };
+      }
+    }
+  }
+  return null;
+}
+
+function normalizeLegacyMathSyntax(source) {
+  const tex = String(source || "");
+  let normalized = "";
   let index = 0;
 
-  while (index < lines.length) {
-    const match = /^([ \t]{0,3})\[\^([^\]\n]+)\]:[ \t]*(.*)$/.exec(lines[index]);
-    if (!match) {
-      preservedLines.push(lines[index]);
+  while (index < tex.length) {
+    if (tex.startsWith("\\^", index) && !isEscapedCharacter(tex, index)) {
+      normalized += "^";
+      index += 2;
+      continue;
+    }
+
+    if (
+      !tex.startsWith("\\color", index) ||
+      isEscapedCharacter(tex, index) ||
+      /[a-zA-Z]/.test(tex[index + 6] || "")
+    ) {
+      normalized += tex[index];
       index += 1;
       continue;
     }
 
-    const baseIndent = match[1] || "";
-    const id = match[2].trim();
-    const definitionLines = [match[3] || ""];
-    index += 1;
+    let colorGroupStart = index + 6;
+    while (/[ \t]/.test(tex[colorGroupStart] || "")) colorGroupStart += 1;
+    const colorGroup = readBalancedTexGroup(tex, colorGroupStart);
+    if (!colorGroup) {
+      normalized += tex[index];
+      index += 1;
+      continue;
+    }
 
-    while (index < lines.length) {
-      const line = lines[index];
-      if (!line.startsWith(baseIndent)) break;
-      const lineAfterBase = line.slice(baseIndent.length);
-      const indentedMatch = /^(?: {2,}|\t)(.*)$/.exec(lineAfterBase);
-      if (indentedMatch) {
-        definitionLines.push(indentedMatch[1]);
-        index += 1;
-        continue;
-      }
-      if (lineAfterBase.trim() === "") {
-        const nextLine = lines[index + 1] || "";
-        const nextAfterBase = nextLine.startsWith(baseIndent) ? nextLine.slice(baseIndent.length) : "";
-        if (/^(?: {2,}|\t)/.test(nextAfterBase)) {
-          definitionLines.push("");
-          index += 1;
-          continue;
-        }
-      }
-      break;
+    let contentGroupStart = colorGroup.endIndex + 1;
+    while (/[ \t]/.test(tex[contentGroupStart] || "")) contentGroupStart += 1;
+    const contentGroup = readBalancedTexGroup(tex, contentGroupStart);
+    if (!contentGroup) {
+      normalized += tex[index];
+      index += 1;
+      continue;
     }
 
-    footnoteDefinitions.set(id, definitionLines.join("\n").trim());
+    normalized += `{\\color{${colorGroup.content}}${normalizeLegacyMathSyntax(contentGroup.content)}}`;
+    index = contentGroup.endIndex + 1;
   }
 
-  return preservedLines.join("\n");
+  return normalized;
 }
 
-function applyFootnotes(markdown) {
-  const markdownWithReferences = markdown.replace(/\[\^([^\]\n]+)\]/g, function(match, idText) {
-    const id = idText.trim();
-    if (!id) return match;
-    if (!footnoteOrder.includes(id)) footnoteOrder.push(id);
+function createUniqueHeadingId(raw) {
+  const baseId = String(raw || "")
+    .toLowerCase()
+    .trim()
+    .replace(/<[^>]*>/g, '')
+    .replace(/\s+/g, '-')
+    .replace(/[^\p{L}\p{N}\p{M}_-]/gu, '')
+    .replace(/-+/g, '-')
+    .replace(/^-+|-+$/g, '') || 'heading';
+  let id = baseId;
+  let suffix = 0;
+  while (usedHeadingIds.has(id)) {
+    suffix += 1;
+    id = `${baseId}-${suffix}`;
+  }
+  usedHeadingIds.add(id);
+  return id;
+}
 
-    const refCount = (footnoteRefCounts.get(id) || 0) + 1;
-    footnoteRefCounts.set(id, refCount);
+function normalizeWorkerMarkmapFences(markdown) {
+  const lines = String(markdown || '').split(/\r?\n/);
+  const output = [];
+  let index = 0;
 
-    const normalizedId = normalizeFootnoteId(id);
-    const refId = `fnref-${normalizedId}${refCount > 1 ? `-${refCount}` : ""}`;
-    if (!footnoteFirstRefId.has(id)) footnoteFirstRefId.set(id, refId);
+  while (index < lines.length) {
+    const opening = lines[index].match(/^([ \t]{0,3})(`{3,}|~{3,})([ \t]*)(.*)$/);
+    const info = opening ? opening[4].trim() : '';
+    if (!opening || !/^markmap(?:\s|$)/i.test(info)) {
+      output.push(lines[index]);
+      index += 1;
+      continue;
+    }
 
-    const noteNumber = footnoteOrder.indexOf(id) + 1;
-    return `<sup id="${escapeHtmlAttribute(refId)}" class="footnote-ref"><a href="#fn-${escapeHtmlAttribute(normalizedId)}" aria-label="Footnote ${noteNumber}">[${noteNumber}]</a></sup>`;
-  });
+    const indent = opening[1];
+    const fence = opening[2];
+    const marker = fence[0];
+    const content = [];
+    let nestedFence = null;
+    let maxInnerFenceLength = fence.length;
+    let closeIndex = -1;
+
+    for (let scan = index + 1; scan < lines.length; scan += 1) {
+      const line = lines[scan];
+      const fenceMatch = line.match(/^[ \t]{0,3}(`{3,}|~{3,})([ \t]*.*)$/);
+      if (fenceMatch) {
+        const currentFence = fenceMatch[1];
+        const currentMarker = currentFence[0];
+        const tail = fenceMatch[2].trim();
+        if (currentMarker === marker) {
+          maxInnerFenceLength = Math.max(maxInnerFenceLength, currentFence.length);
+        }
+        if (nestedFence) {
+          if (currentMarker === nestedFence.marker && currentFence.length >= nestedFence.length && tail === '') {
+            nestedFence = null;
+          }
+        } else if (currentMarker === marker && currentFence.length >= fence.length && tail === '') {
+          closeIndex = scan;
+          break;
+        } else if (tail !== '') {
+          nestedFence = { marker: currentMarker, length: currentFence.length };
+        }
+      }
+      content.push(line);
+    }
 
-  const footnotesHtml = footnoteOrder
-    .filter((id) => footnoteDefinitions.has(id))
-    .map((id) => {
-      const normalizedId = normalizeFootnoteId(id);
-      const backRefId = footnoteFirstRefId.get(id) || `fnref-${normalizedId}`;
-      const backRefHtml = `<a href="#${escapeHtmlAttribute(backRefId)}" class="footnote-backref" aria-label="Back to content">&#8592;</a>`;
-      const noteHtml = renderDefinitionContent(footnoteDefinitions.get(id) || "", { appendHtml: backRefHtml });
-      return `<li id="fn-${escapeHtmlAttribute(normalizedId)}">${noteHtml}</li>`;
-    })
-    .join("");
+    if (closeIndex === -1) {
+      output.push(lines[index]);
+      index += 1;
+      continue;
+    }
 
-  if (!footnotesHtml) return markdownWithReferences;
-  return `${markdownWithReferences}\n\n<section class="footnotes"><hr><ol>${footnotesHtml}</ol></section>`;
+    const normalizedFence = marker.repeat(maxInnerFenceLength + 1);
+    output.push(`${indent}${normalizedFence}${opening[3]}${opening[4]}`);
+    output.push(...content);
+    output.push(`${indent}${normalizedFence}`);
+    index = closeIndex + 1;
+  }
+
+  return output.join('\n');
 }
 
 function configureMarked() {
@@ -199,7 +349,120 @@ function configureMarked() {
       return { type: "blockMath", raw: match[0], text: match[1] };
     },
     renderer(token) {
-      return `<div class="math-block">$$\n${token.text}\n$$</div>\n`;
+      return `<div class="math-block tex2jax_process">$$\n${escapeHtml(normalizeLegacyMathSyntax(token.text))}\n$$</div>\n`;
+    },
+  };
+
+  const footnoteDefinitionExtension = {
+    name: "footnoteDefinition",
+    level: "block",
+    start(src) {
+      const match = src.match(/(?:^|\n)[ \t]{0,3}\[\^[^\]\n]+\]:/);
+      if (!match) return undefined;
+      return match.index + (match[0][0] === "\n" ? 1 : 0);
+    },
+    tokenizer(src) {
+      if (suppressFootnotePreprocess) return undefined;
+      const lines = src.split("\n");
+      const match = /^([ \t]{0,3})\[\^([^\]\n]+)\]:[ \t]*(.*)$/.exec(lines[0]);
+      if (!match) return undefined;
+      const baseIndent = match[1] || "";
+      const id = normalizeFootnoteLabel(match[2]);
+      const definitionLines = [match[3] || ""];
+      const rawLines = [lines[0]];
+      let index = 1;
+      while (index < lines.length) {
+        const line = lines[index];
+        if (!line.startsWith(baseIndent)) break;
+        const lineAfterBase = line.slice(baseIndent.length);
+        const indentedMatch = /^(?: {2,}|\t)(.*)$/.exec(lineAfterBase);
+        if (indentedMatch) {
+          rawLines.push(line);
+          definitionLines.push(indentedMatch[1]);
+          index += 1;
+          continue;
+        }
+        if (lineAfterBase.trim() === "") {
+          const nextLine = lines[index + 1] || "";
+          const nextAfterBase = nextLine.startsWith(baseIndent) ? nextLine.slice(baseIndent.length) : "";
+          if (/^(?: {2,}|\t)/.test(nextAfterBase)) {
+            rawLines.push(line);
+            definitionLines.push("");
+            index += 1;
+            continue;
+          }
+        }
+        break;
+      }
+      let raw = rawLines.join("\n");
+      if (src.startsWith(raw + "\n")) raw += "\n";
+      if (id && !footnoteDefinitions.has(id)) {
+        footnoteDefinitions.set(id, definitionLines.join("\n").trim());
+      }
+      return { type: "footnoteDefinition", raw };
+    },
+    renderer() {
+      return "";
+    },
+  };
+
+  const footnoteReferenceExtension = {
+    name: "footnoteReference",
+    level: "inline",
+    start(src) {
+      if (suppressFootnotePreprocess) return undefined;
+      const index = src.indexOf("[^");
+      return index >= 0 ? index : undefined;
+    },
+    tokenizer(src) {
+      if (suppressFootnotePreprocess) return undefined;
+      const match = /^\[\^([^\]\n]+)\]/.exec(src);
+      if (!match) return undefined;
+      return { type: "footnoteReference", raw: match[0], id: match[1].trim() };
+    },
+    renderer(token) {
+      const id = normalizeFootnoteLabel(token.id);
+      if (!id || !footnoteDefinitions.has(id)) return escapeHtml(token.raw);
+      if (!footnoteOrder.includes(id)) footnoteOrder.push(id);
+      const refCount = (footnoteRefCounts.get(id) || 0) + 1;
+      footnoteRefCounts.set(id, refCount);
+      const slug = getFootnoteSlug(id);
+      const refId = getFootnoteReferenceId(id, refCount);
+      const noteNumber = footnoteOrder.indexOf(id) + 1;
+      return `<sup id="${escapeHtmlAttribute(refId)}" class="footnote-ref"><a href="#fn-${escapeHtmlAttribute(slug)}" aria-label="Footnote ${noteNumber}">[${noteNumber}]</a></sup>`;
+    },
+  };
+
+  const inlineMathExtension = {
+    name: "inlineMath",
+    level: "inline",
+    start(src) {
+      const match = INLINE_MATH_START_PATTERN.exec(src);
+      return match ? match.index : undefined;
+    },
+    tokenizer(src) {
+      if (src.startsWith("\\$")) return { type: "inlineMath", raw: "\\$", literalDollar: true };
+      if (src.startsWith("\\(") || src.startsWith("\\[")) {
+        const opening = src.slice(0, 2);
+        const closing = opening === "\\(" ? "\\)" : "\\]";
+        const closeIndex = findClosingMathDelimiter(src, closing, 2);
+        if (closeIndex >= 2) {
+          return {
+            type: "inlineMath",
+            raw: src.slice(0, closeIndex + 2),
+            display: opening === "\\[",
+          };
+        }
+        return undefined;
+      }
+      if (src[0] !== "$" || isEscapedCharacter(src, 0)) return undefined;
+      const mathToken = tokenizeDollarMath(src);
+      return mathToken || { type: "inlineMath", raw: "$", literalDollar: true };
+    },
+    renderer(token) {
+      if (token.literalDollar) return '<span class="math-literal-dollar tex2jax_ignore">&#36;</span>';
+      const displayClass = token.display ? ' math-display-inline' : '';
+      return `<span class="math-inline tex2jax_process${displayClass}">${escapeHtml(normalizeLegacyMathSyntax(token.raw))}</span>`;
     },
   };
 
@@ -211,16 +474,27 @@ function configureMarked() {
       return match ? match.index + 1 : undefined;
     },
     tokenizer(src) {
+      if (this.lexer && this.lexer.state && !this.lexer.state.top) return undefined;
       const lines = src.split("\n");
       if (lines.length < 2) return undefined;
 
-      const term = lines[0];
-      if (EMPTY_LINE_PATTERN.test(term) || MARKDOWN_LIST_MARKER_PATTERN.test(term)) return undefined;
-      if (!DEFINITION_LIST_ITEM_PATTERN.test(lines[1])) return undefined;
-
+      const terms = [];
+      const rawLines = [];
+      let index = 0;
+      while (index < lines.length && !DEFINITION_LIST_ITEM_PATTERN.test(lines[index])) {
+        const term = lines[index];
+        if (
+          EMPTY_LINE_PATTERN.test(term) ||
+          MARKDOWN_LIST_MARKER_PATTERN.test(term) ||
+          DEFINITION_LIST_DISALLOWED_TERM_PATTERN.test(term) ||
+          GFM_TABLE_DELIMITER_PATTERN.test(term)
+        ) return undefined;
+        terms.push(term.trim());
+        rawLines.push(term);
+        index += 1;
+      }
+      if (terms.length === 0 || index >= lines.length) return undefined;
       const definitions = [];
-      const rawLines = [term];
-      let index = 1;
       while (index < lines.length) {
         const itemMatch = DEFINITION_LIST_ITEM_PATTERN.exec(lines[index]);
         if (!itemMatch) break;
@@ -255,14 +529,16 @@ function configureMarked() {
       if (definitions.length === 0) return undefined;
       let raw = rawLines.join("\n");
       if (src.startsWith(raw + "\n")) raw += "\n";
-      return { type: "definitionList", raw, term: term.trim(), definitions };
+      return { type: "definitionList", raw, terms, definitions };
     },
     renderer(token) {
-      const termHtml = parseInlineWithoutFootnotes(token.term);
+      const termHtml = token.terms
+        .map((term) => `<dt>${parseInlineWithoutFootnotes(term)}</dt>`)
+        .join("");
       const definitionHtml = token.definitions
         .map((definition) => `<dd>${renderDefinitionContent(definition)}</dd>`)
         .join("");
-      return `<dl><dt>${termHtml}</dt>${definitionHtml}</dl>\n`;
+      return `<dl>${termHtml}${definitionHtml}</dl>\n`;
     },
   };
 
@@ -278,7 +554,7 @@ function configureMarked() {
       return match ? { type: "superscript", raw: match[0], text: match[1] } : undefined;
     },
     renderer(token) {
-      return `<sup>${marked.parseInline(token.text)}</sup>`;
+      return `<sup>${parseInlineWithoutFootnotes(token.text)}</sup>`;
     },
   };
 
@@ -294,7 +570,7 @@ function configureMarked() {
       return match ? { type: "subscript", raw: match[0], text: match[1] } : undefined;
     },
     renderer(token) {
-      return `<sub>${marked.parseInline(token.text)}</sub>`;
+      return `<sub>${parseInlineWithoutFootnotes(token.text)}</sub>`;
     },
   };
 
@@ -310,7 +586,7 @@ function configureMarked() {
       return match ? { type: "highlight", raw: match[0], text: match[1] } : undefined;
     },
     renderer(token) {
-      return `<mark>${marked.parseInline(token.text)}</mark>`;
+      return `<mark>${parseInlineWithoutFootnotes(token.text)}</mark>`;
     },
   };
 
@@ -379,7 +655,7 @@ function configureMarked() {
     }
 
     if (language === "math") {
-      return `<div class="math-block">$$\n${code}\n$$</div>\n`;
+      return `<div class="math-block tex2jax_process">$$\n${escapeHtml(normalizeLegacyMathSyntax(code))}\n$$</div>\n`;
     }
 
     const validLanguage = hljs && hljs.getLanguage(language) ? language : "plaintext";
@@ -390,16 +666,7 @@ function configureMarked() {
   };
 
   renderer.heading = function(text, level, raw) {
-    let id = raw
-      .toLowerCase()
-      .trim()
-      .replace(/<[^>]*>/g, '')
-      .replace(/\s+/g, '-')
-      .replace(/[^\w-]/g, '')
-      .replace(/-+/g, '-');
-    if (!id) {
-      id = `heading-worker-${Math.random().toString(36).substr(2, 9)}`;
-    }
+    const id = createUniqueHeadingId(raw);
     return `<h${level} id="${id}">${text}</h${level}>`;
   };
 
@@ -472,7 +739,10 @@ function configureMarked() {
   marked.use({
     extensions: [
       blockMathExtension,
+      footnoteDefinitionExtension,
       definitionListExtension,
+      inlineMathExtension,
+      footnoteReferenceExtension,
       superscriptExtension,
       subscriptExtension,
       highlightExtension,
@@ -480,10 +750,12 @@ function configureMarked() {
     hooks: {
       preprocess(markdown) {
         if (suppressFootnotePreprocess) return markdown;
-        resetExtendedMarkdownState();
-        const normalizedMarkdown = normalizeMarkmapFences(markdown);
-        const protectedMarkdown = normalizedMarkdown.replace(/\\\$/g, "&#36;");
-        return applyFootnotes(extractFootnoteDefinitions(protectedMarkdown));
+        if (!preserveExtendedMarkdownState) resetExtendedMarkdownState();
+        return normalizeMarkmapFences(markdown);
+      },
+      postprocess(html) {
+        if (suppressFootnotePreprocess) return html;
+        return html + renderFootnotesSection();
       },
     },
   });
@@ -508,6 +780,9 @@ function isSegmentedPreviewSafe(markdown) {
   if (/^\[[^\]\n]+\]:\s+\S+/m.test(markdown)) return false;
   if (/\[\^[^\]\n]+\]/.test(markdown)) return false;
   if (/\n:[ \t]+/.test(markdown)) return false;
+  if (/^[ \t]{0,3}(?:[*+-]|\d{1,9}[.)])(?:[ \t]+|$)/m.test(markdown)) return false;
+  if (/^(?: {4}|\t)\S/m.test(markdown)) return false;
+  if (/^[ \t]{0,3}(?:<!--|<\?|<![A-Z]|<!\[CDATA\[)/m.test(markdown)) return false;
   if (/^\s{0,3}<\/?[a-zA-Z][\w:-]*(?:\s|>|\/>)/m.test(markdown)) return false;
   return true;
 }
@@ -580,7 +855,7 @@ function splitMarkdownBlocks(markdown) {
 }
 
 function renderSegmentedMarkdown(markdown, options) {
-  const normalizedMarkdown = normalizeMarkmapFences(markdown);
+  const normalizedMarkdown = normalizeWorkerMarkmapFences(markdown);
   if (!isSegmentedPreviewSafe(normalizedMarkdown)) {
     return { mode: "full-required", reason: "unsafe-markdown" };
   }
@@ -591,21 +866,28 @@ function renderSegmentedMarkdown(markdown, options) {
   }
 
   const seenHashes = new Map();
-  const renderedBlocks = blocks.map((block) => {
-    const hash = hashString(block.source);
-    const seenCount = seenHashes.get(hash) || 0;
-    seenHashes.set(hash, seenCount + 1);
-    const html = marked.parse(block.source);
-    return {
-      id: `preview-block-${hash}-${seenCount}`,
-      hash,
-      html,
-      htmlLength: html.length,
-      sourceLength: block.source.length,
-      startLine: block.startLine,
-      endLine: block.endLine,
-    };
-  });
+  resetExtendedMarkdownState();
+  preserveExtendedMarkdownState = true;
+  let renderedBlocks;
+  try {
+    renderedBlocks = blocks.map((block) => {
+      const hash = hashString(block.source);
+      const seenCount = seenHashes.get(hash) || 0;
+      seenHashes.set(hash, seenCount + 1);
+      const html = marked.parse(block.source);
+      return {
+        id: `preview-block-${hash}-${seenCount}`,
+        hash,
+        html,
+        htmlLength: html.length,
+        sourceLength: block.source.length,
+        startLine: block.startLine,
+        endLine: block.endLine,
+      };
+    });
+  } finally {
+    preserveExtendedMarkdownState = false;
+  }
 
   return {
     mode: "segmented",
diff --git a/desktop-app/resources/js/script.js b/desktop-app/resources/js/script.js
index 40e4c56a..37db9652 100644
--- a/desktop-app/resources/js/script.js
+++ b/desktop-app/resources/js/script.js
@@ -2211,41 +2211,65 @@ document.addEventListener("DOMContentLoaded", async function () {
   const renderer = new marked.Renderer();
   const BLOCK_MATH_MARKER_PATTERN = /^\$\$/m;
   const BLOCK_MATH_PATTERN = /^\$\$[ \t]*\n?([\s\S]*?)\n?\$\$[ \t]*(?:\n|$)/;
+  const INLINE_MATH_START_PATTERN = /\\(?:\$|\(|\[)|\$/;
   const RAW_MATH_TEXT_PATTERN = /\$\$|\$[^$]|\\\(|\\\[/;
   const MATHJAX_TEXT_TARGET_SELECTOR = 'p, li, td, th, dd, dt, blockquote, figcaption, h1, h2, h3, h4, h5, h6, .math-block';
   const DEFINITION_LIST_ITEM_PATTERN = /^:[ \t]+(.*)$/;
   const SUPERSCRIPT_PATTERN = /^\^(?!\s)([^^\n]*?\S)\^(?!\^)/;
   const SUBSCRIPT_PATTERN = /^~(?!~)(?!\s)([^~\n]*?\S)~(?!~)/;
   const HIGHLIGHT_PATTERN = /^==(?=\S)([\s\S]*?\S)==/;
-  const MARKDOWN_LIST_MARKER_PATTERN = /^(\s*)(?:[-*+]\s+|\d+\.\s+|>\s+)/;
+  const MARKDOWN_LIST_MARKER_PATTERN = /^(\s*)(?:[-*+]\s+|\d{1,9}[.)]\s+|>\s*)/;
+  const DEFINITION_LIST_DISALLOWED_TERM_PATTERN = /^(?: {4}|\t|[ \t]{0,3}(?:`{3,}|~{3,}|#{1,6}(?:[ \t]+|$)|(?:[*_-][ \t]*){3,}$|[=-]+[ \t]*$|\[[^\]\n]+\]:[ \t]*\S|<!--|<\?|<![A-Z]|<!\[CDATA\[|<\/?[a-zA-Z][\w:-]*(?:\s|>|\/>)))/;
+  const GFM_TABLE_DELIMITER_PATTERN = /^[ \t]*\|?[ \t]*:?-+:?[ \t]*(?:\|[ \t]*:?-+:?[ \t]*)+\|?[ \t]*$/;
   const EMPTY_LINE_PATTERN = /^\s*$/;
   const footnoteDefinitions = new Map();
   const footnoteOrder = [];
   const footnoteRefCounts = new Map();
-  const footnoteFirstRefId = new Map();
-  let anonymousFootnoteCounter = 0;
+  const footnoteSlugs = new Map();
+  const usedFootnoteSlugs = new Set();
+  const usedHeadingIds = new Set();
   let suppressFootnotePreprocess = false;
 
   function resetExtendedMarkdownState() {
     footnoteDefinitions.clear();
     footnoteOrder.length = 0;
     footnoteRefCounts.clear();
-    footnoteFirstRefId.clear();
-    anonymousFootnoteCounter = 0;
+    footnoteSlugs.clear();
+    usedFootnoteSlugs.clear();
+    usedHeadingIds.clear();
   }
 
-  function normalizeFootnoteId(id) {
-    const normalized = String(id || "")
+  function normalizeFootnoteLabel(id) {
+    return String(id || "")
       .trim()
       .toLowerCase()
-      .replace(/[^a-z0-9_-]+/g, "-")
-      .replace(/^-+|-+$/g, "");
-    if (normalized) {
-      return normalized;
+      .replace(/\s+/g, " ");
+  }
+
+  function getFootnoteSlug(label) {
+    if (footnoteSlugs.has(label)) {
+      return footnoteSlugs.get(label);
     }
 
-    anonymousFootnoteCounter += 1;
-    return `footnote-${anonymousFootnoteCounter}`;
+    const baseSlug = String(label || "")
+      .replace(/\s+/g, "-")
+      .replace(/[^\p{L}\p{N}\p{M}_-]+/gu, "-")
+      .replace(/-+/g, "-")
+      .replace(/^-+|-+$/g, "") || "footnote";
+    let slug = baseSlug;
+    let suffix = 1;
+    while (usedFootnoteSlugs.has(slug)) {
+      slug = `${baseSlug}-${suffix}`;
+      suffix += 1;
+    }
+    usedFootnoteSlugs.add(slug);
+    footnoteSlugs.set(label, slug);
+    return slug;
+  }
+
+  function getFootnoteReferenceId(label, referenceNumber) {
+    const slug = getFootnoteSlug(label);
+    return `fnref-${slug}${referenceNumber > 1 ? `-${referenceNumber}` : ""}`;
   }
 
   function escapeHtmlAttribute(value) {
@@ -2311,6 +2335,9 @@ document.addEventListener("DOMContentLoaded", async function () {
     if (/^\[[^\]\n]+\]:\s+\S+/m.test(markdown)) return false;
     if (/\[\^[^\]\n]+\]/.test(markdown)) return false;
     if (/\n:[ \t]+/.test(markdown)) return false;
+    if (/^[ \t]{0,3}(?:[*+-]|\d{1,9}[.)])(?:[ \t]+|$)/m.test(markdown)) return false;
+    if (/^(?: {4}|\t)\S/m.test(markdown)) return false;
+    if (/^[ \t]{0,3}(?:<!--|<\?|<![A-Z]|<!\[CDATA\[)/m.test(markdown)) return false;
     if (/^\s{0,3}<\/?[a-zA-Z][\w:-]*(?:\s|>|\/>)/m.test(markdown)) return false;
     return true;
   }
@@ -2484,106 +2511,163 @@ document.addEventListener("DOMContentLoaded", async function () {
       .join("");
   }
 
-  function extractFootnoteDefinitions(markdown) {
-    const lines = markdown.split("\n");
-    const preservedLines = [];
-    let index = 0;
+  function renderFootnotesSection() {
+    const footnotesHtml = footnoteOrder
+      .filter((id) => footnoteDefinitions.has(id))
+      .map((id) => {
+        const slug = getFootnoteSlug(id);
+        const referenceCount = footnoteRefCounts.get(id) || 1;
+        const safeSlug = escapeHtmlAttribute(slug);
+        const backRefHtml = Array.from({ length: referenceCount }, (_, index) => {
+          const referenceNumber = index + 1;
+          const backRefId = escapeHtmlAttribute(getFootnoteReferenceId(id, referenceNumber));
+          const occurrenceLabel = referenceNumber > 1 ? ` ${referenceNumber}` : "";
+          const occurrenceMarker = referenceNumber > 1 ? `<sup>${referenceNumber}</sup>` : "";
+          return `<a href="#${backRefId}" class="footnote-backref" aria-label="Back to content${occurrenceLabel}">←${occurrenceMarker}</a>`;
+        }).join(" ");
+        const noteHtml = renderDefinitionContent(
+          footnoteDefinitions.get(id) || "",
+          { appendHtml: backRefHtml }
+        );
+        return `<li id="fn-${safeSlug}">${noteHtml}</li>`;
+      })
+      .join("");
 
-    while (index < lines.length) {
-      const match = /^([ \t]{0,3})\[\^([^\]\n]+)\]:[ \t]*(.*)$/.exec(lines[index]);
-      if (!match) {
-        preservedLines.push(lines[index]);
-        index += 1;
-        continue;
+    return footnotesHtml
+      ? `<section class="footnotes"><hr><ol>${footnotesHtml}</ol></section>`
+      : "";
+  }
+
+  function isEscapedCharacter(source, index) {
+    let backslashCount = 0;
+    for (let cursor = index - 1; cursor >= 0 && source[cursor] === "\\"; cursor -= 1) {
+      backslashCount += 1;
+    }
+    return backslashCount % 2 === 1;
+  }
+
+  function findClosingMathDelimiter(source, delimiter, startIndex) {
+    for (let index = startIndex; index <= source.length - delimiter.length; index += 1) {
+      if (source[index] === "\n") return -1;
+      if (source.startsWith(delimiter, index) && !isEscapedCharacter(source, index)) {
+        return index;
       }
+    }
+    return -1;
+  }
 
-      const baseIndent = match[1] || "";
-      const id = match[2].trim();
-      const definitionLines = [match[3] || ""];
-      index += 1;
+  function tokenizeDollarMath(source) {
+    if (source.startsWith("$$")) {
+      const closeIndex = findClosingMathDelimiter(source, "$$", 2);
+      if (closeIndex > 2) {
+        return {
+          type: "inlineMath",
+          raw: source.slice(0, closeIndex + 2),
+          display: true,
+        };
+      }
+      return null;
+    }
 
-      while (index < lines.length) {
-        const line = lines[index];
-        if (!line.startsWith(baseIndent)) {
-          break;
-        }
+    if (source[0] !== "$" || !source[1] || /[\s$]/.test(source[1])) {
+      return null;
+    }
 
-        const lineAfterBase = line.slice(baseIndent.length);
-        const indentedMatch = /^(?: {2,}|\t)(.*)$/.exec(lineAfterBase);
-        if (indentedMatch) {
-          definitionLines.push(indentedMatch[1]);
-          index += 1;
-          continue;
-        }
+    for (let index = 1; index < source.length; index += 1) {
+      if (source[index] === "\n") break;
+      if (source[index] !== "$" || isEscapedCharacter(source, index)) continue;
+      if (/\s/.test(source[index - 1]) || /\d/.test(source[index + 1] || "")) return null;
+      return {
+        type: "inlineMath",
+        raw: source.slice(0, index + 1),
+        display: false,
+      };
+    }
 
-        if (lineAfterBase.trim() === "") {
-          const nextLine = lines[index + 1] || "";
-          const nextAfterBase = nextLine.startsWith(baseIndent)
-            ? nextLine.slice(baseIndent.length)
-            : "";
-          if (/^(?: {2,}|\t)/.test(nextAfterBase)) {
-            definitionLines.push("");
-            index += 1;
-            continue;
-          }
-        }
+    return null;
+  }
 
-        break;
+  function readBalancedTexGroup(source, startIndex) {
+    if (source[startIndex] !== "{") return null;
+    let depth = 0;
+    for (let index = startIndex; index < source.length; index += 1) {
+      if (isEscapedCharacter(source, index)) continue;
+      if (source[index] === "{") {
+        depth += 1;
+      } else if (source[index] === "}") {
+        depth -= 1;
+        if (depth === 0) {
+          return { endIndex: index, content: source.slice(startIndex + 1, index) };
+        }
       }
-
-      footnoteDefinitions.set(id, definitionLines.join("\n").trim());
     }
-
-    return preservedLines.join("\n");
+    return null;
   }
 
-  function applyFootnotes(markdown) {
-    const markdownWithReferences = markdown.replace(/\[\^([^\]\n]+)\]/g, function(match, idText) {
-      const id = idText.trim();
-      if (!id) {
-        return match;
+  function normalizeLegacyMathSyntax(source) {
+    const tex = String(source || "");
+    let normalized = "";
+    let index = 0;
+
+    while (index < tex.length) {
+      if (tex.startsWith("\\^", index) && !isEscapedCharacter(tex, index)) {
+        normalized += "^";
+        index += 2;
+        continue;
       }
 
-      if (!footnoteOrder.includes(id)) {
-        footnoteOrder.push(id);
+      if (
+        !tex.startsWith("\\color", index) ||
+        isEscapedCharacter(tex, index) ||
+        /[a-zA-Z]/.test(tex[index + 6] || "")
+      ) {
+        normalized += tex[index];
+        index += 1;
+        continue;
       }
 
-      const refCount = (footnoteRefCounts.get(id) || 0) + 1;
-      footnoteRefCounts.set(id, refCount);
+      let colorGroupStart = index + 6;
+      while (/[ \t]/.test(tex[colorGroupStart] || "")) colorGroupStart += 1;
+      const colorGroup = readBalancedTexGroup(tex, colorGroupStart);
+      if (!colorGroup) {
+        normalized += tex[index];
+        index += 1;
+        continue;
+      }
 
-      const normalizedId = normalizeFootnoteId(id);
-      const refId = `fnref-${normalizedId}${refCount > 1 ? `-${refCount}` : ""}`;
-      if (!footnoteFirstRefId.has(id)) {
-        footnoteFirstRefId.set(id, refId);
+      let contentGroupStart = colorGroup.endIndex + 1;
+      while (/[ \t]/.test(tex[contentGroupStart] || "")) contentGroupStart += 1;
+      const contentGroup = readBalancedTexGroup(tex, contentGroupStart);
+      if (!contentGroup) {
+        normalized += tex[index];
+        index += 1;
+        continue;
       }
 
-      const noteNumber = footnoteOrder.indexOf(id) + 1;
-      const safeRefId = escapeHtmlAttribute(refId);
-      const safeNormalizedId = escapeHtmlAttribute(normalizedId);
-      return `<sup id="${safeRefId}" class="footnote-ref"><a href="#fn-${safeNormalizedId}" aria-label="Footnote ${noteNumber}">[${noteNumber}]</a></sup>`;
-    });
+      normalized += `{\\color{${colorGroup.content}}${normalizeLegacyMathSyntax(contentGroup.content)}}`;
+      index = contentGroup.endIndex + 1;
+    }
 
-    const footnotesHtml = footnoteOrder
-      .filter((id) => footnoteDefinitions.has(id))
-      .map((id) => {
-        const normalizedId = normalizeFootnoteId(id);
-        const backRefId = footnoteFirstRefId.get(id) || `fnref-${normalizedId}`;
-        const safeNormalizedId = escapeHtmlAttribute(normalizedId);
-        const safeBackRefId = escapeHtmlAttribute(backRefId);
-        const backRefHtml = `<a href="#${safeBackRefId}" class="footnote-backref" aria-label="Back to content">←</a>`;
-        const noteHtml = renderDefinitionContent(
-          footnoteDefinitions.get(id) || "",
-          { appendHtml: backRefHtml }
-        );
-        return `<li id="fn-${safeNormalizedId}">${noteHtml}</li>`;
-      })
-      .join("");
+    return normalized;
+  }
 
-    if (!footnotesHtml) {
-      return markdownWithReferences;
+  function createUniqueHeadingId(raw) {
+    const baseId = String(raw || "")
+      .toLowerCase()
+      .trim()
+      .replace(/<[^>]*>/g, '')
+      .replace(/\s+/g, '-')
+      .replace(/[^\p{L}\p{N}\p{M}_-]/gu, '')
+      .replace(/-+/g, '-')
+      .replace(/^-+|-+$/g, '') || 'heading';
+    let id = baseId;
+    let suffix = 0;
+    while (usedHeadingIds.has(id)) {
+      suffix += 1;
+      id = `${baseId}-${suffix}`;
     }
-
-    return `${markdownWithReferences}\n\n<section class="footnotes"><hr><ol>${footnotesHtml}</ol></section>`;
+    usedHeadingIds.add(id);
+    return id;
   }
 
   const blockMathExtension = {
@@ -2608,9 +2692,127 @@ document.addEventListener("DOMContentLoaded", async function () {
       };
     },
     renderer(token) {
-      return `<div class="math-block">$$\n${token.text}\n$$</div>\n`;
+      return `<div class="math-block tex2jax_process">$$\n${escapeHtml(normalizeLegacyMathSyntax(token.text))}\n$$</div>\n`;
     }
   };
+  const footnoteDefinitionExtension = {
+    name: "footnoteDefinition",
+    level: "block",
+    start(src) {
+      const match = src.match(/(?:^|\n)[ \t]{0,3}\[\^[^\]\n]+\]:/);
+      if (!match) return undefined;
+      return match.index + (match[0][0] === "\n" ? 1 : 0);
+    },
+    tokenizer(src) {
+      if (suppressFootnotePreprocess) return undefined;
+      const lines = src.split("\n");
+      const match = /^([ \t]{0,3})\[\^([^\]\n]+)\]:[ \t]*(.*)$/.exec(lines[0]);
+      if (!match) return undefined;
+
+      const baseIndent = match[1] || "";
+      const id = normalizeFootnoteLabel(match[2]);
+      const definitionLines = [match[3] || ""];
+      const rawLines = [lines[0]];
+      let index = 1;
+      while (index < lines.length) {
+        const line = lines[index];
+        if (!line.startsWith(baseIndent)) break;
+        const lineAfterBase = line.slice(baseIndent.length);
+        const indentedMatch = /^(?: {2,}|\t)(.*)$/.exec(lineAfterBase);
+        if (indentedMatch) {
+          rawLines.push(line);
+          definitionLines.push(indentedMatch[1]);
+          index += 1;
+          continue;
+        }
+        if (lineAfterBase.trim() === "") {
+          const nextLine = lines[index + 1] || "";
+          const nextAfterBase = nextLine.startsWith(baseIndent)
+            ? nextLine.slice(baseIndent.length)
+            : "";
+          if (/^(?: {2,}|\t)/.test(nextAfterBase)) {
+            rawLines.push(line);
+            definitionLines.push("");
+            index += 1;
+            continue;
+          }
+        }
+        break;
+      }
+
+      let raw = rawLines.join("\n");
+      if (src.startsWith(raw + "\n")) raw += "\n";
+      if (id && !footnoteDefinitions.has(id)) {
+        footnoteDefinitions.set(id, definitionLines.join("\n").trim());
+      }
+      return { type: "footnoteDefinition", raw };
+    },
+    renderer() {
+      return "";
+    },
+  };
+  const footnoteReferenceExtension = {
+    name: "footnoteReference",
+    level: "inline",
+    start(src) {
+      if (suppressFootnotePreprocess) return undefined;
+      const index = src.indexOf("[^");
+      return index >= 0 ? index : undefined;
+    },
+    tokenizer(src) {
+      if (suppressFootnotePreprocess) return undefined;
+      const match = /^\[\^([^\]\n]+)\]/.exec(src);
+      if (!match) return undefined;
+      return { type: "footnoteReference", raw: match[0], id: match[1].trim() };
+    },
+    renderer(token) {
+      const id = normalizeFootnoteLabel(token.id);
+      if (!id || !footnoteDefinitions.has(id)) return escapeHtml(token.raw);
+      if (!footnoteOrder.includes(id)) footnoteOrder.push(id);
+      const refCount = (footnoteRefCounts.get(id) || 0) + 1;
+      footnoteRefCounts.set(id, refCount);
+      const slug = getFootnoteSlug(id);
+      const refId = getFootnoteReferenceId(id, refCount);
+      const noteNumber = footnoteOrder.indexOf(id) + 1;
+      return `<sup id="${escapeHtmlAttribute(refId)}" class="footnote-ref"><a href="#fn-${escapeHtmlAttribute(slug)}" aria-label="Footnote ${noteNumber}">[${noteNumber}]</a></sup>`;
+    },
+  };
+  const inlineMathExtension = {
+    name: "inlineMath",
+    level: "inline",
+    start(src) {
+      const match = INLINE_MATH_START_PATTERN.exec(src);
+      return match ? match.index : undefined;
+    },
+    tokenizer(src) {
+      if (src.startsWith("\\$")) {
+        return { type: "inlineMath", raw: "\\$", literalDollar: true };
+      }
+      if (src.startsWith("\\(") || src.startsWith("\\[")) {
+        const opening = src.slice(0, 2);
+        const closing = opening === "\\(" ? "\\)" : "\\]";
+        const closeIndex = findClosingMathDelimiter(src, closing, 2);
+        if (closeIndex >= 2) {
+          return {
+            type: "inlineMath",
+            raw: src.slice(0, closeIndex + 2),
+            display: opening === "\\[",
+          };
+        }
+        return undefined;
+      }
+      if (src[0] !== "$" || isEscapedCharacter(src, 0)) return undefined;
+      const mathToken = tokenizeDollarMath(src);
+      return mathToken || { type: "inlineMath", raw: "$", literalDollar: true };
+    },
+    renderer(token) {
+      if (token.literalDollar) {
+        return '<span class="math-literal-dollar tex2jax_ignore">&#36;</span>';
+      }
+      const displayClass = token.display ? ' math-display-inline' : '';
+      return `<span class="math-inline tex2jax_process${displayClass}">${escapeHtml(normalizeLegacyMathSyntax(token.raw))}</span>`;
+    },
+  };
   const definitionListExtension = {
     name: "definitionList",
     level: "block",
@@ -2622,23 +2824,29 @@ document.addEventListener("DOMContentLoaded", async function () {
       return match.index + 1;
     },
     tokenizer(src) {
+      if (this.lexer && this.lexer.state && !this.lexer.state.top) return undefined;
       const lines = src.split("\n");
       if (lines.length < 2) {
         return undefined;
       }
 
-      const term = lines[0];
-      if (EMPTY_LINE_PATTERN.test(term) || MARKDOWN_LIST_MARKER_PATTERN.test(term)) {
-        return undefined;
-      }
-
-      if (!DEFINITION_LIST_ITEM_PATTERN.test(lines[1])) {
-        return undefined;
+      const terms = [];
+      const rawLines = [];
+      let index = 0;
+      while (index < lines.length && !DEFINITION_LIST_ITEM_PATTERN.test(lines[index])) {
+        const term = lines[index];
+        if (
+          EMPTY_LINE_PATTERN.test(term) ||
+          MARKDOWN_LIST_MARKER_PATTERN.test(term) ||
+          DEFINITION_LIST_DISALLOWED_TERM_PATTERN.test(term) ||
+          GFM_TABLE_DELIMITER_PATTERN.test(term)
+        ) return undefined;
+        terms.push(term.trim());
+        rawLines.push(term);
+        index += 1;
       }
-
+      if (terms.length === 0 || index >= lines.length) return undefined;
       const definitions = [];
-      const rawLines = [term];
-      let index = 1;
       while (index < lines.length) {
         const itemMatch = DEFINITION_LIST_ITEM_PATTERN.exec(lines[index]);
         if (!itemMatch) {
@@ -2689,16 +2897,18 @@ document.addEventListener("DOMContentLoaded", async function () {
       return {
         type: "definitionList",
         raw: raw,
-        term: term.trim(),
+        terms: terms,
         definitions: definitions,
       };
     },
     renderer(token) {
-      const termHtml = parseInlineWithoutFootnotes(token.term);
+      const termHtml = token.terms
+        .map((term) => `<dt>${parseInlineWithoutFootnotes(term)}</dt>`)
+        .join("");
       const definitionHtml = token.definitions
         .map((definition) => `<dd>${renderDefinitionContent(definition)}</dd>`)
         .join("");
-      return `<dl><dt>${termHtml}</dt>${definitionHtml}</dl>\n`;
+      return `<dl>${termHtml}${definitionHtml}</dl>\n`;
     },
   };
   const superscriptExtension = {
@@ -2720,7 +2930,7 @@ document.addEventListener("DOMContentLoaded", async function () {
       };
     },
     renderer(token) {
-      return `<sup>${marked.parseInline(token.text)}</sup>`;
+      return `<sup>${parseInlineWithoutFootnotes(token.text)}</sup>`;
     },
   };
   const subscriptExtension = {
@@ -2742,7 +2952,7 @@ document.addEventListener("DOMContentLoaded", async function () {
       };
     },
     renderer(token) {
-      return `<sub>${marked.parseInline(token.text)}</sub>`;
+      return `<sub>${parseInlineWithoutFootnotes(token.text)}</sub>`;
     },
   };
   const highlightExtension = {
@@ -2764,7 +2974,7 @@ document.addEventListener("DOMContentLoaded", async function () {
       };
     },
     renderer(token) {
-      return `<mark>${marked.parseInline(token.text)}</mark>`;
+      return `<mark>${parseInlineWithoutFootnotes(token.text)}</mark>`;
     },
   };
 
@@ -2852,7 +3062,7 @@ document.addEventListener("DOMContentLoaded", async function () {
     }
 
     if (language === 'math') {
-      return `<div class="math-block">$$\n${code}\n$$</div>\n`;
+      return `<div class="math-block tex2jax_process">$$\n${escapeHtml(normalizeLegacyMathSyntax(code))}\n$$</div>\n`;
     }
     
     const validLanguage = hljs.getLanguage(language) ? language : "plaintext";
@@ -2863,16 +3073,7 @@ document.addEventListener("DOMContentLoaded", async function () {
   };
 
   renderer.heading = function (text, level, raw) {
-    let id = raw
-      .toLowerCase()
-      .trim()
-      .replace(/<[^>]*>/g, '')
-      .replace(/\s+/g, '-')
-      .replace(/[^\w-]/g, '')
-      .replace(/-+/g, '-');
-    if (!id) {
-      id = 'heading-' + Math.random().toString(36).substr(2, 9);
-    }
+    const id = createUniqueHeadingId(raw);
     return `<h${level} id="${id}">${text}</h${level}>`;
   };
 
@@ -2945,7 +3146,10 @@ document.addEventListener("DOMContentLoaded", async function () {
   marked.use({
     extensions: [
       blockMathExtension,
+      footnoteDefinitionExtension,
       definitionListExtension,
+      inlineMathExtension,
+      footnoteReferenceExtension,
       superscriptExtension,
       subscriptExtension,
       highlightExtension,
@@ -2956,11 +3160,11 @@ document.addEventListener("DOMContentLoaded", async function () {
           return markdown;
         }
         resetExtendedMarkdownState();
-        // ✅ Replace escaped dollar signs before marked.js strips the backslash.
-        // This prevents MathJax from treating lone $ as a math delimiter.
-        const normalizedMarkdown = normalizeMarkmapFences(markdown);
-        const protectedMarkdown = normalizedMarkdown.replace(/\\\$/g, '&#36;');
-        return applyFootnotes(extractFootnoteDefinitions(protectedMarkdown));
+        return normalizeMarkmapFences(markdown);
+      },
+      postprocess(html) {
+        if (suppressFootnotePreprocess) return html;
+        return html + renderFootnotesSection();
       },
     },
   });
diff --git a/preview-worker.js b/preview-worker.js
index 989b3566..9a81e6d5 100644
--- a/preview-worker.js
+++ b/preview-worker.js
@@ -25,19 +25,24 @@ const markedOptions = {
 
 const BLOCK_MATH_MARKER_PATTERN = /^\$\$/m;
 const BLOCK_MATH_PATTERN = /^\$\$[ \t]*\n?([\s\S]*?)\n?\$\$[ \t]*(?:\n|$)/;
+const INLINE_MATH_START_PATTERN = /\\(?:\$|\(|\[)|\$/;
 const DEFINITION_LIST_ITEM_PATTERN = /^:[ \t]+(.*)$/;
 const SUPERSCRIPT_PATTERN = /^\^(?!\s)([^^\n]*?\S)\^(?!\^)/;
 const SUBSCRIPT_PATTERN = /^~(?!~)(?!\s)([^~\n]*?\S)~(?!~)/;
 const HIGHLIGHT_PATTERN = /^==(?=\S)([\s\S]*?\S)==/;
-const MARKDOWN_LIST_MARKER_PATTERN = /^(\s*)(?:[-*+]\s+|\d+\.\s+|>\s+)/;
+const MARKDOWN_LIST_MARKER_PATTERN = /^(\s*)(?:[-*+]\s+|\d{1,9}[.)]\s+|>\s*)/;
+const DEFINITION_LIST_DISALLOWED_TERM_PATTERN = /^(?: {4}|\t|[ \t]{0,3}(?:`{3,}|~{3,}|#{1,6}(?:[ \t]+|$)|(?:[*_-][ \t]*){3,}$|[=-]+[ \t]*$|\[[^\]\n]+\]:[ \t]*\S|<!--|<\?|<![A-Z]|<!\[CDATA\[|<\/?[a-zA-Z][\w:-]*(?:\s|>|\/>)))/;
+const GFM_TABLE_DELIMITER_PATTERN = /^[ \t]*\|?[ \t]*:?-+:?[ \t]*(?:\|[ \t]*:?-+:?[ \t]*)+\|?[ \t]*$/;
 const EMPTY_LINE_PATTERN = /^\s*$/;
 
 let suppressFootnotePreprocess = false;
+let preserveExtendedMarkdownState = false;
 const footnoteDefinitions = new Map();
 const footnoteOrder = [];
 const footnoteRefCounts = new Map();
-const footnoteFirstRefId = new Map();
-let anonymousFootnoteCounter = 0;
+const footnoteSlugs = new Map();
+const usedFootnoteSlugs = new Set();
+const usedHeadingIds = new Set();
 
 function escapeHtml(str) {
   return String(str)
@@ -60,19 +65,40 @@ function resetExtendedMarkdownState() {
   footnoteDefinitions.clear();
   footnoteOrder.length = 0;
   footnoteRefCounts.clear();
-  footnoteFirstRefId.clear();
-  anonymousFootnoteCounter = 0;
+  footnoteSlugs.clear();
+  usedFootnoteSlugs.clear();
+  usedHeadingIds.clear();
 }
 
-function normalizeFootnoteId(id) {
-  const normalized = String(id || "")
+function normalizeFootnoteLabel(id) {
+  return String(id || "")
     .trim()
     .toLowerCase()
-    .replace(/[^a-z0-9_-]+/g, "-")
-    .replace(/^-+|-+$/g, "");
-  if (normalized) return normalized;
-  anonymousFootnoteCounter += 1;
-  return `footnote-${anonymousFootnoteCounter}`;
+    .replace(/\s+/g, " ");
+}
+
+function getFootnoteSlug(label) {
+  if (footnoteSlugs.has(label)) return footnoteSlugs.get(label);
+
+  const baseSlug = String(label || "")
+    .replace(/\s+/g, "-")
+    .replace(/[^\p{L}\p{N}\p{M}_-]+/gu, "-")
+    .replace(/-+/g, "-")
+    .replace(/^-+|-+$/g, "") || "footnote";
+  let slug = baseSlug;
+  let suffix = 1;
+  while (usedFootnoteSlugs.has(slug)) {
+    slug = `${baseSlug}-${suffix}`;
+    suffix += 1;
+  }
+  usedFootnoteSlugs.add(slug);
+  footnoteSlugs.set(label, slug);
+  return slug;
+}
+
+function getFootnoteReferenceId(label, referenceNumber) {
+  const slug = getFootnoteSlug(label);
+  return `fnref-${slug}${referenceNumber > 1 ? `-${referenceNumber}` : ""}`;
 }
 
 function parseInlineWithoutFootnotes(text) {
@@ -104,82 +130,206 @@ function renderDefinitionContent(content, options) {
     .join("");
 }
 
-function extractFootnoteDefinitions(markdown) {
-  const lines = markdown.split("\n");
-  const preservedLines = [];
+function renderFootnotesSection() {
+  const footnotesHtml = footnoteOrder
+    .filter((id) => footnoteDefinitions.has(id))
+    .map((id) => {
+      const slug = getFootnoteSlug(id);
+      const referenceCount = footnoteRefCounts.get(id) || 1;
+      const backRefHtml = Array.from({ length: referenceCount }, (_, index) => {
+        const referenceNumber = index + 1;
+        const backRefId = escapeHtmlAttribute(getFootnoteReferenceId(id, referenceNumber));
+        const occurrenceLabel = referenceNumber > 1 ? ` ${referenceNumber}` : "";
+        const occurrenceMarker = referenceNumber > 1 ? `<sup>${referenceNumber}</sup>` : "";
+        return `<a href="#${backRefId}" class="footnote-backref" aria-label="Back to content${occurrenceLabel}">&#8592;${occurrenceMarker}</a>`;
+      }).join(" ");
+      const noteHtml = renderDefinitionContent(footnoteDefinitions.get(id) || "", { appendHtml: backRefHtml });
+      return `<li id="fn-${escapeHtmlAttribute(slug)}">${noteHtml}</li>`;
+    })
+    .join("");
+
+  return footnotesHtml
+    ? `<section class="footnotes"><hr><ol>${footnotesHtml}</ol></section>`
+    : "";
+}
+
+function isEscapedCharacter(source, index) {
+  let backslashCount = 0;
+  for (let cursor = index - 1; cursor >= 0 && source[cursor] === "\\"; cursor -= 1) {
+    backslashCount += 1;
+  }
+  return backslashCount % 2 === 1;
+}
+
+function findClosingMathDelimiter(source, delimiter, startIndex) {
+  for (let index = startIndex; index <= source.length - delimiter.length; index += 1) {
+    if (source[index] === "\n") return -1;
+    if (source.startsWith(delimiter, index) && !isEscapedCharacter(source, index)) return index;
+  }
+  return -1;
+}
+
+function tokenizeDollarMath(source) {
+  if (source.startsWith("$$")) {
+    const closeIndex = findClosingMathDelimiter(source, "$$", 2);
+    if (closeIndex > 2) {
+      return { type: "inlineMath", raw: source.slice(0, closeIndex + 2), display: true };
+    }
+    return null;
+  }
+  if (source[0] !== "$" || !source[1] || /[\s$]/.test(source[1])) return null;
+  for (let index = 1; index < source.length; index += 1) {
+    if (source[index] === "\n") break;
+    if (source[index] !== "$" || isEscapedCharacter(source, index)) continue;
+    if (/\s/.test(source[index - 1]) || /\d/.test(source[index + 1] || "")) return null;
+    return { type: "inlineMath", raw: source.slice(0, index + 1), display: false };
+  }
+  return null;
+}
+
+function readBalancedTexGroup(source, startIndex) {
+  if (source[startIndex] !== "{") return null;
+  let depth = 0;
+  for (let index = startIndex; index < source.length; index += 1) {
+    if (isEscapedCharacter(source, index)) continue;
+    if (source[index] === "{") {
+      depth += 1;
+    } else if (source[index] === "}") {
+      depth -= 1;
+      if (depth === 0) {
+        return { endIndex: index, content: source.slice(startIndex + 1, index) };
+      }
+    }
+  }
+  return null;
+}
+
+function normalizeLegacyMathSyntax(source) {
+  const tex = String(source || "");
+  let normalized = "";
   let index = 0;
 
-  while (index < lines.length) {
-    const match = /^([ \t]{0,3})\[\^([^\]\n]+)\]:[ \t]*(.*)$/.exec(lines[index]);
-    if (!match) {
-      preservedLines.push(lines[index]);
+  while (index < tex.length) {
+    if (tex.startsWith("\\^", index) && !isEscapedCharacter(tex, index)) {
+      normalized += "^";
+      index += 2;
+      continue;
+    }
+
+    if (
+      !tex.startsWith("\\color", index) ||
+      isEscapedCharacter(tex, index) ||
+      /[a-zA-Z]/.test(tex[index + 6] || "")
+    ) {
+      normalized += tex[index];
       index += 1;
       continue;
     }
 
-    const baseIndent = match[1] || "";
-    const id = match[2].trim();
-    const definitionLines = [match[3] || ""];
-    index += 1;
+    let colorGroupStart = index + 6;
+    while (/[ \t]/.test(tex[colorGroupStart] || "")) colorGroupStart += 1;
+    const colorGroup = readBalancedTexGroup(tex, colorGroupStart);
+    if (!colorGroup) {
+      normalized += tex[index];
+      index += 1;
+      continue;
+    }
 
-    while (index < lines.length) {
-      const line = lines[index];
-      if (!line.startsWith(baseIndent)) break;
-      const lineAfterBase = line.slice(baseIndent.length);
-      const indentedMatch = /^(?: {2,}|\t)(.*)$/.exec(lineAfterBase);
-      if (indentedMatch) {
-        definitionLines.push(indentedMatch[1]);
-        index += 1;
-        continue;
-      }
-      if (lineAfterBase.trim() === "") {
-        const nextLine = lines[index + 1] || "";
-        const nextAfterBase = nextLine.startsWith(baseIndent) ? nextLine.slice(baseIndent.length) : "";
-        if (/^(?: {2,}|\t)/.test(nextAfterBase)) {
-          definitionLines.push("");
-          index += 1;
-          continue;
-        }
-      }
-      break;
+    let contentGroupStart = colorGroup.endIndex + 1;
+    while (/[ \t]/.test(tex[contentGroupStart] || "")) contentGroupStart += 1;
+    const contentGroup = readBalancedTexGroup(tex, contentGroupStart);
+    if (!contentGroup) {
+      normalized += tex[index];
+      index += 1;
+      continue;
     }
 
-    footnoteDefinitions.set(id, definitionLines.join("\n").trim());
+    normalized += `{\\color{${colorGroup.content}}${normalizeLegacyMathSyntax(contentGroup.content)}}`;
+    index = contentGroup.endIndex + 1;
   }
 
-  return preservedLines.join("\n");
+  return normalized;
 }
 
-function applyFootnotes(markdown) {
-  const markdownWithReferences = markdown.replace(/\[\^([^\]\n]+)\]/g, function(match, idText) {
-    const id = idText.trim();
-    if (!id) return match;
-    if (!footnoteOrder.includes(id)) footnoteOrder.push(id);
+function createUniqueHeadingId(raw) {
+  const baseId = String(raw || "")
+    .toLowerCase()
+    .trim()
+    .replace(/<[^>]*>/g, '')
+    .replace(/\s+/g, '-')
+    .replace(/[^\p{L}\p{N}\p{M}_-]/gu, '')
+    .replace(/-+/g, '-')
+    .replace(/^-+|-+$/g, '') || 'heading';
+  let id = baseId;
+  let suffix = 0;
+  while (usedHeadingIds.has(id)) {
+    suffix += 1;
+    id = `${baseId}-${suffix}`;
+  }
+  usedHeadingIds.add(id);
+  return id;
+}
 
-    const refCount = (footnoteRefCounts.get(id) || 0) + 1;
-    footnoteRefCounts.set(id, refCount);
+function normalizeWorkerMarkmapFences(markdown) {
+  const lines = String(markdown || '').split(/\r?\n/);
+  const output = [];
+  let index = 0;
 
-    const normalizedId = normalizeFootnoteId(id);
-    const refId = `fnref-${normalizedId}${refCount > 1 ? `-${refCount}` : ""}`;
-    if (!footnoteFirstRefId.has(id)) footnoteFirstRefId.set(id, refId);
+  while (index < lines.length) {
+    const opening = lines[index].match(/^([ \t]{0,3})(`{3,}|~{3,})([ \t]*)(.*)$/);
+    const info = opening ? opening[4].trim() : '';
+    if (!opening || !/^markmap(?:\s|$)/i.test(info)) {
+      output.push(lines[index]);
+      index += 1;
+      continue;
+    }
 
-    const noteNumber = footnoteOrder.indexOf(id) + 1;
-    return `<sup id="${escapeHtmlAttribute(refId)}" class="footnote-ref"><a href="#fn-${escapeHtmlAttribute(normalizedId)}" aria-label="Footnote ${noteNumber}">[${noteNumber}]</a></sup>`;
-  });
+    const indent = opening[1];
+    const fence = opening[2];
+    const marker = fence[0];
+    const content = [];
+    let nestedFence = null;
+    let maxInnerFenceLength = fence.length;
+    let closeIndex = -1;
+
+    for (let scan = index + 1; scan < lines.length; scan += 1) {
+      const line = lines[scan];
+      const fenceMatch = line.match(/^[ \t]{0,3}(`{3,}|~{3,})([ \t]*.*)$/);
+      if (fenceMatch) {
+        const currentFence = fenceMatch[1];
+        const currentMarker = currentFence[0];
+        const tail = fenceMatch[2].trim();
+        if (currentMarker === marker) {
+          maxInnerFenceLength = Math.max(maxInnerFenceLength, currentFence.length);
+        }
+        if (nestedFence) {
+          if (currentMarker === nestedFence.marker && currentFence.length >= nestedFence.length && tail === '') {
+            nestedFence = null;
+          }
+        } else if (currentMarker === marker && currentFence.length >= fence.length && tail === '') {
+          closeIndex = scan;
+          break;
+        } else if (tail !== '') {
+          nestedFence = { marker: currentMarker, length: currentFence.length };
+        }
+      }
+      content.push(line);
+    }
 
-  const footnotesHtml = footnoteOrder
-    .filter((id) => footnoteDefinitions.has(id))
-    .map((id) => {
-      const normalizedId = normalizeFootnoteId(id);
-      const backRefId = footnoteFirstRefId.get(id) || `fnref-${normalizedId}`;
-      const backRefHtml = `<a href="#${escapeHtmlAttribute(backRefId)}" class="footnote-backref" aria-label="Back to content">&#8592;</a>`;
-      const noteHtml = renderDefinitionContent(footnoteDefinitions.get(id) || "", { appendHtml: backRefHtml });
-      return `<li id="fn-${escapeHtmlAttribute(normalizedId)}">${noteHtml}</li>`;
-    })
-    .join("");
+    if (closeIndex === -1) {
+      output.push(lines[index]);
+      index += 1;
+      continue;
+    }
 
-  if (!footnotesHtml) return markdownWithReferences;
-  return `${markdownWithReferences}\n\n<section class="footnotes"><hr><ol>${footnotesHtml}</ol></section>`;
+    const normalizedFence = marker.repeat(maxInnerFenceLength + 1);
+    output.push(`${indent}${normalizedFence}${opening[3]}${opening[4]}`);
+    output.push(...content);
+    output.push(`${indent}${normalizedFence}`);
+    index = closeIndex + 1;
+  }
+
+  return output.join('\n');
 }
 
 function configureMarked() {
@@ -199,7 +349,120 @@ function configureMarked() {
       return { type: "blockMath", raw: match[0], text: match[1] };
     },
     renderer(token) {
-      return `<div class="math-block">$$\n${token.text}\n$$</div>\n`;
+      return `<div class="math-block tex2jax_process">$$\n${escapeHtml(normalizeLegacyMathSyntax(token.text))}\n$$</div>\n`;
+    },
+  };
+
+  const footnoteDefinitionExtension = {
+    name: "footnoteDefinition",
+    level: "block",
+    start(src) {
+      const match = src.match(/(?:^|\n)[ \t]{0,3}\[\^[^\]\n]+\]:/);
+      if (!match) return undefined;
+      return match.index + (match[0][0] === "\n" ? 1 : 0);
+    },
+    tokenizer(src) {
+      if (suppressFootnotePreprocess) return undefined;
+      const lines = src.split("\n");
+      const match = /^([ \t]{0,3})\[\^([^\]\n]+)\]:[ \t]*(.*)$/.exec(lines[0]);
+      if (!match) return undefined;
+      const baseIndent = match[1] || "";
+      const id = normalizeFootnoteLabel(match[2]);
+      const definitionLines = [match[3] || ""];
+      const rawLines = [lines[0]];
+      let index = 1;
+      while (index < lines.length) {
+        const line = lines[index];
+        if (!line.startsWith(baseIndent)) break;
+        const lineAfterBase = line.slice(baseIndent.length);
+        const indentedMatch = /^(?: {2,}|\t)(.*)$/.exec(lineAfterBase);
+        if (indentedMatch) {
+          rawLines.push(line);
+          definitionLines.push(indentedMatch[1]);
+          index += 1;
+          continue;
+        }
+        if (lineAfterBase.trim() === "") {
+          const nextLine = lines[index + 1] || "";
+          const nextAfterBase = nextLine.startsWith(baseIndent) ? nextLine.slice(baseIndent.length) : "";
+          if (/^(?: {2,}|\t)/.test(nextAfterBase)) {
+            rawLines.push(line);
+            definitionLines.push("");
+            index += 1;
+            continue;
+          }
+        }
+        break;
+      }
+      let raw = rawLines.join("\n");
+      if (src.startsWith(raw + "\n")) raw += "\n";
+      if (id && !footnoteDefinitions.has(id)) {
+        footnoteDefinitions.set(id, definitionLines.join("\n").trim());
+      }
+      return { type: "footnoteDefinition", raw };
+    },
+    renderer() {
+      return "";
+    },
+  };
+
+  const footnoteReferenceExtension = {
+    name: "footnoteReference",
+    level: "inline",
+    start(src) {
+      if (suppressFootnotePreprocess) return undefined;
+      const index = src.indexOf("[^");
+      return index >= 0 ? index : undefined;
+    },
+    tokenizer(src) {
+      if (suppressFootnotePreprocess) return undefined;
+      const match = /^\[\^([^\]\n]+)\]/.exec(src);
+      if (!match) return undefined;
+      return { type: "footnoteReference", raw: match[0], id: match[1].trim() };
+    },
+    renderer(token) {
+      const id = normalizeFootnoteLabel(token.id);
+      if (!id || !footnoteDefinitions.has(id)) return escapeHtml(token.raw);
+      if (!footnoteOrder.includes(id)) footnoteOrder.push(id);
+      const refCount = (footnoteRefCounts.get(id) || 0) + 1;
+      footnoteRefCounts.set(id, refCount);
+      const slug = getFootnoteSlug(id);
+      const refId = getFootnoteReferenceId(id, refCount);
+      const noteNumber = footnoteOrder.indexOf(id) + 1;
+      return `<sup id="${escapeHtmlAttribute(refId)}" class="footnote-ref"><a href="#fn-${escapeHtmlAttribute(slug)}" aria-label="Footnote ${noteNumber}">[${noteNumber}]</a></sup>`;
+    },
+  };
+
+  const inlineMathExtension = {
+    name: "inlineMath",
+    level: "inline",
+    start(src) {
+      const match = INLINE_MATH_START_PATTERN.exec(src);
+      return match ? match.index : undefined;
+    },
+    tokenizer(src) {
+      if (src.startsWith("\\$")) return { type: "inlineMath", raw: "\\$", literalDollar: true };
+      if (src.startsWith("\\(") || src.startsWith("\\[")) {
+        const opening = src.slice(0, 2);
+        const closing = opening === "\\(" ? "\\)" : "\\]";
+        const closeIndex = findClosingMathDelimiter(src, closing, 2);
+        if (closeIndex >= 2) {
+          return {
+            type: "inlineMath",
+            raw: src.slice(0, closeIndex + 2),
+            display: opening === "\\[",
+          };
+        }
+        return undefined;
+      }
+      if (src[0] !== "$" || isEscapedCharacter(src, 0)) return undefined;
+      const mathToken = tokenizeDollarMath(src);
+      return mathToken || { type: "inlineMath", raw: "$", literalDollar: true };
+    },
+    renderer(token) {
+      if (token.literalDollar) return '<span class="math-literal-dollar tex2jax_ignore">&#36;</span>';
+      const displayClass = token.display ? ' math-display-inline' : '';
+      return `<span class="math-inline tex2jax_process${displayClass}">${escapeHtml(normalizeLegacyMathSyntax(token.raw))}</span>`;
     },
   };
 
@@ -211,16 +474,27 @@ function configureMarked() {
       return match ? match.index + 1 : undefined;
     },
     tokenizer(src) {
+      if (this.lexer && this.lexer.state && !this.lexer.state.top) return undefined;
       const lines = src.split("\n");
       if (lines.length < 2) return undefined;
 
-      const term = lines[0];
-      if (EMPTY_LINE_PATTERN.test(term) || MARKDOWN_LIST_MARKER_PATTERN.test(term)) return undefined;
-      if (!DEFINITION_LIST_ITEM_PATTERN.test(lines[1])) return undefined;
-
+      const terms = [];
+      const rawLines = [];
+      let index = 0;
+      while (index < lines.length && !DEFINITION_LIST_ITEM_PATTERN.test(lines[index])) {
+        const term = lines[index];
+        if (
+          EMPTY_LINE_PATTERN.test(term) ||
+          MARKDOWN_LIST_MARKER_PATTERN.test(term) ||
+          DEFINITION_LIST_DISALLOWED_TERM_PATTERN.test(term) ||
+          GFM_TABLE_DELIMITER_PATTERN.test(term)
+        ) return undefined;
+        terms.push(term.trim());
+        rawLines.push(term);
+        index += 1;
+      }
+      if (terms.length === 0 || index >= lines.length) return undefined;
       const definitions = [];
-      const rawLines = [term];
-      let index = 1;
       while (index < lines.length) {
         const itemMatch = DEFINITION_LIST_ITEM_PATTERN.exec(lines[index]);
         if (!itemMatch) break;
@@ -255,14 +529,16 @@ function configureMarked() {
       if (definitions.length === 0) return undefined;
       let raw = rawLines.join("\n");
       if (src.startsWith(raw + "\n")) raw += "\n";
-      return { type: "definitionList", raw, term: term.trim(), definitions };
+      return { type: "definitionList", raw, terms, definitions };
     },
     renderer(token) {
-      const termHtml = parseInlineWithoutFootnotes(token.term);
+      const termHtml = token.terms
+        .map((term) => `<dt>${parseInlineWithoutFootnotes(term)}</dt>`)
+        .join("");
       const definitionHtml = token.definitions
         .map((definition) => `<dd>${renderDefinitionContent(definition)}</dd>`)
         .join("");
-      return `<dl><dt>${termHtml}</dt>${definitionHtml}</dl>\n`;
+      return `<dl>${termHtml}${definitionHtml}</dl>\n`;
     },
   };
 
@@ -278,7 +554,7 @@ function configureMarked() {
       return match ? { type: "superscript", raw: match[0], text: match[1] } : undefined;
     },
     renderer(token) {
-      return `<sup>${marked.parseInline(token.text)}</sup>`;
+      return `<sup>${parseInlineWithoutFootnotes(token.text)}</sup>`;
     },
   };
 
@@ -294,7 +570,7 @@ function configureMarked() {
       return match ? { type: "subscript", raw: match[0], text: match[1] } : undefined;
     },
     renderer(token) {
-      return `<sub>${marked.parseInline(token.text)}</sub>`;
+      return `<sub>${parseInlineWithoutFootnotes(token.text)}</sub>`;
     },
   };
 
@@ -310,7 +586,7 @@ function configureMarked() {
       return match ? { type: "highlight", raw: match[0], text: match[1] } : undefined;
     },
     renderer(token) {
-      return `<mark>${marked.parseInline(token.text)}</mark>`;
+      return `<mark>${parseInlineWithoutFootnotes(token.text)}</mark>`;
     },
   };
 
@@ -379,7 +655,7 @@ function configureMarked() {
     }
 
     if (language === "math") {
-      return `<div class="math-block">$$\n${code}\n$$</div>\n`;
+      return `<div class="math-block tex2jax_process">$$\n${escapeHtml(normalizeLegacyMathSyntax(code))}\n$$</div>\n`;
     }
 
     const validLanguage = hljs && hljs.getLanguage(language) ? language : "plaintext";
@@ -390,16 +666,7 @@ function configureMarked() {
   };
 
   renderer.heading = function(text, level, raw) {
-    let id = raw
-      .toLowerCase()
-      .trim()
-      .replace(/<[^>]*>/g, '')
-      .replace(/\s+/g, '-')
-      .replace(/[^\w-]/g, '')
-      .replace(/-+/g, '-');
-    if (!id) {
-      id = `heading-worker-${Math.random().toString(36).substr(2, 9)}`;
-    }
+    const id = createUniqueHeadingId(raw);
     return `<h${level} id="${id}">${text}</h${level}>`;
   };
 
@@ -472,7 +739,10 @@ function configureMarked() {
   marked.use({
     extensions: [
       blockMathExtension,
+      footnoteDefinitionExtension,
       definitionListExtension,
+      inlineMathExtension,
+      footnoteReferenceExtension,
       superscriptExtension,
       subscriptExtension,
       highlightExtension,
@@ -480,10 +750,12 @@ function configureMarked() {
     hooks: {
       preprocess(markdown) {
         if (suppressFootnotePreprocess) return markdown;
-        resetExtendedMarkdownState();
-        const normalizedMarkdown = normalizeMarkmapFences(markdown);
-        const protectedMarkdown = normalizedMarkdown.replace(/\\\$/g, "&#36;");
-        return applyFootnotes(extractFootnoteDefinitions(protectedMarkdown));
+        if (!preserveExtendedMarkdownState) resetExtendedMarkdownState();
+        return normalizeMarkmapFences(markdown);
+      },
+      postprocess(html) {
+        if (suppressFootnotePreprocess) return html;
+        return html + renderFootnotesSection();
       },
     },
   });
@@ -508,6 +780,9 @@ function isSegmentedPreviewSafe(markdown) {
   if (/^\[[^\]\n]+\]:\s+\S+/m.test(markdown)) return false;
   if (/\[\^[^\]\n]+\]/.test(markdown)) return false;
   if (/\n:[ \t]+/.test(markdown)) return false;
+  if (/^[ \t]{0,3}(?:[*+-]|\d{1,9}[.)])(?:[ \t]+|$)/m.test(markdown)) return false;
+  if (/^(?: {4}|\t)\S/m.test(markdown)) return false;
+  if (/^[ \t]{0,3}(?:<!--|<\?|<![A-Z]|<!\[CDATA\[)/m.test(markdown)) return false;
   if (/^\s{0,3}<\/?[a-zA-Z][\w:-]*(?:\s|>|\/>)/m.test(markdown)) return false;
   return true;
 }
@@ -580,7 +855,7 @@ function splitMarkdownBlocks(markdown) {
 }
 
 function renderSegmentedMarkdown(markdown, options) {
-  const normalizedMarkdown = normalizeMarkmapFences(markdown);
+  const normalizedMarkdown = normalizeWorkerMarkmapFences(markdown);
   if (!isSegmentedPreviewSafe(normalizedMarkdown)) {
     return { mode: "full-required", reason: "unsafe-markdown" };
   }
@@ -591,21 +866,28 @@ function renderSegmentedMarkdown(markdown, options) {
   }
 
   const seenHashes = new Map();
-  const renderedBlocks = blocks.map((block) => {
-    const hash = hashString(block.source);
-    const seenCount = seenHashes.get(hash) || 0;
-    seenHashes.set(hash, seenCount + 1);
-    const html = marked.parse(block.source);
-    return {
-      id: `preview-block-${hash}-${seenCount}`,
-      hash,
-      html,
-      htmlLength: html.length,
-      sourceLength: block.source.length,
-      startLine: block.startLine,
-      endLine: block.endLine,
-    };
-  });
+  resetExtendedMarkdownState();
+  preserveExtendedMarkdownState = true;
+  let renderedBlocks;
+  try {
+    renderedBlocks = blocks.map((block) => {
+      const hash = hashString(block.source);
+      const seenCount = seenHashes.get(hash) || 0;
+      seenHashes.set(hash, seenCount + 1);
+      const html = marked.parse(block.source);
+      return {
+        id: `preview-block-${hash}-${seenCount}`,
+        hash,
+        html,
+        htmlLength: html.length,
+        sourceLength: block.source.length,
+        startLine: block.startLine,
+        endLine: block.endLine,
+      };
+    });
+  } finally {
+    preserveExtendedMarkdownState = false;
+  }
 
   return {
     mode: "segmented",
diff --git a/script.js b/script.js
index 40e4c56a..37db9652 100644
--- a/script.js
+++ b/script.js
@@ -2211,41 +2211,65 @@ document.addEventListener("DOMContentLoaded", async function () {
   const renderer = new marked.Renderer();
   const BLOCK_MATH_MARKER_PATTERN = /^\$\$/m;
   const BLOCK_MATH_PATTERN = /^\$\$[ \t]*\n?([\s\S]*?)\n?\$\$[ \t]*(?:\n|$)/;
+  const INLINE_MATH_START_PATTERN = /\\(?:\$|\(|\[)|\$/;
   const RAW_MATH_TEXT_PATTERN = /\$\$|\$[^$]|\\\(|\\\[/;
   const MATHJAX_TEXT_TARGET_SELECTOR = 'p, li, td, th, dd, dt, blockquote, figcaption, h1, h2, h3, h4, h5, h6, .math-block';
   const DEFINITION_LIST_ITEM_PATTERN = /^:[ \t]+(.*)$/;
   const SUPERSCRIPT_PATTERN = /^\^(?!\s)([^^\n]*?\S)\^(?!\^)/;
   const SUBSCRIPT_PATTERN = /^~(?!~)(?!\s)([^~\n]*?\S)~(?!~)/;
   const HIGHLIGHT_PATTERN = /^==(?=\S)([\s\S]*?\S)==/;
-  const MARKDOWN_LIST_MARKER_PATTERN = /^(\s*)(?:[-*+]\s+|\d+\.\s+|>\s+)/;
+  const MARKDOWN_LIST_MARKER_PATTERN = /^(\s*)(?:[-*+]\s+|\d{1,9}[.)]\s+|>\s*)/;
+  const DEFINITION_LIST_DISALLOWED_TERM_PATTERN = /^(?: {4}|\t|[ \t]{0,3}(?:`{3,}|~{3,}|#{1,6}(?:[ \t]+|$)|(?:[*_-][ \t]*){3,}$|[=-]+[ \t]*$|\[[^\]\n]+\]:[ \t]*\S|<!--|<\?|<![A-Z]|<!\[CDATA\[|<\/?[a-zA-Z][\w:-]*(?:\s|>|\/>)))/;
+  const GFM_TABLE_DELIMITER_PATTERN = /^[ \t]*\|?[ \t]*:?-+:?[ \t]*(?:\|[ \t]*:?-+:?[ \t]*)+\|?[ \t]*$/;
   const EMPTY_LINE_PATTERN = /^\s*$/;
   const footnoteDefinitions = new Map();
   const footnoteOrder = [];
   const footnoteRefCounts = new Map();
-  const footnoteFirstRefId = new Map();
-  let anonymousFootnoteCounter = 0;
+  const footnoteSlugs = new Map();
+  const usedFootnoteSlugs = new Set();
+  const usedHeadingIds = new Set();
   let suppressFootnotePreprocess = false;
 
   function resetExtendedMarkdownState() {
     footnoteDefinitions.clear();
     footnoteOrder.length = 0;
     footnoteRefCounts.clear();
-    footnoteFirstRefId.clear();
-    anonymousFootnoteCounter = 0;
+    footnoteSlugs.clear();
+    usedFootnoteSlugs.clear();
+    usedHeadingIds.clear();
   }
 
-  function normalizeFootnoteId(id) {
-    const normalized = String(id || "")
+  function normalizeFootnoteLabel(id) {
+    return String(id || "")
       .trim()
       .toLowerCase()
-      .replace(/[^a-z0-9_-]+/g, "-")
-      .replace(/^-+|-+$/g, "");
-    if (normalized) {
-      return normalized;
+      .replace(/\s+/g, " ");
+  }
+
+  function getFootnoteSlug(label) {
+    if (footnoteSlugs.has(label)) {
+      return footnoteSlugs.get(label);
     }
 
-    anonymousFootnoteCounter += 1;
-    return `footnote-${anonymousFootnoteCounter}`;
+    const baseSlug = String(label || "")
+      .replace(/\s+/g, "-")
+      .replace(/[^\p{L}\p{N}\p{M}_-]+/gu, "-")
+      .replace(/-+/g, "-")
+      .replace(/^-+|-+$/g, "") || "footnote";
+    let slug = baseSlug;
+    let suffix = 1;
+    while (usedFootnoteSlugs.has(slug)) {
+      slug = `${baseSlug}-${suffix}`;
+      suffix += 1;
+    }
+    usedFootnoteSlugs.add(slug);
+    footnoteSlugs.set(label, slug);
+    return slug;
+  }
+
+  function getFootnoteReferenceId(label, referenceNumber) {
+    const slug = getFootnoteSlug(label);
+    return `fnref-${slug}${referenceNumber > 1 ? `-${referenceNumber}` : ""}`;
   }
 
   function escapeHtmlAttribute(value) {
@@ -2311,6 +2335,9 @@ document.addEventListener("DOMContentLoaded", async function () {
     if (/^\[[^\]\n]+\]:\s+\S+/m.test(markdown)) return false;
     if (/\[\^[^\]\n]+\]/.test(markdown)) return false;
     if (/\n:[ \t]+/.test(markdown)) return false;
+    if (/^[ \t]{0,3}(?:[*+-]|\d{1,9}[.)])(?:[ \t]+|$)/m.test(markdown)) return false;
+    if (/^(?: {4}|\t)\S/m.test(markdown)) return false;
+    if (/^[ \t]{0,3}(?:<!--|<\?|<![A-Z]|<!\[CDATA\[)/m.test(markdown)) return false;
     if (/^\s{0,3}<\/?[a-zA-Z][\w:-]*(?:\s|>|\/>)/m.test(markdown)) return false;
     return true;
   }
@@ -2484,106 +2511,163 @@ document.addEventListener("DOMContentLoaded", async function () {
       .join("");
   }
 
-  function extractFootnoteDefinitions(markdown) {
-    const lines = markdown.split("\n");
-    const preservedLines = [];
-    let index = 0;
+  function renderFootnotesSection() {
+    const footnotesHtml = footnoteOrder
+      .filter((id) => footnoteDefinitions.has(id))
+      .map((id) => {
+        const slug = getFootnoteSlug(id);
+        const referenceCount = footnoteRefCounts.get(id) || 1;
+        const safeSlug = escapeHtmlAttribute(slug);
+        const backRefHtml = Array.from({ length: referenceCount }, (_, index) => {
+          const referenceNumber = index + 1;
+          const backRefId = escapeHtmlAttribute(getFootnoteReferenceId(id, referenceNumber));
+          const occurrenceLabel = referenceNumber > 1 ? ` ${referenceNumber}` : "";
+          const occurrenceMarker = referenceNumber > 1 ? `<sup>${referenceNumber}</sup>` : "";
+          return `<a href="#${backRefId}" class="footnote-backref" aria-label="Back to content${occurrenceLabel}">←${occurrenceMarker}</a>`;
+        }).join(" ");
+        const noteHtml = renderDefinitionContent(
+          footnoteDefinitions.get(id) || "",
+          { appendHtml: backRefHtml }
+        );
+        return `<li id="fn-${safeSlug}">${noteHtml}</li>`;
+      })
+      .join("");
 
-    while (index < lines.length) {
-      const match = /^([ \t]{0,3})\[\^([^\]\n]+)\]:[ \t]*(.*)$/.exec(lines[index]);
-      if (!match) {
-        preservedLines.push(lines[index]);
-        index += 1;
-        continue;
+    return footnotesHtml
+      ? `<section class="footnotes"><hr><ol>${footnotesHtml}</ol></section>`
+      : "";
+  }
+
+  function isEscapedCharacter(source, index) {
+    let backslashCount = 0;
+    for (let cursor = index - 1; cursor >= 0 && source[cursor] === "\\"; cursor -= 1) {
+      backslashCount += 1;
+    }
+    return backslashCount % 2 === 1;
+  }
+
+  function findClosingMathDelimiter(source, delimiter, startIndex) {
+    for (let index = startIndex; index <= source.length - delimiter.length; index += 1) {
+      if (source[index] === "\n") return -1;
+      if (source.startsWith(delimiter, index) && !isEscapedCharacter(source, index)) {
+        return index;
       }
+    }
+    return -1;
+  }
 
-      const baseIndent = match[1] || "";
-      const id = match[2].trim();
-      const definitionLines = [match[3] || ""];
-      index += 1;
+  function tokenizeDollarMath(source) {
+    if (source.startsWith("$$")) {
+      const closeIndex = findClosingMathDelimiter(source, "$$", 2);
+      if (closeIndex > 2) {
+        return {
+          type: "inlineMath",
+          raw: source.slice(0, closeIndex + 2),
+          display: true,
+        };
+      }
+      return null;
+    }
 
-      while (index < lines.length) {
-        const line = lines[index];
-        if (!line.startsWith(baseIndent)) {
-          break;
-        }
+    if (source[0] !== "$" || !source[1] || /[\s$]/.test(source[1])) {
+      return null;
+    }
 
-        const lineAfterBase = line.slice(baseIndent.length);
-        const indentedMatch = /^(?: {2,}|\t)(.*)$/.exec(lineAfterBase);
-        if (indentedMatch) {
-          definitionLines.push(indentedMatch[1]);
-          index += 1;
-          continue;
-        }
+    for (let index = 1; index < source.length; index += 1) {
+      if (source[index] === "\n") break;
+      if (source[index] !== "$" || isEscapedCharacter(source, index)) continue;
+      if (/\s/.test(source[index - 1]) || /\d/.test(source[index + 1] || "")) return null;
+      return {
+        type: "inlineMath",
+        raw: source.slice(0, index + 1),
+        display: false,
+      };
+    }
 
-        if (lineAfterBase.trim() === "") {
-          const nextLine = lines[index + 1] || "";
-          const nextAfterBase = nextLine.startsWith(baseIndent)
-            ? nextLine.slice(baseIndent.length)
-            : "";
-          if (/^(?: {2,}|\t)/.test(nextAfterBase)) {
-            definitionLines.push("");
-            index += 1;
-            continue;
-          }
-        }
+    return null;
+  }
 
-        break;
+  function readBalancedTexGroup(source, startIndex) {
+    if (source[startIndex] !== "{") return null;
+    let depth = 0;
+    for (let index = startIndex; index < source.length; index += 1) {
+      if (isEscapedCharacter(source, index)) continue;
+      if (source[index] === "{") {
+        depth += 1;
+      } else if (source[index] === "}") {
+        depth -= 1;
+        if (depth === 0) {
+          return { endIndex: index, content: source.slice(startIndex + 1, index) };
+        }
       }
-
-      footnoteDefinitions.set(id, definitionLines.join("\n").trim());
     }
-
-    return preservedLines.join("\n");
+    return null;
   }
 
-  function applyFootnotes(markdown) {
-    const markdownWithReferences = markdown.replace(/\[\^([^\]\n]+)\]/g, function(match, idText) {
-      const id = idText.trim();
-      if (!id) {
-        return match;
+  function normalizeLegacyMathSyntax(source) {
+    const tex = String(source || "");
+    let normalized = "";
+    let index = 0;
+
+    while (index < tex.length) {
+      if (tex.startsWith("\\^", index) && !isEscapedCharacter(tex, index)) {
+        normalized += "^";
+        index += 2;
+        continue;
       }
 
-      if (!footnoteOrder.includes(id)) {
-        footnoteOrder.push(id);
+      if (
+        !tex.startsWith("\\color", index) ||
+        isEscapedCharacter(tex, index) ||
+        /[a-zA-Z]/.test(tex[index + 6] || "")
+      ) {
+        normalized += tex[index];
+        index += 1;
+        continue;
       }
 
-      const refCount = (footnoteRefCounts.get(id) || 0) + 1;
-      footnoteRefCounts.set(id, refCount);
+      let colorGroupStart = index + 6;
+      while (/[ \t]/.test(tex[colorGroupStart] || "")) colorGroupStart += 1;
+      const colorGroup = readBalancedTexGroup(tex, colorGroupStart);
+      if (!colorGroup) {
+        normalized += tex[index];
+        index += 1;
+        continue;
+      }
 
-      const normalizedId = normalizeFootnoteId(id);
-      const refId = `fnref-${normalizedId}${refCount > 1 ? `-${refCount}` : ""}`;
-      if (!footnoteFirstRefId.has(id)) {
-        footnoteFirstRefId.set(id, refId);
+      let contentGroupStart = colorGroup.endIndex + 1;
+      while (/[ \t]/.test(tex[contentGroupStart] || "")) contentGroupStart += 1;
+      const contentGroup = readBalancedTexGroup(tex, contentGroupStart);
+      if (!contentGroup) {
+        normalized += tex[index];
+        index += 1;
+        continue;
       }
 
-      const noteNumber = footnoteOrder.indexOf(id) + 1;
-      const safeRefId = escapeHtmlAttribute(refId);
-      const safeNormalizedId = escapeHtmlAttribute(normalizedId);
-      return `<sup id="${safeRefId}" class="footnote-ref"><a href="#fn-${safeNormalizedId}" aria-label="Footnote ${noteNumber}">[${noteNumber}]</a></sup>`;
-    });
+      normalized += `{\\color{${colorGroup.content}}${normalizeLegacyMathSyntax(contentGroup.content)}}`;
+      index = contentGroup.endIndex + 1;
+    }
 
-    const footnotesHtml = footnoteOrder
-      .filter((id) => footnoteDefinitions.has(id))
-      .map((id) => {
-        const normalizedId = normalizeFootnoteId(id);
-        const backRefId = footnoteFirstRefId.get(id) || `fnref-${normalizedId}`;
-        const safeNormalizedId = escapeHtmlAttribute(normalizedId);
-        const safeBackRefId = escapeHtmlAttribute(backRefId);
-        const backRefHtml = `<a href="#${safeBackRefId}" class="footnote-backref" aria-label="Back to content">←</a>`;
-        const noteHtml = renderDefinitionContent(
-          footnoteDefinitions.get(id) || "",
-          { appendHtml: backRefHtml }
-        );
-        return `<li id="fn-${safeNormalizedId}">${noteHtml}</li>`;
-      })
-      .join("");
+    return normalized;
+  }
 
-    if (!footnotesHtml) {
-      return markdownWithReferences;
+  function createUniqueHeadingId(raw) {
+    const baseId = String(raw || "")
+      .toLowerCase()
+      .trim()
+      .replace(/<[^>]*>/g, '')
+      .replace(/\s+/g, '-')
+      .replace(/[^\p{L}\p{N}\p{M}_-]/gu, '')
+      .replace(/-+/g, '-')
+      .replace(/^-+|-+$/g, '') || 'heading';
+    let id = baseId;
+    let suffix = 0;
+    while (usedHeadingIds.has(id)) {
+      suffix += 1;
+      id = `${baseId}-${suffix}`;
     }
-
-    return `${markdownWithReferences}\n\n<section class="footnotes"><hr><ol>${footnotesHtml}</ol></section>`;
+    usedHeadingIds.add(id);
+    return id;
   }
 
   const blockMathExtension = {
@@ -2608,9 +2692,127 @@ document.addEventListener("DOMContentLoaded", async function () {
       };
     },
     renderer(token) {
-      return `<div class="math-block">$$\n${token.text}\n$$</div>\n`;
+      return `<div class="math-block tex2jax_process">$$\n${escapeHtml(normalizeLegacyMathSyntax(token.text))}\n$$</div>\n`;
     }
   };
+  const footnoteDefinitionExtension = {
+    name: "footnoteDefinition",
+    level: "block",
+    start(src) {
+      const match = src.match(/(?:^|\n)[ \t]{0,3}\[\^[^\]\n]+\]:/);
+      if (!match) return undefined;
+      return match.index + (match[0][0] === "\n" ? 1 : 0);
+    },
+    tokenizer(src) {
+      if (suppressFootnotePreprocess) return undefined;
+      const lines = src.split("\n");
+      const match = /^([ \t]{0,3})\[\^([^\]\n]+)\]:[ \t]*(.*)$/.exec(lines[0]);
+      if (!match) return undefined;
+
+      const baseIndent = match[1] || "";
+      const id = normalizeFootnoteLabel(match[2]);
+      const definitionLines = [match[3] || ""];
+      const rawLines = [lines[0]];
+      let index = 1;
+      while (index < lines.length) {
+        const line = lines[index];
+        if (!line.startsWith(baseIndent)) break;
+        const lineAfterBase = line.slice(baseIndent.length);
+        const indentedMatch = /^(?: {2,}|\t)(.*)$/.exec(lineAfterBase);
+        if (indentedMatch) {
+          rawLines.push(line);
+          definitionLines.push(indentedMatch[1]);
+          index += 1;
+          continue;
+        }
+        if (lineAfterBase.trim() === "") {
+          const nextLine = lines[index + 1] || "";
+          const nextAfterBase = nextLine.startsWith(baseIndent)
+            ? nextLine.slice(baseIndent.length)
+            : "";
+          if (/^(?: {2,}|\t)/.test(nextAfterBase)) {
+            rawLines.push(line);
+            definitionLines.push("");
+            index += 1;
+            continue;
+          }
+        }
+        break;
+      }
+
+      let raw = rawLines.join("\n");
+      if (src.startsWith(raw + "\n")) raw += "\n";
+      if (id && !footnoteDefinitions.has(id)) {
+        footnoteDefinitions.set(id, definitionLines.join("\n").trim());
+      }
+      return { type: "footnoteDefinition", raw };
+    },
+    renderer() {
+      return "";
+    },
+  };
+  const footnoteReferenceExtension = {
+    name: "footnoteReference",
+    level: "inline",
+    start(src) {
+      if (suppressFootnotePreprocess) return undefined;
+      const index = src.indexOf("[^");
+      return index >= 0 ? index : undefined;
+    },
+    tokenizer(src) {
+      if (suppressFootnotePreprocess) return undefined;
+      const match = /^\[\^([^\]\n]+)\]/.exec(src);
+      if (!match) return undefined;
+      return { type: "footnoteReference", raw: match[0], id: match[1].trim() };
+    },
+    renderer(token) {
+      const id = normalizeFootnoteLabel(token.id);
+      if (!id || !footnoteDefinitions.has(id)) return escapeHtml(token.raw);
+      if (!footnoteOrder.includes(id)) footnoteOrder.push(id);
+      const refCount = (footnoteRefCounts.get(id) || 0) + 1;
+      footnoteRefCounts.set(id, refCount);
+      const slug = getFootnoteSlug(id);
+      const refId = getFootnoteReferenceId(id, refCount);
+      const noteNumber = footnoteOrder.indexOf(id) + 1;
+      return `<sup id="${escapeHtmlAttribute(refId)}" class="footnote-ref"><a href="#fn-${escapeHtmlAttribute(slug)}" aria-label="Footnote ${noteNumber}">[${noteNumber}]</a></sup>`;
+    },
+  };
+  const inlineMathExtension = {
+    name: "inlineMath",
+    level: "inline",
+    start(src) {
+      const match = INLINE_MATH_START_PATTERN.exec(src);
+      return match ? match.index : undefined;
+    },
+    tokenizer(src) {
+      if (src.startsWith("\\$")) {
+        return { type: "inlineMath", raw: "\\$", literalDollar: true };
+      }
+      if (src.startsWith("\\(") || src.startsWith("\\[")) {
+        const opening = src.slice(0, 2);
+        const closing = opening === "\\(" ? "\\)" : "\\]";
+        const closeIndex = findClosingMathDelimiter(src, closing, 2);
+        if (closeIndex >= 2) {
+          return {
+            type: "inlineMath",
+            raw: src.slice(0, closeIndex + 2),
+            display: opening === "\\[",
+          };
+        }
+        return undefined;
+      }
+      if (src[0] !== "$" || isEscapedCharacter(src, 0)) return undefined;
+      const mathToken = tokenizeDollarMath(src);
+      return mathToken || { type: "inlineMath", raw: "$", literalDollar: true };
+    },
+    renderer(token) {
+      if (token.literalDollar) {
+        return '<span class="math-literal-dollar tex2jax_ignore">&#36;</span>';
+      }
+      const displayClass = token.display ? ' math-display-inline' : '';
+      return `<span class="math-inline tex2jax_process${displayClass}">${escapeHtml(normalizeLegacyMathSyntax(token.raw))}</span>`;
+    },
+  };
   const definitionListExtension = {
     name: "definitionList",
     level: "block",
@@ -2622,23 +2824,29 @@ document.addEventListener("DOMContentLoaded", async function () {
       return match.index + 1;
     },
     tokenizer(src) {
+      if (this.lexer && this.lexer.state && !this.lexer.state.top) return undefined;
       const lines = src.split("\n");
       if (lines.length < 2) {
         return undefined;
       }
 
-      const term = lines[0];
-      if (EMPTY_LINE_PATTERN.test(term) || MARKDOWN_LIST_MARKER_PATTERN.test(term)) {
-        return undefined;
-      }
-
-      if (!DEFINITION_LIST_ITEM_PATTERN.test(lines[1])) {
-        return undefined;
+      const terms = [];
+      const rawLines = [];
+      let index = 0;
+      while (index < lines.length && !DEFINITION_LIST_ITEM_PATTERN.test(lines[index])) {
+        const term = lines[index];
+        if (
+          EMPTY_LINE_PATTERN.test(term) ||
+          MARKDOWN_LIST_MARKER_PATTERN.test(term) ||
+          DEFINITION_LIST_DISALLOWED_TERM_PATTERN.test(term) ||
+          GFM_TABLE_DELIMITER_PATTERN.test(term)
+        ) return undefined;
+        terms.push(term.trim());
+        rawLines.push(term);
+        index += 1;
       }
-
+      if (terms.length === 0 || index >= lines.length) return undefined;
       const definitions = [];
-      const rawLines = [term];
-      let index = 1;
       while (index < lines.length) {
         const itemMatch = DEFINITION_LIST_ITEM_PATTERN.exec(lines[index]);
         if (!itemMatch) {
@@ -2689,16 +2897,18 @@ document.addEventListener("DOMContentLoaded", async function () {
       return {
         type: "definitionList",
         raw: raw,
-        term: term.trim(),
+        terms: terms,
         definitions: definitions,
       };
     },
     renderer(token) {
-      const termHtml = parseInlineWithoutFootnotes(token.term);
+      const termHtml = token.terms
+        .map((term) => `<dt>${parseInlineWithoutFootnotes(term)}</dt>`)
+        .join("");
       const definitionHtml = token.definitions
         .map((definition) => `<dd>${renderDefinitionContent(definition)}</dd>`)
         .join("");
-      return `<dl><dt>${termHtml}</dt>${definitionHtml}</dl>\n`;
+      return `<dl>${termHtml}${definitionHtml}</dl>\n`;
     },
   };
   const superscriptExtension = {
@@ -2720,7 +2930,7 @@ document.addEventListener("DOMContentLoaded", async function () {
       };
     },
     renderer(token) {
-      return `<sup>${marked.parseInline(token.text)}</sup>`;
+      return `<sup>${parseInlineWithoutFootnotes(token.text)}</sup>`;
     },
   };
   const subscriptExtension = {
@@ -2742,7 +2952,7 @@ document.addEventListener("DOMContentLoaded", async function () {
       };
     },
     renderer(token) {
-      return `<sub>${marked.parseInline(token.text)}</sub>`;
+      return `<sub>${parseInlineWithoutFootnotes(token.text)}</sub>`;
     },
   };
   const highlightExtension = {
@@ -2764,7 +2974,7 @@ document.addEventListener("DOMContentLoaded", async function () {
       };
     },
     renderer(token) {
-      return `<mark>${marked.parseInline(token.text)}</mark>`;
+      return `<mark>${parseInlineWithoutFootnotes(token.text)}</mark>`;
     },
   };
 
@@ -2852,7 +3062,7 @@ document.addEventListener("DOMContentLoaded", async function () {
     }
 
     if (language === 'math') {
-      return `<div class="math-block">$$\n${code}\n$$</div>\n`;
+      return `<div class="math-block tex2jax_process">$$\n${escapeHtml(normalizeLegacyMathSyntax(code))}\n$$</div>\n`;
     }
     
     const validLanguage = hljs.getLanguage(language) ? language : "plaintext";
@@ -2863,16 +3073,7 @@ document.addEventListener("DOMContentLoaded", async function () {
   };
 
   renderer.heading = function (text, level, raw) {
-    let id = raw
-      .toLowerCase()
-      .trim()
-      .replace(/<[^>]*>/g, '')
-      .replace(/\s+/g, '-')
-      .replace(/[^\w-]/g, '')
-      .replace(/-+/g, '-');
-    if (!id) {
-      id = 'heading-' + Math.random().toString(36).substr(2, 9);
-    }
+    const id = createUniqueHeadingId(raw);
     return `<h${level} id="${id}">${text}</h${level}>`;
   };
 
@@ -2945,7 +3146,10 @@ document.addEventListener("DOMContentLoaded", async function () {
   marked.use({
     extensions: [
       blockMathExtension,
+      footnoteDefinitionExtension,
       definitionListExtension,
+      inlineMathExtension,
+      footnoteReferenceExtension,
       superscriptExtension,
       subscriptExtension,
       highlightExtension,
@@ -2956,11 +3160,11 @@ document.addEventListener("DOMContentLoaded", async function () {
           return markdown;
         }
         resetExtendedMarkdownState();
-        // ✅ Replace escaped dollar signs before marked.js strips the backslash.
-        // This prevents MathJax from treating lone $ as a math delimiter.
-        const normalizedMarkdown = normalizeMarkmapFences(markdown);
-        const protectedMarkdown = normalizedMarkdown.replace(/\\\$/g, '&#36;');
-        return applyFootnotes(extractFootnoteDefinitions(protectedMarkdown));
+        return normalizeMarkmapFences(markdown);
+      },
+      postprocess(html) {
+        if (suppressFootnotePreprocess) return html;
+        return html + renderFootnotesSection();
       },
     },
   });
diff --git a/tests/e2e/data-loss-hardening.spec.js b/tests/e2e/data-loss-hardening.spec.js
index f465e52e..3c5d6c05 100644
--- a/tests/e2e/data-loss-hardening.spec.js
+++ b/tests/e2e/data-loss-hardening.spec.js
@@ -341,6 +341,7 @@ test('IndexedDB fallback journal recovers a normal edit when localStorage is ful
 test('encrypted dirty journal restores the latest Secret Workspace edit after abrupt close', async ({ context, page }) => {
   await openApp(page);
   await page.locator('.document-tree-row[data-tree-id="workspace_secret"] .document-tree-main').click();
+  await expect(page.locator('#secret-workspace-key')).toBeFocused();
   await page.locator('#secret-workspace-key').fill('durable-secret-key');
   await page.locator('#secret-workspace-key-confirm').fill('durable-secret-key');
   await page.locator('#secret-workspace-modal-confirm').click();
@@ -365,6 +366,7 @@ test('encrypted dirty journal restores the latest Secret Workspace edit after ab
   const reopened = await context.newPage();
   await openApp(reopened);
   await reopened.locator('.document-tree-row[data-tree-id="workspace_secret"] .document-tree-main').click();
+  await expect(reopened.locator('#secret-workspace-key')).toBeFocused();
   await reopened.locator('#secret-workspace-key').fill('durable-secret-key');
   await reopened.locator('#secret-workspace-modal-confirm').click();
   await expect(reopened.locator('#secret-workspace-modal')).toBeHidden();
diff --git a/tests/e2e/formatting-regressions.spec.js b/tests/e2e/formatting-regressions.spec.js
new file mode 100644
index 00000000..e8c8bb0f
--- /dev/null
+++ b/tests/e2e/formatting-regressions.spec.js
@@ -0,0 +1,391 @@
+const { test, expect } = require('@playwright/test');
+const { openApp, setEditorContent } = require('../helpers/app');
+
+test.beforeEach(async ({ page }) => {
+  await openApp(page);
+});
+
+test('de-duplicates heading ids and resets slug state for each render', async ({ page }) => {
+  await setEditorContent(page, [
+    '#### Test',
+    'First section',
+    '',
+    '#### Test',
+    'Second section',
+    '',
+    '#### Test-1',
+    'Explicit suffix collision',
+    '',
+    '#### Test',
+    'Third duplicate',
+    '',
+    '[Second heading](#test-1)'
+  ].join('\n'));
+
+  await expect(page.locator('#markdown-preview h4')).toHaveCount(4);
+  await expect(page.locator('#markdown-preview h4').first()).toHaveAttribute('id', 'test');
+  await expect(page.locator('#markdown-preview h4').nth(1)).toHaveAttribute('id', 'test-1');
+  await expect(page.locator('#markdown-preview h4').nth(2)).toHaveAttribute('id', 'test-1-1');
+  await expect(page.locator('#markdown-preview h4').nth(3)).toHaveAttribute('id', 'test-2');
+
+  await expect(page.locator('#markdown-preview a[href="#test-1"]')).toHaveAttribute('href', '#test-1');
+  await page.locator('#markdown-preview a[href="#test-1"]').click();
+  await expect(page.locator('#test-1')).toHaveText('Test');
+
+  await setEditorContent(page, '# Test');
+  await expect(page.locator('#markdown-preview h1')).toHaveAttribute('id', 'test');
+});
+
+test('preserves Unicode in heading ids and gives empty slugs stable fallbacks', async ({ page }) => {
+  await setEditorContent(page, [
+    '# 你好 世界',
+    '',
+    '# Café déjà vu',
+    '',
+    '# 🎉',
+    '',
+    '# 🎉',
+    '',
+    '[Jump to Chinese heading](#你好-世界)'
+  ].join('\n'));
+
+  const headings = page.locator('#markdown-preview h1');
+  await expect(headings).toHaveCount(4);
+  await expect(headings.nth(0)).toHaveAttribute('id', '你好-世界');
+  await expect(headings.nth(1)).toHaveAttribute('id', 'café-déjà-vu');
+  await expect(headings.nth(2)).toHaveAttribute('id', 'heading');
+  await expect(headings.nth(3)).toHaveAttribute('id', 'heading-1');
+  await expect(page.locator('#markdown-preview a')).toHaveAttribute(
+    'href',
+    '#%E4%BD%A0%E5%A5%BD-%E4%B8%96%E7%95%8C'
+  );
+  await expect(page.locator('#markdown-preview a')).toHaveJSProperty('hash', '#%E4%BD%A0%E5%A5%BD-%E4%B8%96%E7%95%8C');
+  await expect.poll(() => page.evaluate(() => {
+    const href = document.querySelector('#markdown-preview a').getAttribute('href');
+    return Boolean(document.getElementById(decodeURIComponent(href.slice(1))));
+  })).toBe(true);
+});
+
+test('de-duplicates headings across segmented worker blocks', async ({ page }) => {
+  const blocks = ['# Worker duplicate'];
+  for (let index = 0; index < 75; index += 1) {
+    blocks.push(`Paragraph ${index} ${'worker filler '.repeat(70)}`);
+  }
+  blocks.splice(40, 0, '# Worker duplicate');
+
+  await setEditorContent(page, blocks.join('\n\n'));
+
+  await expect(page.locator('#markdown-preview .preview-render-block')).not.toHaveCount(0);
+  await expect(page.locator('#markdown-preview h1')).toHaveCount(2);
+  await expect(page.locator('#markdown-preview h1').first()).toHaveAttribute('id', 'worker-duplicate');
+  await expect(page.locator('#markdown-preview h1').last()).toHaveAttribute('id', 'worker-duplicate-1');
+});
+
+test('uses full parsing for large documents with cross-block Markdown constructs', async ({ page }) => {
+  const filler = Array.from(
+    { length: 75 },
+    (_, index) => `Paragraph ${index} ${'large document filler '.repeat(45)}`
+  ).join('\n\n');
+
+  await setEditorContent(page, [
+    '- item one',
+    '',
+    '  continuation paragraph',
+    '',
+    '- item two',
+    '',
+    filler
+  ].join('\n'));
+
+  await expect(page.locator('#markdown-preview .preview-render-block')).toHaveCount(0);
+  await expect(page.locator('#markdown-preview > ul')).toHaveCount(1);
+  await expect(page.locator('#markdown-preview > ul > li')).toHaveCount(2);
+  await expect(page.locator('#markdown-preview > ul > li').first()).toContainText('continuation paragraph');
+
+  await setEditorContent(page, [
+    '    line one',
+    '',
+    '    line two',
+    '',
+    filler
+  ].join('\n'));
+
+  await expect(page.locator('#markdown-preview .preview-render-block')).toHaveCount(0);
+  await expect(page.locator('#markdown-preview pre code')).toHaveCount(1);
+  await expect(page.locator('#markdown-preview pre code')).toHaveText('line one\n\nline two\n');
+
+  await setEditorContent(page, [
+    '<!--',
+    'hidden first',
+    '',
+    'hidden second',
+    '-->',
+    '',
+    'Visible content.',
+    '',
+    filler
+  ].join('\n'));
+
+  await expect(page.locator('#markdown-preview .preview-render-block')).toHaveCount(0);
+  await expect(page.locator('#markdown-preview')).not.toContainText('hidden first');
+  await expect(page.locator('#markdown-preview')).not.toContainText('hidden second');
+  await expect(page.locator('#markdown-preview')).toContainText('Visible content.');
+});
+
+test('keeps GFM lists separated when the bullet character changes', async ({ page }) => {
+  await setEditorContent(page, [
+    '- List 1, item 1',
+    '- List 1, item 2',
+    '* List 2, item 1',
+    '',
+    '+ Same marker, item 1',
+    '+ Same marker, item 2'
+  ].join('\n'));
+
+  const lists = page.locator('#markdown-preview > ul');
+  await expect(lists).toHaveCount(3);
+  await expect(lists.nth(0).locator('li')).toHaveCount(2);
+  await expect(lists.nth(1).locator('li')).toHaveCount(1);
+  await expect(lists.nth(2).locator('li')).toHaveCount(2);
+});
+
+test('distinguishes currency, escaped dollars, and valid inline math', async ({ page }) => {
+  await setEditorContent(page, [
+    'Options ran $20, $45, and $99 for the three tiers.',
+    '',
+    'Escaped prices cost \\$20, \\$45, and \\$99.',
+    '',
+    'Before text $x_1^2$ then $x_2^2$ after text.',
+    '',
+    'A dollar inside math: $\\sqrt{\\$4}$.',
+    '',
+    'Mixed price and math: $20 plus $x^2$.',
+    '',
+    'Whitespace is literal: $ not math$ and $not math $.',
+    '',
+    'Digit adjacency is literal: $x$5.'
+  ].join('\n'));
+
+  const paragraphs = page.locator('#markdown-preview > p');
+  await expect(paragraphs.nth(0)).toContainText('Options ran $20, $45, and $99 for the three tiers.');
+  await expect(paragraphs.nth(0).locator('.math-inline')).toHaveCount(0);
+  await expect(paragraphs.nth(0).locator('.math-literal-dollar')).toHaveCount(3);
+  await expect(paragraphs.nth(1)).toContainText('Escaped prices cost $20, $45, and $99.');
+  await expect(paragraphs.nth(1).locator('.math-inline')).toHaveCount(0);
+  await expect(paragraphs.nth(1).locator('.math-literal-dollar')).toHaveCount(3);
+  await expect(page.locator('#markdown-preview .math-inline')).toHaveCount(4);
+  await expect(page.locator('#markdown-preview .math-inline').nth(0)).toHaveText('$x_1^2$');
+  await expect(page.locator('#markdown-preview .math-inline').nth(1)).toHaveText('$x_2^2$');
+  await expect(page.locator('#markdown-preview .math-inline').nth(2)).toHaveText('$\\sqrt{\\$4}$');
+  await expect(page.locator('#markdown-preview .math-inline').nth(3)).toHaveText('$x^2$');
+  await expect(paragraphs.nth(4)).toContainText('Mixed price and math: $20 plus');
+  await expect(paragraphs.nth(4).locator('.math-literal-dollar')).toHaveCount(1);
+});
+
+test('does not transform dollars or footnotes inside code', async ({ page }) => {
+  await setEditorContent(page, [
+    '~~~md',
+    'Options ran \\$20, \\$45, and \\$99.',
+    '[^fenced]: must stay code',
+    '~~~',
+    '',
+    'Inline code: `[^inline]: must stay code` and `\\$20`.',
+    '',
+    'Real note[^note] and repeated note[^note].',
+    '',
+    '[^note]: Footnote body.',
+    '  Continued body.'
+  ].join('\n'));
+
+  await expect(page.locator('#markdown-preview pre code')).toHaveText([
+    'Options ran \\$20, \\$45, and \\$99.',
+    '[^fenced]: must stay code'
+  ].join('\n'));
+  await expect(page.locator('#markdown-preview p code').nth(0)).toHaveText('[^inline]: must stay code');
+  await expect(page.locator('#markdown-preview p code').nth(1)).toHaveText('\\$20');
+  await expect(page.locator('#markdown-preview .footnote-ref')).toHaveCount(2);
+  await expect(page.locator('#fnref-note')).toHaveText('[1]');
+  await expect(page.locator('#fnref-note-2')).toHaveText('[1]');
+  await expect(page.locator('#markdown-preview .footnotes')).toContainText('Footnote body.');
+  await expect(page.locator('#markdown-preview .footnotes')).toContainText('Continued body.');
+});
+
+test('matches footnote labels case-insensitively and links every defined reference', async ({ page }) => {
+  await setEditorContent(page, [
+    'Undefined[^missing].',
+    '',
+    'Case reference[^Note].',
+    '',
+    'Repeated[^repeat] and again[^REPEAT].',
+    '',
+    'Slug collision[^a!] and another[^a?].',
+    '',
+    '[^note]: Case-insensitive definition.',
+    '[^repeat]: Repeated definition.',
+    '[^a!]: First collision definition.',
+    '[^a?]: Second collision definition.'
+  ].join('\n'));
+
+  await expect(page.locator('#markdown-preview > p').first()).toContainText('Undefined[^missing].');
+  await expect(page.locator('#markdown-preview .footnote-ref')).toHaveText(['[1]', '[2]', '[2]', '[3]', '[4]']);
+  await expect(page.locator('#markdown-preview .footnotes li')).toHaveCount(4);
+  await expect(page.locator('#fn-note')).toContainText('Case-insensitive definition.');
+  await expect(page.locator('#fn-repeat')).toContainText('Repeated definition.');
+  await expect(page.locator('#fn-a')).toContainText('First collision definition.');
+  await expect(page.locator('#fn-a-1')).toContainText('Second collision definition.');
+
+  const repeatedBackrefs = page.locator('#fn-repeat .footnote-backref');
+  await expect(repeatedBackrefs).toHaveCount(2);
+  await expect(repeatedBackrefs.nth(0)).toHaveAttribute('href', '#fnref-repeat');
+  await expect(repeatedBackrefs.nth(1)).toHaveAttribute('href', '#fnref-repeat-2');
+  await expect(repeatedBackrefs.nth(1)).toContainText('2');
+});
+
+test('supports Markdown Extra multi-term definition lists without changing ordinary prose', async ({ page }) => {
+  await setEditorContent(page, [
+    '~~~md',
+    'Code term A',
+    'Code term B',
+    ': Must stay literal code',
+    '~~~',
+    '',
+    'Term A',
+    'Term B',
+    ': Shared definition for both terms above',
+    ': Alternate shared definition',
+    '',
+    'Single term',
+    ': Single definition',
+    '',
+    'Ordinary line A',
+    'Ordinary line B'
+  ].join('\n'));
+
+  const lists = page.locator('#markdown-preview dl');
+  await expect(lists).toHaveCount(2);
+  await expect(page.locator('#markdown-preview pre code')).toContainText(': Must stay literal code');
+  await expect(lists.nth(0).locator('dt')).toHaveText(['Term A', 'Term B']);
+  await expect(lists.nth(0).locator('dd')).toHaveText([
+    'Shared definition for both terms above',
+    'Alternate shared definition'
+  ]);
+  await expect(lists.nth(1).locator('dt')).toHaveText(['Single term']);
+  await expect(page.locator('#markdown-preview > p').last()).toContainText('Ordinary line A');
+  await expect(page.locator('#markdown-preview > p').last()).toContainText('Ordinary line B');
+});
+
+test('does not let definition lists preempt GFM and CommonMark block constructs', async ({ page }) => {
+  await setEditorContent(page, [
+    '1) Ordered item',
+    ': lazy continuation in the list',
+    '',
+    'Setext heading',
+    '---',
+    ': paragraph after the heading',
+    '',
+    '***',
+    ': paragraph after the thematic break',
+    '',
+    '    indented code',
+    ': paragraph after the code',
+    '',
+    '[ref]: https://example.com',
+    ': paragraph after the reference definition',
+    '',
+    '[uses ref][ref]',
+    '',
+    'A | B',
+    '--- | ---',
+    ': table row'
+  ].join('\n'));
+
+  await expect(page.locator('#markdown-preview dl')).toHaveCount(0);
+  await expect(page.locator('#markdown-preview ol')).toHaveCount(1);
+  await expect(page.locator('#markdown-preview ol')).toContainText(': lazy continuation in the list');
+  await expect(page.locator('#markdown-preview h2')).toHaveText('Setext heading');
+  await expect(page.locator('#markdown-preview hr')).toHaveCount(1);
+  await expect(page.locator('#markdown-preview pre code')).toHaveText('indented code\n');
+  await expect(page.locator('#markdown-preview a[href="https://example.com"]')).toHaveText('uses ref');
+  await expect(page.locator('#markdown-preview table')).toHaveCount(1);
+  await expect(page.locator('#markdown-preview table tbody td').first()).toHaveText(': table row');
+});
+
+test('keeps TeX atomic while preserving superscript, subscript, and highlight outside math', async ({ page }) => {
+  await setEditorContent(page, [
+    'Outside ^two^, ~down~, and ==marked==.',
+    '',
+    'Before text $x_1^2$ then $x_2^2$ after text.',
+    '',
+    'Before text $right\\_ascension = 5h35m$ after text.',
+    '',
+    'Before text $\\left\\{ x \\mid x > 0 \\right\\}$ after text.',
+    '',
+    '$A_cE\\left\\{-\\dfrac{du(x_1)}{dx},\\ \\dfrac{du(x_2)}{dx}\\right\\}$',
+    '',
+    'Other delimiters: \\(x^2\\) and \\[y^2\\].',
+    '',
+    '$$',
+    'A_cE\\left\\{-\\dfrac{du(x_1)}{dx},\\ \\dfrac{du(x_2)}{dx}\\right\\}',
+    '$$'
+  ].join('\n'));
+
+  await expect(page.locator('#markdown-preview')).toContainText('Outside two, down, and marked.');
+  await expect(page.locator('#markdown-preview > p sup')).toHaveText('two');
+  await expect(page.locator('#markdown-preview > p sub')).toHaveText('down');
+  await expect(page.locator('#markdown-preview > p mark')).toHaveText('marked');
+
+  const math = page.locator('#markdown-preview .math-inline');
+  await expect(math).toHaveCount(7);
+  await expect(math.nth(0)).toHaveText('$x_1^2$');
+  await expect(math.nth(1)).toHaveText('$x_2^2$');
+  await expect(math.nth(2)).toHaveText('$right\\_ascension = 5h35m$');
+  await expect(math.nth(3)).toHaveText('$\\left\\{ x \\mid x > 0 \\right\\}$');
+  await expect(math.nth(4)).toHaveText('$A_cE\\left\\{-\\dfrac{du(x_1)}{dx},\\ \\dfrac{du(x_2)}{dx}\\right\\}$');
+  await expect(math.nth(5)).toHaveText('\\(x^2\\)');
+  await expect(math.nth(6)).toHaveText('\\[y^2\\]');
+  await expect(page.locator('#markdown-preview .math-block')).toContainText('A_cE\\left\\{');
+});
+
+test('scopes legacy MathJax color syntax without changing standard switches or sanitization', async ({ page }) => {
+  await setEditorContent(page, [
+    '$\\color{red}{v\\^2} \\color{blue}{G}M\\left(\\color{green}{\\frac{2}{r}} - \\color{purple}{\\frac{1}{a}}\\right)$',
+    '',
+    '${\\color{red}v^2} + \\textcolor{blue}{G}M$',
+    '',
+    '$\\color{red}{outer \\color{blue}{inner} outer} + z$',
+    '',
+    '$\\color{orange} x + y$',
+    '',
+    '$$',
+    '\\color{teal}{A_{nested}}',
+    '$$',
+    '',
+    '```math',
+    '\\color{brown}{B^2}',
+    '```',
+    '',
+    '$x <svg onload="window.__mathXss = true"></svg> y$',
+    '',
+    'Safe note[^safe].',
+    '',
+    '[^safe]: <img src="x" onerror="window.__footnoteXss = true"> body'
+  ].join('\n'));
+
+  const math = page.locator('#markdown-preview .math-inline');
+  await expect(math).toHaveCount(5);
+  await expect(math.nth(0)).toContainText('${\\color{red}v^2} {\\color{blue}G}M\\left({\\color{green}\\frac{2}{r}} - {\\color{purple}\\frac{1}{a}}\\right)$');
+  await expect(math.nth(0)).not.toContainText('\\^');
+  await expect(math.nth(1)).toContainText('{\\color{red}v^2}');
+  await expect(math.nth(2)).toContainText('${\\color{red}outer {\\color{blue}inner} outer} + z$');
+  await expect(math.nth(3)).toContainText('$\\color{orange} x + y$');
+  const mathBlocks = page.locator('#markdown-preview .math-block');
+  await expect(mathBlocks).toHaveCount(2);
+  await expect(mathBlocks.nth(0)).toContainText('{\\color{teal}A_{nested}}');
+  await expect(mathBlocks.nth(1)).toContainText('{\\color{brown}B^2}');
+  await expect(page.locator('#markdown-preview svg')).toHaveCount(0);
+  await expect(page.locator('#markdown-preview [onload], #markdown-preview [onerror]')).toHaveCount(0);
+  await expect.poll(() => page.evaluate(() => ({ math: window.__mathXss, note: window.__footnoteXss }))).toEqual({
+    math: undefined,
+    note: undefined
+  });
+});
diff --git a/tests/e2e/tab-split-sidebar-update.spec.js b/tests/e2e/tab-split-sidebar-update.spec.js
index 14246dc6..24173bbc 100644
--- a/tests/e2e/tab-split-sidebar-update.spec.js
+++ b/tests/e2e/tab-split-sidebar-update.spec.js
@@ -233,6 +233,7 @@ test('closing a tab keeps the document in Files and reopening restores the tab',
   await page.locator('#tab-new-btn').click();
   const closedTabId = await page.locator('#tab-list .tab-item.active').getAttribute('data-tab-id');
   await setEditorContent(page, '# Kept document');
+  await expect.poll(async () => JSON.stringify(await storedDocuments(page))).toContain('# Kept document');
   await page.locator('#tab-list .tab-item.active .tab-close-btn').click();
 
   await expect(page.locator(`.tab-item[data-tab-id="${closedTabId}"]`)).toHaveCount(0);