pi-studio 0.5.48 → 0.5.50

package/client/studio-client.js

@@ -1461,6 +1461,13 @@
         return annotationHelpers.stripAnnotationMarkers(text);
       }
 
+      function stripMarkdownHtmlComments(text) {
+        if (annotationHelpers && typeof annotationHelpers.stripMarkdownHtmlComments === "function") {
+          return annotationHelpers.stripMarkdownHtmlComments(text);
+        }
+        return String(text || "");
+      }
+
       function prepareEditorTextForSend(text) {
         const raw = String(text || "");
         return annotationsEnabled ? raw : stripAnnotationMarkers(raw);
@@ -1524,15 +1531,17 @@
         syncBadgeEl.classList.remove("sync");
       }
 
-      function buildPlainMarkdownHtml(markdown) {
-        return "<pre class='plain-markdown'>" + escapeHtml(String(markdown || "")) + "</pre>";
+      function buildPlainMarkdownHtml(markdown, options) {
+        const shouldStripHtmlComments = Boolean(options && options.stripMarkdownHtmlComments);
+        const source = shouldStripHtmlComments ? stripMarkdownHtmlComments(markdown) : String(markdown || "");
+        return "<pre class='plain-markdown'>" + escapeHtml(source) + "</pre>";
       }
 
-      function buildPreviewErrorHtml(message, markdown) {
-        return "<div class='preview-error'>" + escapeHtml(String(message || "Preview rendering failed.")) + "</div>" + buildPlainMarkdownHtml(markdown);
+      function buildPreviewErrorHtml(message, markdown, options) {
+        return "<div class='preview-error'>" + escapeHtml(String(message || "Preview rendering failed.")) + "</div>" + buildPlainMarkdownHtml(markdown, options);
       }
 
-      function sanitizeRenderedHtml(html, markdown) {
+      function sanitizeRenderedHtml(html, markdown, options) {
         const rawHtml = typeof html === "string" ? html : "";
         const mathAnnotationPreserved = rawHtml.replace(/<math\b([^>]*)>([\s\S]*?)<\/math>/gi, (match, attrs, inner) => {
           const texAnnotationMatch = String(inner || "").match(/<annotation\b[^>]*encoding="application\/x-tex"[^>]*>([\s\S]*?)<\/annotation>/i);
@@ -1556,7 +1565,7 @@
             ADD_DATA_URI_TAGS: ["embed"],
           });
         }
-        return buildPreviewErrorHtml("Preview sanitizer unavailable. Showing plain markdown.", markdown);
+        return buildPreviewErrorHtml("Preview sanitizer unavailable. Showing plain markdown.", markdown, options);
       }
 
       function isPdfPreviewSource(src) {
@@ -1895,6 +1904,7 @@
 
         fallbackTargets.forEach((entry) => {
           entry.renderTarget.classList.add("studio-mathjax-fallback");
+          entry.renderTarget.setAttribute("data-tex-source", entry.tex);
           if (entry.displayMode) {
             entry.renderTarget.classList.add("studio-mathjax-fallback-display");
             entry.renderTarget.textContent = "\\[\n" + entry.tex + "\n\\]";
@@ -2536,6 +2546,10 @@
         const previewPrepared = annotationsEnabled
           ? prepareMarkdownForPandocPreview(markdown)
           : { markdown: stripAnnotationMarkers(String(markdown || "")), placeholders: [] };
+        const previewingEditorText = pane === "source" || rightView === "editor-preview";
+        const previewFallbackOptions = {
+          stripMarkdownHtmlComments: !previewingEditorText || editorLanguage !== "latex",
+        };
 
         try {
           const renderedHtml = await renderMarkdownWithPandoc(previewPrepared.markdown, {
@@ -2550,7 +2564,7 @@
 
           clearPreviewJumpHighlight(targetEl);
           finishPreviewRender(targetEl);
-          targetEl.innerHTML = sanitizeRenderedHtml(renderedHtml, markdown);
+          targetEl.innerHTML = sanitizeRenderedHtml(renderedHtml, markdown, previewFallbackOptions);
           applyPreviewAnnotationPlaceholdersToElement(targetEl, previewPrepared.placeholders);
           await renderAnnotationMathInElement(targetEl);
           decoratePdfEmbeds(targetEl);
@@ -2594,7 +2608,7 @@
           const detail = error && error.message ? error.message : String(error || "unknown error");
           clearPreviewJumpHighlight(targetEl);
           finishPreviewRender(targetEl);
-          targetEl.innerHTML = buildPreviewErrorHtml("Preview renderer unavailable (" + detail + "). Showing plain markdown.", markdown);
+          targetEl.innerHTML = buildPreviewErrorHtml("Preview renderer unavailable (" + detail + "). Showing plain markdown.", markdown, previewFallbackOptions);
           if (pane === "response") {
             applyPendingResponseScrollReset();
             scheduleResponsePaneRepaintNudge();
@@ -3847,7 +3861,8 @@
               + ">"
               + "<div class='preview-comment-controls'>"
               + "<button type='button' class='preview-comment-summary' hidden></button>"
-              + "<button type='button' class='preview-comment-add'>Comment</button>"
+              + "<button type='button' class='preview-comment-add' data-preview-comment-action='comment'>Comment</button>"
+              + "<button type='button' class='preview-comment-jump' data-preview-comment-action='jump'>Jump</button>"
               + "</div>"
               + "<div class='preview-comment-block-content preview-code-line-content'>" + lineHtml + "</div>"
               + "</div>",
@@ -4434,16 +4449,19 @@
       }
 
       function supportsPreviewCommentsForCurrentEditor() {
-        // LaTeX preview comments are intentionally disabled for now.
-        // The initial client-side source/block heuristics were too unreliable on complex real documents.
-        // Keep the independent LaTeX rendering fixes, but only enable preview comments where mapping is robust.
-        return editorLanguage === "markdown" || supportsCodePreviewCommentsForCurrentEditor();
+        return editorLanguage === "markdown"
+          || editorLanguage === "latex"
+          || supportsCodePreviewCommentsForCurrentEditor();
       }
 
       function getPreviewCommentBlockKindLabel(kind) {
         if (kind === "heading") return "heading";
         if (kind === "blockquote") return "quote block";
         if (kind === "list") return "list";
+        if (kind === "math") return "equation";
+        if (kind === "figure") return "figure";
+        if (kind === "algorithm") return "algorithm block";
+        if (kind === "page-break") return "page break";
         if (kind === "code") return "code block";
         if (kind === "table") return "table";
         if (kind === "code-line") return "code line";
@@ -4457,13 +4475,687 @@
           || kind === "heading"
           || kind === "blockquote"
           || kind === "list"
+          || kind === "math"
           || kind === "code-line"
           || kind === "diff-line"
           || kind === "text-line";
       }
 
+      const DISPLAY_MATH_ENV_NAMES = new Set([
+        "displaymath",
+        "equation",
+        "equation*",
+        "align",
+        "align*",
+        "aligned",
+        "gather",
+        "gather*",
+        "multline",
+        "multline*",
+        "eqnarray",
+        "eqnarray*",
+        "split",
+      ]);
+
+      function isEscapedAt(text, index) {
+        let slashCount = 0;
+        for (let i = index - 1; i >= 0 && text[i] === "\\"; i -= 1) {
+          slashCount += 1;
+        }
+        return (slashCount % 2) === 1;
+      }
+
+      function readBalancedLatexGroup(source, startIndex, openChar, closeChar) {
+        if (!source || source[startIndex] !== openChar) return null;
+        let depth = 0;
+        for (let index = startIndex; index < source.length; index += 1) {
+          const ch = source[index];
+          if (ch === "\\") {
+            index += 1;
+            continue;
+          }
+          if (ch === openChar) {
+            depth += 1;
+            continue;
+          }
+          if (ch === closeChar) {
+            depth -= 1;
+            if (depth === 0) {
+              return {
+                start: startIndex,
+                contentStart: startIndex + 1,
+                contentEnd: index,
+                end: index + 1,
+              };
+            }
+          }
+        }
+        return null;
+      }
+
+      const DROPPED_MARKDOWN_RAW_TEX_GROUP_COMMANDS = new Set([
+        "textbf",
+        "textit",
+        "emph",
+        "underline",
+        "texttt",
+        "textrm",
+        "textsf",
+        "textsc",
+        "mbox",
+        "makebox",
+        "framebox",
+        "fbox",
+        "url",
+        "path",
+        "nolinkurl",
+      ]);
+      const DROPPED_MARKDOWN_RAW_TEX_DOUBLE_GROUP_COMMANDS = new Set([
+        "href",
+        "hyperref",
+      ]);
+      const DROPPED_MARKDOWN_RAW_TEX_STANDALONE_COMMANDS = new Set([
+        "latex",
+        "tex",
+        "newpage",
+        "pagebreak",
+        "clearpage",
+      ]);
+
+      function skipLatexWhitespace(source, startIndex) {
+        let index = startIndex;
+        while (index < source.length && /\s/.test(source[index])) index += 1;
+        return index;
+      }
+
+      function parseLatexCommandAt(source, startIndex) {
+        if (!source || source[startIndex] !== "\\") return null;
+        let index = startIndex + 1;
+        if (index >= source.length) {
+          return { name: "", end: index };
+        }
+        if (/[A-Za-z@]/.test(source[index])) {
+          const nameStart = index;
+          while (index < source.length && /[A-Za-z@]/.test(source[index])) index += 1;
+          if (source[index] === "*") index += 1;
+          return {
+            name: source.slice(nameStart, index),
+            end: index,
+          };
+        }
+        return {
+          name: source[index],
+          end: index + 1,
+        };
+      }
+
+      function collectDisplayMathRanges(text) {
+        const source = String(text || "");
+        const ranges = [];
+        let index = 0;
+
+        while (index < source.length) {
+          if (source[index] === "%" && !isEscapedAt(source, index)) {
+            while (index < source.length && source[index] !== "\n") index += 1;
+            continue;
+          }
+          if (source.startsWith("$$", index)) {
+            const close = source.indexOf("$$", index + 2);
+            if (close >= 0) {
+              ranges.push({
+                start: index,
+                end: close + 2,
+                bodyStart: index + 2,
+                bodyEnd: close,
+                bodyText: source.slice(index + 2, close),
+              });
+              index = close + 2;
+              continue;
+            }
+          }
+          if (source.startsWith("\\[", index)) {
+            const close = source.indexOf("\\]", index + 2);
+            if (close >= 0) {
+              ranges.push({
+                start: index,
+                end: close + 2,
+                bodyStart: index + 2,
+                bodyEnd: close,
+                bodyText: source.slice(index + 2, close),
+              });
+              index = close + 2;
+              continue;
+            }
+          }
+          if (source.startsWith("\\begin{", index)) {
+            const envGroup = readBalancedLatexGroup(source, index + 6, "{", "}");
+            const envName = envGroup ? source.slice(envGroup.contentStart, envGroup.contentEnd).trim() : "";
+            if (envName && DISPLAY_MATH_ENV_NAMES.has(envName)) {
+              const closeToken = "\\end{" + envName + "}";
+              const close = source.indexOf(closeToken, envGroup.end);
+              if (close >= 0) {
+                ranges.push({
+                  start: index,
+                  end: close + closeToken.length,
+                  bodyStart: envGroup.end,
+                  bodyEnd: close,
+                  bodyText: source.slice(envGroup.end, close),
+                });
+                index = close + closeToken.length;
+                continue;
+              }
+            }
+          }
+          index += 1;
+        }
+
+        return ranges;
+      }
+
+      function getStandaloneDisplayMathRange(text) {
+        const source = String(text || "");
+        const leadingMatch = source.match(/^\s*/);
+        const trailingMatch = source.match(/\s*$/);
+        const leadingLength = leadingMatch ? leadingMatch[0].length : 0;
+        const trailingLength = trailingMatch ? trailingMatch[0].length : 0;
+        const trimmedEnd = Math.max(leadingLength, source.length - trailingLength);
+        const trimmed = source.slice(leadingLength, trimmedEnd);
+        if (!trimmed) return null;
+        const ranges = collectDisplayMathRanges(trimmed);
+        if (ranges.length !== 1) return null;
+        const range = ranges[0];
+        if (!range || range.start !== 0 || range.end !== trimmed.length) return null;
+        return {
+          start: leadingLength + range.start,
+          end: leadingLength + range.end,
+          bodyStart: leadingLength + range.bodyStart,
+          bodyEnd: leadingLength + range.bodyEnd,
+          bodyText: String(range.bodyText || ""),
+        };
+      }
+
+      const LATEX_PREVIEW_HEADING_COMMANDS = new Set([
+        "part",
+        "chapter",
+        "section",
+        "subsection",
+        "subsubsection",
+        "paragraph",
+        "subparagraph",
+      ]);
+      const LATEX_PREVIEW_VISIBLE_GROUP_COMMANDS = new Set([
+        "part",
+        "chapter",
+        "section",
+        "subsection",
+        "subsubsection",
+        "paragraph",
+        "subparagraph",
+        "title",
+        "author",
+        "caption",
+        "text",
+        "textbf",
+        "textit",
+        "emph",
+        "underline",
+        "texttt",
+        "textrm",
+        "textsf",
+        "textsc",
+        "mbox",
+        "makebox",
+        "framebox",
+        "fbox",
+        "url",
+        "path",
+        "nolinkurl",
+      ]);
+      const LATEX_PREVIEW_SECOND_ARG_VISIBLE_COMMANDS = new Set([
+        "href",
+        "hyperref",
+      ]);
+      const LATEX_PREVIEW_HIDDEN_COMMANDS = new Set([
+        "label",
+        "ref",
+        "eqref",
+        "autoref",
+        "pageref",
+        "cite",
+        "citet",
+        "citep",
+        "citealt",
+        "citeauthor",
+        "nocite",
+        "footnote",
+        "marginpar",
+        "index",
+        "includegraphics",
+        "addbibresource",
+      ]);
+      const LATEX_PREVIEW_SKIPPED_ENV_NAMES = new Set([
+        "document",
+        "thebibliography",
+        "itemize",
+        "enumerate",
+        "description",
+        "figure",
+        "figure*",
+        "table",
+        "table*",
+        "tabular",
+        "tabular*",
+        "theorem",
+        "lemma",
+        "proposition",
+        "corollary",
+        "definition",
+        "proof",
+        "remark",
+        "example",
+        "verbatim",
+        "lstlisting",
+        "minted",
+        "algorithm",
+        "algorithm*",
+        "algorithmic",
+      ]);
+      const LATEX_PREVIEW_STRUCTURAL_ENV_KIND_BY_NAME = new Map([
+        ["figure", "figure"],
+        ["figure*", "figure"],
+        ["table", "table"],
+        ["table*", "table"],
+        ["algorithm", "algorithm"],
+        ["algorithm*", "algorithm"],
+      ]);
+
+      function stripLatexPreviewComments(text) {
+        const source = String(text || "");
+        let out = "";
+        for (let index = 0; index < source.length; index += 1) {
+          const ch = source[index];
+          if (ch === "%" && !isEscapedAt(source, index)) {
+            while (index < source.length && source[index] !== "\n") index += 1;
+            if (index < source.length && source[index] === "\n") {
+              out += "\n";
+            }
+            continue;
+          }
+          out += ch;
+        }
+        return out;
+      }
+
+      function skipLatexPreviewCommentSpace(source, startIndex) {
+        let index = Math.max(0, Number(startIndex) || 0);
+        while (index < source.length) {
+          const ch = source[index];
+          if (/\s/.test(ch)) {
+            index += 1;
+            continue;
+          }
+          if (ch === "%" && !isEscapedAt(source, index)) {
+            while (index < source.length && source[index] !== "\n") index += 1;
+            continue;
+          }
+          break;
+        }
+        return index;
+      }
+
+      function readLatexHeadingChunk(chunkText) {
+        const source = String(chunkText || "");
+        let index = skipLatexPreviewCommentSpace(source, 0);
+        const command = parseLatexCommandAt(source, index);
+        const commandName = command && command.name
+          ? String(command.name || "").replace(/\*$/, "").toLowerCase()
+          : "";
+        if (!command || !LATEX_PREVIEW_HEADING_COMMANDS.has(commandName)) return null;
+        index = skipLatexPreviewCommentSpace(source, command.end);
+        if (source[index] === "[") {
+          const optionalGroup = readBalancedLatexGroup(source, index, "[", "]");
+          if (optionalGroup) {
+            index = skipLatexPreviewCommentSpace(source, optionalGroup.end);
+          }
+        }
+        if (source[index] !== "{") return null;
+        const titleGroup = readBalancedLatexGroup(source, index, "{", "}");
+        if (!titleGroup) return null;
+        index = skipLatexPreviewCommentSpace(source, titleGroup.end);
+        while (index < source.length) {
+          const trailingCommand = parseLatexCommandAt(source, index);
+          const trailingName = trailingCommand && trailingCommand.name
+            ? String(trailingCommand.name || "").replace(/\*$/, "").toLowerCase()
+            : "";
+          if (!trailingCommand || !LATEX_PREVIEW_HIDDEN_COMMANDS.has(trailingName)) {
+            break;
+          }
+          let nextIndex = skipLatexPreviewCommentSpace(source, trailingCommand.end);
+          if (source[nextIndex] === "[") {
+            const optionalGroup = readBalancedLatexGroup(source, nextIndex, "[", "]");
+            if (optionalGroup) {
+              nextIndex = skipLatexPreviewCommentSpace(source, optionalGroup.end);
+            }
+          }
+          if (source[nextIndex] === "{") {
+            const argGroup = readBalancedLatexGroup(source, nextIndex, "{", "}");
+            if (argGroup) {
+              nextIndex = skipLatexPreviewCommentSpace(source, argGroup.end);
+            }
+          }
+          index = nextIndex;
+        }
+        if (skipLatexPreviewCommentSpace(source, index) < source.length) return null;
+        return {
+          commandName,
+          titleText: source.slice(titleGroup.contentStart, titleGroup.contentEnd),
+        };
+      }
+
+      function extractLatexPreviewVisibleText(text) {
+        const source = String(text || "");
+        let out = "";
+        let index = 0;
+
+        while (index < source.length) {
+          const ch = source[index];
+          if (ch === "%" && !isEscapedAt(source, index)) {
+            while (index < source.length && source[index] !== "\n") index += 1;
+            continue;
+          }
+          if (source.startsWith("$$", index)) {
+            const close = source.indexOf("$$", index + 2);
+            if (close >= 0) {
+              out += " " + source.slice(index + 2, close) + " ";
+              index = close + 2;
+              continue;
+            }
+          }
+          if (ch === "$" && !isEscapedAt(source, index)) {
+            const close = findClosingUnescapedSequence(source, index + 1, "$", true);
+            if (close >= 0) {
+              out += " " + source.slice(index + 1, close) + " ";
+              index = close + 1;
+              continue;
+            }
+          }
+          if (source.startsWith("\\(", index)) {
+            const close = source.indexOf("\\)", index + 2);
+            if (close >= 0) {
+              out += " " + source.slice(index + 2, close) + " ";
+              index = close + 2;
+              continue;
+            }
+          }
+          if (source.startsWith("\\[", index)) {
+            const close = source.indexOf("\\]", index + 2);
+            if (close >= 0) {
+              out += " " + source.slice(index + 2, close) + " ";
+              index = close + 2;
+              continue;
+            }
+          }
+          if (source.startsWith("\\begin{", index)) {
+            const envGroup = readBalancedLatexGroup(source, index + 6, "{", "}");
+            const envName = envGroup ? source.slice(envGroup.contentStart, envGroup.contentEnd).trim() : "";
+            if (envName && DISPLAY_MATH_ENV_NAMES.has(envName)) {
+              const closeToken = "\\end{" + envName + "}";
+              const close = source.indexOf(closeToken, envGroup.end);
+              if (close >= 0) {
+                out += " " + source.slice(envGroup.end, close) + " ";
+                index = close + closeToken.length;
+                continue;
+              }
+            }
+          }
+          if (source.startsWith("\\end{", index)) {
+            const envGroup = readBalancedLatexGroup(source, index + 4, "{", "}");
+            if (envGroup) {
+              index = envGroup.end;
+              continue;
+            }
+          }
+          if (ch === "\\") {
+            const command = parseLatexCommandAt(source, index);
+            const commandName = command && command.name
+              ? String(command.name || "").replace(/\*$/, "").toLowerCase()
+              : "";
+            if (!command) {
+              index += 1;
+              continue;
+            }
+            if (commandName === "begin" || commandName === "end") {
+              let nextIndex = skipLatexWhitespace(source, command.end);
+              if (source[nextIndex] === "{") {
+                const group = readBalancedLatexGroup(source, nextIndex, "{", "}");
+                if (group) {
+                  index = group.end;
+                  continue;
+                }
+              }
+            }
+            if (commandName === "latex") {
+              out += "LaTeX";
+              index = command.end;
+              continue;
+            }
+            if (commandName === "tex") {
+              out += "TeX";
+              index = command.end;
+              continue;
+            }
+            if (commandName === "item") {
+              out += " ";
+              index = command.end;
+              continue;
+            }
+            let nextIndex = skipLatexWhitespace(source, command.end);
+            if (source[nextIndex] === "[") {
+              const optionalGroup = readBalancedLatexGroup(source, nextIndex, "[", "]");
+              if (optionalGroup) {
+                nextIndex = skipLatexWhitespace(source, optionalGroup.end);
+              }
+            }
+            if (LATEX_PREVIEW_VISIBLE_GROUP_COMMANDS.has(commandName) && source[nextIndex] === "{") {
+              const group = readBalancedLatexGroup(source, nextIndex, "{", "}");
+              if (group) {
+                out += " " + extractLatexPreviewVisibleText(source.slice(group.contentStart, group.contentEnd)) + " ";
+                index = group.end;
+                continue;
+              }
+            }
+            if (LATEX_PREVIEW_SECOND_ARG_VISIBLE_COMMANDS.has(commandName) && source[nextIndex] === "{") {
+              const firstGroup = readBalancedLatexGroup(source, nextIndex, "{", "}");
+              if (firstGroup) {
+                let secondIndex = skipLatexWhitespace(source, firstGroup.end);
+                if (source[secondIndex] === "{") {
+                  const secondGroup = readBalancedLatexGroup(source, secondIndex, "{", "}");
+                  if (secondGroup) {
+                    out += " " + extractLatexPreviewVisibleText(source.slice(secondGroup.contentStart, secondGroup.contentEnd)) + " ";
+                    index = secondGroup.end;
+                    continue;
+                  }
+                }
+              }
+            }
+            if (LATEX_PREVIEW_HIDDEN_COMMANDS.has(commandName)) {
+              index = nextIndex;
+              if (source[index] === "{") {
+                const group = readBalancedLatexGroup(source, index, "{", "}");
+                if (group) {
+                  index = group.end;
+                  continue;
+                }
+              }
+              index = command.end;
+              continue;
+            }
+            index = command.end;
+            continue;
+          }
+          if (ch === "{" || ch === "}") {
+            index += 1;
+            continue;
+          }
+          if (ch === "~") {
+            out += " ";
+            index += 1;
+            continue;
+          }
+          out += ch;
+          index += 1;
+        }
+
+        return normalizeVisiblePreviewText(out);
+      }
+
+      function findLatexDocumentBodyRange(text) {
+        const source = String(text || "");
+        const beginMatch = source.match(/\\begin\{document\}/);
+        if (!beginMatch || beginMatch.index == null) {
+          return { start: 0, end: source.length };
+        }
+        const start = beginMatch.index + beginMatch[0].length;
+        const endMatch = source.slice(start).match(/\\end\{document\}/);
+        return {
+          start,
+          end: endMatch && endMatch.index != null ? (start + endMatch.index) : source.length,
+        };
+      }
+
+      function normalizeLatexPreviewBlockText(blockText, kind) {
+        const source = String(blockText || "");
+        if (/\\(?:bibliography|printbibliography)\b/i.test(source)) {
+          return kind === "heading" ? "References" : "references";
+        }
+        if (kind === "math") {
+          const mathRange = getStandaloneDisplayMathRange(stripLatexPreviewComments(source));
+          return mathRange ? normalizeVisiblePreviewText(mathRange.bodyText) : normalizeVisiblePreviewText(source);
+        }
+        if (kind === "heading") {
+          const heading = readLatexHeadingChunk(stripLatexPreviewComments(source));
+          return heading ? extractLatexPreviewVisibleText(heading.titleText) : extractLatexPreviewVisibleText(source);
+        }
+        return extractLatexPreviewVisibleText(source);
+      }
+
+      function isLatexPreviewSkippableChunk(chunkText) {
+        const source = stripLatexPreviewComments(chunkText).trim();
+        if (!source) return true;
+        const command = parseLatexCommandAt(source, 0);
+        const commandName = command && command.name
+          ? String(command.name || "").replace(/\*$/, "").toLowerCase()
+          : "";
+        if (command && LATEX_PREVIEW_HIDDEN_COMMANDS.has(commandName)) return true;
+        if (command && /^(?:documentclass|usepackage|newtheorem|title|author|date|maketitle|tableofcontents)$/i.test(commandName)) return true;
+        if (source.startsWith("\\begin{")) {
+          const envGroup = readBalancedLatexGroup(source, 6, "{", "}");
+          const envName = envGroup ? source.slice(envGroup.contentStart, envGroup.contentEnd).trim().toLowerCase() : "";
+          if (envName && LATEX_PREVIEW_SKIPPED_ENV_NAMES.has(envName)) return true;
+        }
+        return false;
+      }
+
+      function normalizePreviewComparableCharacter(character) {
+        switch (String(character || "")) {
+          case "\u2018":
+          case "\u2019":
+          case "\u201A":
+          case "\u201B":
+            return "'";
+          case "\u201C":
+          case "\u201D":
+          case "\u201E":
+          case "\u201F":
+            return '"';
+          case "\u2013":
+          case "\u2014":
+          case "\u2212":
+            return "-";
+          case "\u2026":
+            return "…";
+          default:
+            return String(character || "");
+        }
+      }
+
       function normalizeVisiblePreviewText(text) {
-        return String(text || "").replace(/\s+/g, " ").trim();
+        const source = String(text || "");
+        let normalized = "";
+        let pendingWhitespace = false;
+        for (let i = 0; i < source.length; i += 1) {
+          let character = source[i] === "." && source.slice(i, i + 3) === "..."
+            ? "…"
+            : normalizePreviewComparableCharacter(source[i]);
+          if (character === "…" && source[i] === "." && source.slice(i, i + 3) === "...") {
+            i += 2;
+          }
+          if (/\s/.test(character)) {
+            if (normalized) {
+              pendingWhitespace = true;
+            }
+            continue;
+          }
+          if (pendingWhitespace && normalized) {
+            normalized += " ";
+            pendingWhitespace = false;
+          }
+          normalized += character;
+        }
+        return normalized.trim();
+      }
+
+      function splitSourcePreviewCommentBlockByDisplayMath(sourceText, block) {
+        if (!block || block.kind !== "paragraph") {
+          return block ? [block] : [];
+        }
+        const source = String(sourceText || "");
+        const blockStart = Math.max(0, Math.min(Number(block.start) || 0, source.length));
+        const blockEnd = Math.max(blockStart, Math.min(Number(block.end) || blockStart, source.length));
+        const blockText = source.slice(blockStart, blockEnd);
+        const mathRanges = collectDisplayMathRanges(blockText);
+        if (mathRanges.length === 0) {
+          return [block];
+        }
+
+        const segments = [];
+        function pushSegment(kind, relativeStart, relativeEnd) {
+          const safeRelativeStart = Math.max(0, Math.min(relativeStart, blockText.length));
+          const safeRelativeEnd = Math.max(safeRelativeStart, Math.min(relativeEnd, blockText.length));
+          if (safeRelativeEnd <= safeRelativeStart) return;
+          const absoluteStart = blockStart + safeRelativeStart;
+          const absoluteEnd = blockStart + safeRelativeEnd;
+          const segmentText = source.slice(absoluteStart, absoluteEnd);
+          if (kind === "paragraph" && !normalizeVisiblePreviewText(segmentText)) {
+            return;
+          }
+          segments.push({
+            kind,
+            start: absoluteStart,
+            end: absoluteEnd,
+            lineStart: getLineNumberAtOffset(source, absoluteStart),
+            lineEnd: getLineNumberAtOffset(source, Math.max(absoluteStart, absoluteEnd - 1)),
+          });
+        }
+
+        let cursor = 0;
+        mathRanges.forEach((mathRange) => {
+          if (!mathRange) return;
+          pushSegment("paragraph", cursor, mathRange.start);
+          pushSegment("math", mathRange.start, mathRange.end);
+          cursor = mathRange.end;
+        });
+        pushSegment("paragraph", cursor, blockText.length);
+
+        return segments.length > 0 ? segments : [block];
+      }
+
+      function expandSourcePreviewCommentBlocksByDisplayMath(sourceText, blocks) {
+        const expanded = [];
+        (Array.isArray(blocks) ? blocks : []).forEach((block) => {
+          expanded.push(...splitSourcePreviewCommentBlockByDisplayMath(sourceText, block));
+        });
+        return expanded;
       }
 
       function appendMappedPreviewSlice(chars, rawOffsets, lineText, lineBaseOffset, start, end) {
@@ -4516,6 +5208,14 @@
           }
         }
 
+        if (kind === "math") {
+          const mathRange = getStandaloneDisplayMathRange(source);
+          if (mathRange) {
+            appendMappedPreviewSlice(chars, rawOffsets, source, 0, mathRange.bodyStart, mathRange.bodyEnd);
+            return { text: chars.join(""), rawOffsets };
+          }
+        }
+
         for (let lineIndex = 0; lineIndex < lines.length; lineIndex += 1) {
           const line = lines[lineIndex] || "";
           if (kind === "blockquote") {
@@ -4543,6 +5243,26 @@
         return { text: chars.join(""), rawOffsets };
       }
 
+      function findClosingUnescapedSequence(source, startIndex, sequence) {
+        const text = String(source || "");
+        const needle = String(sequence || "");
+        if (!text || !needle) return -1;
+        let searchIndex = Math.max(0, Number(startIndex) || 0);
+        while (searchIndex <= text.length) {
+          const matchIndex = text.indexOf(needle, searchIndex);
+          if (matchIndex < 0) return -1;
+          let backslashCount = 0;
+          for (let i = matchIndex - 1; i >= 0 && text[i] === "\\"; i -= 1) {
+            backslashCount += 1;
+          }
+          if (backslashCount % 2 === 0) {
+            return matchIndex;
+          }
+          searchIndex = matchIndex + needle.length;
+        }
+        return -1;
+      }
+
       function buildPreviewInlineDisplayMap(text, rawOffsets) {
         const source = String(text || "");
         const rawMap = Array.isArray(rawOffsets) ? rawOffsets : [];
@@ -4556,6 +5276,12 @@
           charEnds.push(rawEnd);
         }
 
+        function appendRawRange(startIndex, endIndex) {
+          for (let i = startIndex; i < endIndex; i += 1) {
+            appendChar(source[i], rawMap[i], rawMap[i] + 1);
+          }
+        }
+
         function appendNestedRange(startIndex, endIndex) {
           const nested = buildPreviewInlineDisplayMap(
             source.slice(startIndex, endIndex),
@@ -4584,15 +5310,86 @@
             const fence = "`".repeat(tickCount);
             const closeIndex = source.indexOf(fence, index + tickCount);
             if (closeIndex >= 0) {
-              for (let i = index + tickCount; i < closeIndex; i += 1) {
-                appendChar(source[i], rawMap[i], rawMap[i] + 1);
-              }
+              appendRawRange(index + tickCount, closeIndex);
               index = closeIndex + tickCount;
               continue;
             }
           }
 
+          if (remaining.startsWith("\\(")) {
+            const closeIndex = source.indexOf("\\)", index + 2);
+            if (closeIndex >= 0) {
+              appendRawRange(index + 2, closeIndex);
+              index = closeIndex + 2;
+              continue;
+            }
+          }
+
+          if (remaining.startsWith("\\[")) {
+            const closeIndex = source.indexOf("\\]", index + 2);
+            if (closeIndex >= 0) {
+              appendRawRange(index + 2, closeIndex);
+              index = closeIndex + 2;
+              continue;
+            }
+          }
+
+          if (remaining.startsWith("$$")) {
+            const closeIndex = findClosingUnescapedSequence(source, index + 2, "$$");
+            if (closeIndex >= 0) {
+              appendRawRange(index + 2, closeIndex);
+              index = closeIndex + 2;
+              continue;
+            }
+          }
+
+          if (source[index] === "$") {
+            const closeIndex = findClosingUnescapedSequence(source, index + 1, "$");
+            if (closeIndex >= 0) {
+              appendRawRange(index + 1, closeIndex);
+              index = closeIndex + 1;
+              continue;
+            }
+          }
+
           if (source[index] === "\\" && index + 1 < source.length) {
+            const latexCommand = parseLatexCommandAt(source, index);
+            const normalizedCommandName = latexCommand && latexCommand.name
+              ? String(latexCommand.name || "").replace(/\*$/, "").toLowerCase()
+              : "";
+            const isDroppedLatexCommand = Boolean(
+              normalizedCommandName
+              && (
+                DROPPED_MARKDOWN_RAW_TEX_GROUP_COMMANDS.has(normalizedCommandName)
+                || DROPPED_MARKDOWN_RAW_TEX_DOUBLE_GROUP_COMMANDS.has(normalizedCommandName)
+                || DROPPED_MARKDOWN_RAW_TEX_STANDALONE_COMMANDS.has(normalizedCommandName)
+              )
+            );
+            if (latexCommand && isDroppedLatexCommand) {
+              let nextIndex = skipLatexWhitespace(source, latexCommand.end);
+              if (source[nextIndex] === "[") {
+                const optionalGroup = readBalancedLatexGroup(source, nextIndex, "[", "]");
+                if (optionalGroup) {
+                  nextIndex = skipLatexWhitespace(source, optionalGroup.end);
+                }
+              }
+              if (DROPPED_MARKDOWN_RAW_TEX_GROUP_COMMANDS.has(normalizedCommandName) || DROPPED_MARKDOWN_RAW_TEX_DOUBLE_GROUP_COMMANDS.has(normalizedCommandName)) {
+                if (source[nextIndex] === "{") {
+                  const firstGroup = readBalancedLatexGroup(source, nextIndex, "{", "}");
+                  if (firstGroup) {
+                    nextIndex = skipLatexWhitespace(source, firstGroup.end);
+                  }
+                }
+              }
+              if (DROPPED_MARKDOWN_RAW_TEX_DOUBLE_GROUP_COMMANDS.has(normalizedCommandName) && source[nextIndex] === "{") {
+                const secondGroup = readBalancedLatexGroup(source, nextIndex, "{", "}");
+                if (secondGroup) {
+                  nextIndex = skipLatexWhitespace(source, secondGroup.end);
+                }
+              }
+              index = Math.max(index + 1, nextIndex);
+              continue;
+            }
             appendChar(source[index + 1], rawMap[index], rawMap[index + 1] + 1);
             index += 2;
             continue;
@@ -4630,13 +5427,20 @@
         let pendingWhitespaceEnd = null;
 
         for (let i = 0; i < source.length; i += 1) {
-          const character = source[i];
+          let character = normalizePreviewComparableCharacter(source[i]);
+          let startRef = charStarts[i];
+          let endRef = charEnds[i];
+          if (source[i] === "." && source.slice(i, i + 3) === "...") {
+            character = "…";
+            endRef = charEnds[Math.min(i + 2, charEnds.length - 1)];
+            i += 2;
+          }
           if (/\s/.test(character)) {
             if (outChars.length === 0) continue;
             if (pendingWhitespaceStart == null) {
-              pendingWhitespaceStart = charStarts[i];
+              pendingWhitespaceStart = startRef;
             }
-            pendingWhitespaceEnd = charEnds[i];
+            pendingWhitespaceEnd = endRef;
             continue;
           }
 
@@ -4649,8 +5453,8 @@
           }
 
           outChars.push(character);
-          outStarts.push(charStarts[i]);
-          outEnds.push(charEnds[i]);
+          outStarts.push(startRef);
+          outEnds.push(endRef);
         }
 
         return {
@@ -4682,6 +5486,78 @@
         return buildNormalizedPreviewDisplayMap(chars.join(""), starts, ends);
       }
 
+      function getPreviewMathSearchText(element) {
+        if (!element || !(element instanceof Element)) return null;
+        const texSourceAttr = element.getAttribute("data-tex-source");
+        if (texSourceAttr && texSourceAttr.trim()) {
+          return texSourceAttr;
+        }
+        const tag = element.tagName ? element.tagName.toUpperCase() : "";
+        if (tag === "MATH") {
+          return typeof element.textContent === "string" ? element.textContent : "";
+        }
+        if (element.classList && element.classList.contains("math") && (element.classList.contains("inline") || element.classList.contains("display"))) {
+          return extractMathFallbackTex(
+            typeof element.textContent === "string" ? element.textContent : "",
+            element.classList.contains("display"),
+          );
+        }
+        if (
+          element.classList
+          && (element.classList.contains("studio-display-equation") || element.classList.contains("studio-display-equation-body"))
+          && typeof element.querySelector === "function"
+        ) {
+          const innerMathEl = element.querySelector("[data-tex-source], math[display='block'], .studio-mathjax-fallback-display");
+          if (innerMathEl && innerMathEl !== element) {
+            return getPreviewMathSearchText(innerMathEl);
+          }
+        }
+        return null;
+      }
+
+      function buildNormalizedPreviewSearchText(rootNode) {
+        if (!rootNode) return "";
+        const parts = [];
+
+        function visit(node) {
+          if (!node) return;
+          if (node.nodeType === Node.TEXT_NODE) {
+            parts.push(typeof node.nodeValue === "string" ? node.nodeValue : "");
+            return;
+          }
+          if (node.nodeType !== Node.ELEMENT_NODE && node.nodeType !== Node.DOCUMENT_FRAGMENT_NODE) {
+            return;
+          }
+          if (node.nodeType === Node.ELEMENT_NODE) {
+            const element = node;
+            const mathText = getPreviewMathSearchText(element);
+            if (mathText != null) {
+              parts.push(mathText);
+              return;
+            }
+            if (element.tagName === "BR") {
+              parts.push("\n");
+              return;
+            }
+          }
+          Array.from(node.childNodes || []).forEach(visit);
+        }
+
+        visit(rootNode);
+        return normalizeVisiblePreviewText(parts.join(""));
+      }
+
+      function buildNormalizedPreviewRangeText(range) {
+        if (!range || typeof range.cloneContents !== "function") {
+          return "";
+        }
+        try {
+          return buildNormalizedPreviewSearchText(range.cloneContents());
+        } catch {
+          return normalizeVisiblePreviewText(range.toString());
+        }
+      }
+
       function findPreferredNormalizedTextMatch(haystack, needle, preferredIndex) {
         const source = String(haystack || "");
         const query = String(needle || "");
@@ -4797,8 +5673,9 @@
       }
 
       function scanSourcePreviewCommentBlocks(markdown) {
-        if (editorLanguage !== "markdown") return [];
-        return scanMarkdownPreviewCommentBlocks(markdown);
+        if (editorLanguage === "markdown") return scanMarkdownPreviewCommentBlocks(markdown);
+        if (editorLanguage === "latex") return scanLatexPreviewCommentBlocks(markdown);
+        return [];
       }
 
       function scanMarkdownPreviewCommentBlocks(markdown) {
@@ -4860,6 +5737,10 @@
           return /^\s*<!--/.test(getLine(index));
         }
 
+        function isPageBreakLine(index) {
+          return /^\\(?:newpage|pagebreak|clearpage)(?:\s*\[[^\]]*\])?\s*$/i.test(getLine(index));
+        }
+
         function makeBlock(kind, startLineIndex, endLineIndex) {
           const safeStartLine = Math.max(0, Math.min(startLineIndex, Math.max(0, lines.length - 1)));
           const safeEndLine = Math.max(safeStartLine, Math.min(endLineIndex, Math.max(0, lines.length - 1)));
@@ -4906,6 +5787,12 @@
             continue;
           }
 
+          if (isPageBreakLine(index)) {
+            blocks.push(makeBlock("page-break", index, index));
+            index += 1;
+            continue;
+          }
+
           const fenceMatch = lineStartsFence(index);
           if (fenceMatch) {
             const marker = fenceMatch[1] || "";
@@ -5004,18 +5891,353 @@
           index = endParagraph + 1;
         }
 
+        return expandSourcePreviewCommentBlocksByDisplayMath(source, blocks);
+      }
+
+      function scanLatexPreviewCommentBlocks(markdown) {
+        const source = String(markdown || "").replace(/\r\n/g, "\n");
+        if (!source) return [];
+        const bodyRange = findLatexDocumentBodyRange(source);
+        const bodyStart = Math.max(0, Math.min(bodyRange.start, source.length));
+        const bodyEnd = Math.max(bodyStart, Math.min(bodyRange.end, source.length));
+        const bodyText = source.slice(bodyStart, bodyEnd);
+        const lines = bodyText.split("\n");
+        const lineOffsets = [];
+        let runningOffset = 0;
+        for (const line of lines) {
+          lineOffsets.push(runningOffset);
+          runningOffset += line.length + 1;
+        }
+
+        function getLine(index) {
+          return index >= 0 && index < lines.length ? String(lines[index] || "") : "";
+        }
+
+        function getStrippedLine(index) {
+          return stripLatexPreviewComments(getLine(index)).trim();
+        }
+
+        function isBlankLine(index) {
+          return !getStrippedLine(index);
+        }
+
+        function isBibliographyCommandLine(index) {
+          return /^\\(?:bibliographystyle|bibliography|printbibliography)\b/i.test(getStrippedLine(index));
+        }
+
+        function makeBlock(kind, startLineIndex, endLineIndex) {
+          const safeStartLine = Math.max(0, Math.min(startLineIndex, Math.max(0, lines.length - 1)));
+          const safeEndLine = Math.max(safeStartLine, Math.min(endLineIndex, Math.max(0, lines.length - 1)));
+          const start = bodyStart + (lineOffsets[safeStartLine] || 0);
+          const end = bodyStart + (lineOffsets[safeEndLine] || 0) + getLine(safeEndLine).length;
+          return {
+            kind,
+            start,
+            end,
+            lineStart: getLineNumberAtOffset(source, start),
+            lineEnd: getLineNumberAtOffset(source, Math.max(start, end - 1)),
+          };
+        }
+
+        function getChunkText(startLineIndex, endLineIndex) {
+          return bodyText.slice(
+            lineOffsets[startLineIndex] || 0,
+            (lineOffsets[endLineIndex] || 0) + getLine(endLineIndex).length,
+          );
+        }
+
+        function getEnvironmentStartName(index) {
+          const line = getStrippedLine(index);
+          const match = line.match(/^\\begin\{([^}]+)\}/);
+          return match ? String(match[1] || "").trim().toLowerCase() : "";
+        }
+
+        function findEnvironmentEndLine(startLineIndex, envName) {
+          const openToken = "\\begin{" + envName + "}";
+          const closeToken = "\\end{" + envName + "}";
+          let depth = 0;
+          for (let lineIndex = startLineIndex; lineIndex < lines.length; lineIndex += 1) {
+            const line = getStrippedLine(lineIndex);
+            if (line.includes(openToken)) depth += 1;
+            if (line.includes(closeToken)) {
+              depth -= 1;
+              if (depth <= 0) return lineIndex;
+            }
+          }
+          return startLineIndex;
+        }
+
+        function isHeadingLine(index) {
+          return Boolean(readLatexHeadingChunk(getLine(index)));
+        }
+
+        function findBibliographyCommandEndLine(startLineIndex) {
+          let endLineIndex = startLineIndex;
+          for (let lineIndex = startLineIndex + 1; lineIndex < lines.length; lineIndex += 1) {
+            if (!isBibliographyCommandLine(lineIndex)) break;
+            endLineIndex = lineIndex;
+          }
+          return endLineIndex;
+        }
+
+        function isMathStartLine(index) {
+          const line = getStrippedLine(index);
+          if (!line) return false;
+          if (line.startsWith("$$") || line.startsWith("\\[")) return true;
+          const envName = getEnvironmentStartName(index);
+          return Boolean(envName && DISPLAY_MATH_ENV_NAMES.has(envName));
+        }
+
+        function findMathEndLine(startLineIndex) {
+          for (let endLineIndex = startLineIndex; endLineIndex < lines.length; endLineIndex += 1) {
+            const chunkText = getChunkText(startLineIndex, endLineIndex);
+            if (getStandaloneDisplayMathRange(stripLatexPreviewComments(chunkText))) {
+              return endLineIndex;
+            }
+          }
+          return startLineIndex;
+        }
+
+        const blocks = [];
+        let lineIndex = 0;
+        while (lineIndex < lines.length) {
+          if (isBlankLine(lineIndex)) {
+            lineIndex += 1;
+            continue;
+          }
+
+          const strippedLine = getStrippedLine(lineIndex);
+          const envName = getEnvironmentStartName(lineIndex);
+
+          if (isHeadingLine(lineIndex)) {
+            blocks.push(makeBlock("heading", lineIndex, lineIndex));
+            lineIndex += 1;
+            continue;
+          }
+
+          if (envName === "abstract" || envName === "keywords") {
+            const endLineIndex = findEnvironmentEndLine(lineIndex, envName);
+            const chunkText = getChunkText(lineIndex, endLineIndex);
+            if (normalizeLatexPreviewBlockText(chunkText, "paragraph")) {
+              blocks.push(makeBlock("paragraph", lineIndex, endLineIndex));
+            }
+            lineIndex = endLineIndex + 1;
+            continue;
+          }
+
+          if (envName && LATEX_PREVIEW_STRUCTURAL_ENV_KIND_BY_NAME.has(envName)) {
+            const endLineIndex = findEnvironmentEndLine(lineIndex, envName);
+            blocks.push(makeBlock(LATEX_PREVIEW_STRUCTURAL_ENV_KIND_BY_NAME.get(envName) || "paragraph", lineIndex, endLineIndex));
+            lineIndex = endLineIndex + 1;
+            continue;
+          }
+
+          if (isBibliographyCommandLine(lineIndex)) {
+            const endLineIndex = findBibliographyCommandEndLine(lineIndex);
+            blocks.push(makeBlock("heading", lineIndex, endLineIndex));
+            blocks.push(makeBlock("paragraph", lineIndex, endLineIndex));
+            lineIndex = endLineIndex + 1;
+            continue;
+          }
+
+          if (envName && LATEX_PREVIEW_SKIPPED_ENV_NAMES.has(envName) && !DISPLAY_MATH_ENV_NAMES.has(envName)) {
+            lineIndex = findEnvironmentEndLine(lineIndex, envName) + 1;
+            continue;
+          }
+
+          if (isMathStartLine(lineIndex)) {
+            const endLineIndex = findMathEndLine(lineIndex);
+            blocks.push(makeBlock("math", lineIndex, endLineIndex));
+            lineIndex = endLineIndex + 1;
+            continue;
+          }
+
+          if (isLatexPreviewSkippableChunk(strippedLine)) {
+            lineIndex += 1;
+            continue;
+          }
+
+          const paragraphStartLine = lineIndex;
+          let paragraphEndLine = lineIndex;
+          for (let nextLineIndex = lineIndex + 1; nextLineIndex < lines.length; nextLineIndex += 1) {
+            if (isBlankLine(nextLineIndex) || isHeadingLine(nextLineIndex) || isMathStartLine(nextLineIndex)) {
+              break;
+            }
+            const nextEnvName = getEnvironmentStartName(nextLineIndex);
+            if (nextEnvName) {
+              break;
+            }
+            paragraphEndLine = nextLineIndex;
+          }
+
+          const chunkText = getChunkText(paragraphStartLine, paragraphEndLine);
+          if (normalizeLatexPreviewBlockText(chunkText, "paragraph") && !isLatexPreviewSkippableChunk(chunkText)) {
+            blocks.push(makeBlock("paragraph", paragraphStartLine, paragraphEndLine));
+          }
+          lineIndex = paragraphEndLine + 1;
+        }
+
         return blocks;
       }
 
+      function isPreviewDisplayMathElement(element) {
+        return Boolean(
+          element
+          && element instanceof Element
+          && element.matches
+          && element.matches("math[display='block'], .studio-mathjax-fallback-display, .studio-display-equation, .studio-display-equation-body")
+        );
+      }
+
+      function previewNodesHaveVisibleContent(nodes) {
+        return (Array.isArray(nodes) ? nodes : []).some((node) => {
+          if (!node) return false;
+          if (node.nodeType === Node.TEXT_NODE) {
+            return Boolean(normalizeVisiblePreviewText(node.nodeValue || ""));
+          }
+          return node instanceof Element && Boolean(buildNormalizedPreviewSearchText(node));
+        });
+      }
+
+      function wrapLoosePreviewInlineRunsAsParagraphs(targetEl) {
+        if (!targetEl || !targetEl.childNodes || typeof document.createElement !== "function") return;
+        const childNodes = Array.from(targetEl.childNodes || []);
+        if (childNodes.length === 0) return;
+
+        function isDirectBlockChild(node) {
+          if (!(node instanceof Element) || node.parentElement !== targetEl) return false;
+          const tag = node.tagName ? node.tagName.toUpperCase() : "";
+          if (/^H[1-6]$/.test(tag)) return true;
+          if (tag === "P" || tag === "BLOCKQUOTE" || tag === "UL" || tag === "OL" || tag === "TABLE" || tag === "PRE" || tag === "HEADER" || tag === "FIGURE") {
+            return true;
+          }
+          if (tag === "MATH") {
+            return String(node.getAttribute("display") || "").toLowerCase() === "block";
+          }
+          if (tag === "DIV") return true;
+          return false;
+        }
+
+        let runNodes = [];
+
+        function flushRun(referenceNode) {
+          if (runNodes.length === 0) return;
+          if (!previewNodesHaveVisibleContent(runNodes)) {
+            runNodes.forEach((node) => {
+              if (node && node.parentNode === targetEl) {
+                targetEl.removeChild(node);
+              }
+            });
+            runNodes = [];
+            return;
+          }
+          const paragraphEl = document.createElement("p");
+          runNodes.forEach((node) => {
+            paragraphEl.appendChild(node);
+          });
+          targetEl.insertBefore(paragraphEl, referenceNode || null);
+          runNodes = [];
+        }
+
+        childNodes.forEach((node) => {
+          if (node instanceof Element && isDirectBlockChild(node)) {
+            flushRun(node);
+            return;
+          }
+          if (node.parentNode === targetEl) {
+            runNodes.push(node);
+          }
+        });
+        flushRun(null);
+      }
+
+      function splitMixedPreviewParagraphsAroundDisplayMath(targetEl) {
+        if (!targetEl || typeof targetEl.querySelectorAll !== "function") return;
+        if (editorLanguage === "latex") {
+          wrapLoosePreviewInlineRunsAsParagraphs(targetEl);
+        }
+        Array.from(targetEl.querySelectorAll("p")).forEach((paragraphEl) => {
+          if (!(paragraphEl instanceof Element) || !paragraphEl.parentNode) return;
+          if (paragraphEl.closest && paragraphEl.closest(".preview-comment-block")) return;
+          let ancestor = paragraphEl.parentElement;
+          while (ancestor && ancestor !== targetEl) {
+            if (getPreviewCommentTargetKind(ancestor)) return;
+            ancestor = ancestor.parentElement;
+          }
+          const childNodes = Array.from(paragraphEl.childNodes || []);
+          if (!childNodes.some((node) => isPreviewDisplayMathElement(node))) return;
+
+          const fragment = document.createDocumentFragment();
+          let proseNodes = [];
+          let segmentCount = 0;
+
+          function flushProse() {
+            if (proseNodes.length === 0) return;
+            if (!previewNodesHaveVisibleContent(proseNodes)) {
+              proseNodes = [];
+              return;
+            }
+            const proseEl = paragraphEl.cloneNode(false);
+            if (proseEl instanceof Element) {
+              proseEl.removeAttribute("id");
+            }
+            proseNodes.forEach((node) => {
+              proseEl.appendChild(node);
+            });
+            fragment.appendChild(proseEl);
+            proseNodes = [];
+            segmentCount += 1;
+          }
+
+          childNodes.forEach((node) => {
+            if (isPreviewDisplayMathElement(node)) {
+              flushProse();
+              fragment.appendChild(node);
+              segmentCount += 1;
+              return;
+            }
+            proseNodes.push(node);
+          });
+          flushProse();
+
+          if (segmentCount > 0) {
+            paragraphEl.replaceWith(fragment);
+          }
+        });
+      }
+
       function getPreviewCommentTargetKind(element) {
         if (!element || !(element instanceof Element)) return "";
+        if (element.classList && element.classList.contains("studio-mathjax-fallback-display")) {
+          return "math";
+        }
+        if (element.classList && element.classList.contains("studio-page-break")) {
+          return "page-break";
+        }
         const tag = element.tagName ? element.tagName.toUpperCase() : "";
         if (/^H[1-6]$/.test(tag)) return "heading";
         if (tag === "P") return "paragraph";
+        if (tag === "FIGURE") {
+          if (element.classList && element.classList.contains("studio-algorithm-block")) {
+            return "algorithm";
+          }
+          return editorLanguage === "latex" ? "figure" : "";
+        }
+        if (tag === "DIV" && element.classList) {
+          if (element.classList.contains("studio-display-equation")) {
+            return "math";
+          }
+          if (element.classList.contains("abstract") || element.classList.contains("keywords") || element.classList.contains("references")) {
+            return "paragraph";
+          }
+        }
         if (tag === "BLOCKQUOTE") return "blockquote";
         if (tag === "UL" || tag === "OL") return "list";
         if (tag === "TABLE") return "table";
         if (tag === "PRE") return "code";
+        if (tag === "MATH") {
+          return String(element.getAttribute("display") || "").toLowerCase() === "block" ? "math" : "";
+        }
         if (element.classList) {
           if (
             element.classList.contains("sourceCode")
@@ -5040,11 +6262,49 @@
         return Boolean(getPreviewCommentTargetKind(element));
       }
 
+      function isLatexPreviewCommentTargetElement(element, targetEl) {
+        if (!element || !(element instanceof Element) || !targetEl) return false;
+        const kind = getPreviewCommentTargetKind(element);
+        if (kind === "heading" || kind === "paragraph" || kind === "figure" || kind === "algorithm" || kind === "table") {
+          if (element.parentElement === targetEl) return true;
+          if (
+            kind === "paragraph"
+            && element.classList
+            && element.classList.contains("abstract")
+            && element.parentElement
+            && element.parentElement.tagName === "HEADER"
+            && element.parentElement.id === "title-block-header"
+            && element.parentElement.parentElement === targetEl
+          ) {
+            return true;
+          }
+          return false;
+        }
+        if (kind === "math") {
+          if (element.parentElement === targetEl) return true;
+          const bodyEl = element.parentElement;
+          const frameEl = bodyEl && bodyEl.parentElement;
+          return Boolean(
+            bodyEl
+            && bodyEl.classList
+            && bodyEl.classList.contains("studio-display-equation-body")
+            && frameEl
+            && frameEl.classList
+            && frameEl.classList.contains("studio-display-equation")
+            && frameEl.parentElement === targetEl
+          );
+        }
+        return false;
+      }
+
       function collectPreviewCommentTargetElements(targetEl) {
         if (!targetEl || typeof targetEl.querySelectorAll !== "function") return [];
-        const selector = "h1, h2, h3, h4, h5, h6, p, blockquote, ul, ol, table, div.sourceCode, pre, .callout-note, .callout-tip, .callout-warning, .callout-important, .callout-caution, .mermaid-container";
+        const selector = "h1, h2, h3, h4, h5, h6, p, figure, blockquote, ul, ol, table, div.sourceCode, pre, math[display='block'], .studio-display-equation, .studio-mathjax-fallback-display, .studio-page-break, .abstract, .keywords, .references, .callout-note, .callout-tip, .callout-warning, .callout-important, .callout-caution, .mermaid-container";
         return Array.from(targetEl.querySelectorAll(selector)).filter((element) => {
           if (!isPreviewCommentTargetElement(element)) return false;
+          if (editorLanguage === "latex" && !isLatexPreviewCommentTargetElement(element, targetEl)) {
+            return false;
+          }
           let ancestor = element.parentElement;
           while (ancestor && ancestor !== targetEl) {
             if (ancestor.classList && ancestor.classList.contains("preview-comment-block")) return false;
@@ -5061,6 +6321,13 @@
       function getNormalizedPreviewCommentSourceBlockText(sourceText, sourceBlock) {
         if (!sourceBlock) return "";
         const blockText = String(sourceText || "").slice(sourceBlock.start, sourceBlock.end);
+        if (editorLanguage === "latex") {
+          return normalizeLatexPreviewBlockText(blockText, sourceBlock.kind);
+        }
+        if (sourceBlock.kind === "page-break") {
+          const match = blockText.trim().match(/^\\(newpage|pagebreak|clearpage)/i);
+          return match ? String(match[1] || "").toLowerCase() : "page-break";
+        }
         if (supportsPreviewSelectionCommentsForBlockKind(sourceBlock.kind)) {
           return normalizeVisiblePreviewText(buildPreviewSelectionDisplayMap(blockText, sourceBlock.kind).text);
         }
@@ -5084,21 +6351,66 @@
       function getNormalizedPreviewCommentTargetText(targetEntry) {
         if (!targetEntry) return "";
         if (typeof targetEntry.normalizedText === "string") return targetEntry.normalizedText;
-        targetEntry.normalizedText = normalizeVisiblePreviewText(
-          targetEntry.element && typeof targetEntry.element.textContent === "string"
-            ? targetEntry.element.textContent
-            : "",
-        );
+        if (targetEntry.kind === "page-break") {
+          const element = targetEntry.element;
+          targetEntry.normalizedText = String(element && element.getAttribute ? (element.getAttribute("data-page-break-kind") || "page-break") : "page-break").toLowerCase();
+          return targetEntry.normalizedText;
+        }
+        targetEntry.normalizedText = buildNormalizedPreviewSearchText(targetEntry.element);
         return targetEntry.normalizedText;
       }
 
+      function isHighConfidencePreviewTextContainmentMatch(leftText, rightText) {
+        const left = String(leftText || "");
+        const right = String(rightText || "");
+        if (!left || !right || left === right) return false;
+        const shorter = left.length <= right.length ? left : right;
+        const longer = left.length <= right.length ? right : left;
+        if (shorter.length < 12) return false;
+        if (!/\s/.test(shorter)) return false;
+        return longer.includes(shorter);
+      }
+
+      function tokenizePreviewComparableText(text) {
+        return normalizeVisiblePreviewText(text)
+          .toLowerCase()
+          .split(/\s+/)
+          .map((token) => token.replace(/^[^0-9A-Za-z\u00C0-\uFFFF]+|[^0-9A-Za-z\u00C0-\uFFFF]+$/g, ""))
+          .filter((token) => token && (token.length >= 4 || /[A-Za-z\u00C0-\uFFFF]/.test(token)));
+      }
+
+      function getHighConfidenceLatexOrderedTokenMatchScore(targetText, desiredText) {
+        if (editorLanguage !== "latex") return -1;
+        const targetTokens = tokenizePreviewComparableText(targetText);
+        const desiredTokens = tokenizePreviewComparableText(desiredText);
+        if (targetTokens.length === 0 || desiredTokens.length < 5) return -1;
+
+        let targetTokenIndex = 0;
+        let matchedCount = 0;
+        for (const token of desiredTokens) {
+          while (targetTokenIndex < targetTokens.length && targetTokens[targetTokenIndex] !== token) {
+            targetTokenIndex += 1;
+          }
+          if (targetTokenIndex >= targetTokens.length) break;
+          matchedCount += 1;
+          targetTokenIndex += 1;
+        }
+
+        const matchRatio = matchedCount / desiredTokens.length;
+        if (matchedCount < 5 || matchRatio < 0.6) return -1;
+        return matchedCount * 1000 + Math.round(matchRatio * 100);
+      }
+
       function findMatchingPreviewCommentTargetIndex(sourceText, sourceBlock, targetBlocks, startIndex) {
         const desiredKind = sourceBlock ? sourceBlock.kind : "";
         const desiredText = getNormalizedPreviewCommentSourceBlockText(sourceText, sourceBlock);
+        const preferredStartIndex = Math.max(0, startIndex || 0);
         let fallbackIndex = -1;
         let containsIndex = -1;
+        let orderedTokenIndex = -1;
+        let orderedTokenScore = Number.NEGATIVE_INFINITY;
 
-        for (let i = Math.max(0, startIndex || 0); i < targetBlocks.length; i += 1) {
+        for (let i = preferredStartIndex; i < targetBlocks.length; i += 1) {
           const targetEntry = targetBlocks[i];
           if (!targetEntry || targetEntry.kind !== desiredKind) continue;
           if (fallbackIndex < 0) fallbackIndex = i;
@@ -5107,13 +6419,22 @@
             if (targetText === desiredText) {
               return i;
             }
-            if (containsIndex < 0 && (targetText.includes(desiredText) || desiredText.includes(targetText))) {
+            if (containsIndex < 0 && isHighConfidencePreviewTextContainmentMatch(targetText, desiredText)) {
               containsIndex = i;
             }
+            const latexTokenScore = getHighConfidenceLatexOrderedTokenMatchScore(targetText, desiredText);
+            if (latexTokenScore >= 0) {
+              const score = latexTokenScore - (Math.abs(i - preferredStartIndex) * 4);
+              if (score > orderedTokenScore) {
+                orderedTokenScore = score;
+                orderedTokenIndex = i;
+              }
+            }
           }
         }
 
         if (containsIndex >= 0) return containsIndex;
+        if (orderedTokenIndex >= 0) return orderedTokenIndex;
         return fallbackIndex;
       }
 
@@ -5132,6 +6453,7 @@
         const lineEnd = Math.max(lineStart, Number(blockEl.dataset.reviewNoteLineEnd) || lineStart);
         const summaryBtn = blockEl.querySelector(".preview-comment-summary");
         const addBtn = blockEl.querySelector(".preview-comment-add");
+        const jumpBtn = blockEl.querySelector(".preview-comment-jump");
         const lineLabel = summarizeReviewNoteAnchor({ lineStart: lineStart, lineEnd: lineEnd }).toLowerCase();
         const blockKindLabel = getPreviewCommentBlockKindLabel(blockEl.dataset.previewCommentKind || "paragraph");
         const blockKey = getPreviewCommentBlockKey(blockEl);
@@ -5155,6 +6477,16 @@
             : "";
           addBtn.setAttribute("aria-label", addBtn.title || "Comment");
         }
+
+        if (jumpBtn) {
+          jumpBtn.hidden = !hasSelection;
+          jumpBtn.textContent = "Jump";
+          jumpBtn.dataset.previewCommentMode = hasSelection ? "selection" : "";
+          jumpBtn.title = hasSelection
+            ? ("Jump to the current preview selection on this " + blockKindLabel + " in the raw editor (" + lineLabel + ").")
+            : "";
+          jumpBtn.setAttribute("aria-label", jumpBtn.title || "Jump");
+        }
       }
 
       function updatePreviewCommentBlocksForElement(targetEl) {
@@ -5167,6 +6499,7 @@
 
       function decorateRenderedEditorPreviewComments(targetEl, sourceText) {
         if (!targetEl || typeof targetEl.querySelectorAll !== "function") return;
+        splitMixedPreviewParagraphsAroundDisplayMath(targetEl);
         const sourceBlocks = scanSourcePreviewCommentBlocks(sourceText);
         const targetBlocks = collectPreviewCommentTargetElements(targetEl);
         if (sourceBlocks.length === 0 || targetBlocks.length === 0) return;
@@ -5201,9 +6534,17 @@
           const addBtn = document.createElement("button");
           addBtn.type = "button";
           addBtn.className = "preview-comment-add";
+          addBtn.dataset.previewCommentAction = "comment";
           addBtn.textContent = "Comment";
           controls.appendChild(addBtn);
 
+          const jumpBtn = document.createElement("button");
+          jumpBtn.type = "button";
+          jumpBtn.className = "preview-comment-jump";
+          jumpBtn.dataset.previewCommentAction = "jump";
+          jumpBtn.textContent = "Jump";
+          controls.appendChild(jumpBtn);
+
           originalElement.replaceWith(wrapper);
           wrapper.appendChild(controls);
           originalElement.classList.add("preview-comment-block-content");
@@ -5250,6 +6591,32 @@
         const blockEnd = Math.max(blockStart, Math.min(Number(blockEl.dataset.reviewNoteEnd) || blockStart, source.length));
         if (blockEnd <= blockStart) return null;
 
+        if (kind === "math") {
+          const selectedDisplayText = normalizeVisiblePreviewText(getPreviewMathSearchText(contentEl) || buildNormalizedPreviewSearchText(contentEl));
+          if (!selectedDisplayText) return null;
+          return {
+            selectionStart: blockStart,
+            selectionEnd: blockEnd,
+            lineStart: getLineNumberAtOffset(source, blockStart),
+            lineEnd: getLineNumberAtOffset(source, Math.max(blockStart, blockEnd - 1)),
+            selectedText: source.slice(blockStart, blockEnd),
+            selectedDisplayText,
+          };
+        }
+
+        if (editorLanguage === "latex") {
+          const selectedDisplayText = buildNormalizedPreviewRangeText(range);
+          if (!selectedDisplayText) return null;
+          return {
+            selectionStart: blockStart,
+            selectionEnd: blockEnd,
+            lineStart: getLineNumberAtOffset(source, blockStart),
+            lineEnd: getLineNumberAtOffset(source, Math.max(blockStart, blockEnd - 1)),
+            selectedText: source.slice(blockStart, blockEnd),
+            selectedDisplayText,
+          };
+        }
+
         const sourceBlockText = source.slice(blockStart, blockEnd);
         const displayMap = buildPreviewSelectionDisplayMap(sourceBlockText, kind);
         if (!displayMap.text || !displayMap.charStarts.length || !displayMap.charEnds.length) return null;
@@ -5257,8 +6624,8 @@
         const prefixRange = document.createRange();
         prefixRange.selectNodeContents(contentEl);
         prefixRange.setEnd(range.startContainer, range.startOffset);
-        const prefixText = normalizeVisiblePreviewText(prefixRange.toString());
-        const selectedDisplayText = normalizeVisiblePreviewText(range.toString());
+        const prefixText = buildNormalizedPreviewRangeText(prefixRange);
+        const selectedDisplayText = buildNormalizedPreviewRangeText(range);
         if (!selectedDisplayText) return null;
 
         const desiredStart = Math.max(0, Math.min(prefixText.length, displayMap.text.length));
@@ -5376,7 +6743,7 @@
         let bestScore = Number.NEGATIVE_INFINITY;
         Array.from(targetEl.querySelectorAll(".preview-comment-block")).forEach((blockEl) => {
           const contentEl = blockEl.querySelector(".preview-comment-block-content") || blockEl;
-          const blockText = normalizeVisiblePreviewText(buildNormalizedDomTextMap(contentEl).text);
+          const blockText = buildNormalizedPreviewSearchText(contentEl);
           if (!blockText) return;
           const matchIndex = blockText.indexOf(selectionText);
           if (matchIndex < 0) return;
@@ -5397,9 +6764,25 @@
         const source = String(sourceTextEl && sourceTextEl.value ? sourceTextEl.value : "");
         const range = resolveReviewNoteRange(note, source);
         if (!range) return false;
-        const blockEl = findPreviewCommentBlockForRange(targetEl, range) || findPreviewCommentBlockForNoteText(targetEl, note);
+        const rangeBlock = findPreviewCommentBlockForRange(targetEl, range);
+        const selectionText = getPreviewNoteNormalizedSelectionText(note);
+        let blockEl = rangeBlock;
+        if (selectionText) {
+          const rangeContentEl = rangeBlock ? (rangeBlock.querySelector(".preview-comment-block-content") || rangeBlock) : null;
+          const rangeText = rangeContentEl ? buildNormalizedPreviewSearchText(rangeContentEl) : "";
+          if (!rangeText || !rangeText.includes(selectionText)) {
+            blockEl = findPreviewCommentBlockForNoteText(targetEl, note) || rangeBlock;
+          }
+        }
         if (!blockEl) return false;
         const contentEl = blockEl.querySelector(".preview-comment-block-content") || blockEl;
+        if (String(blockEl.dataset && blockEl.dataset.previewCommentKind || "") === "math") {
+          if (typeof contentEl.scrollIntoView === "function") {
+            contentEl.scrollIntoView({ block: "center", inline: "nearest" });
+          }
+          setPreviewJumpHighlight(targetEl, contentEl, null);
+          return true;
+        }
         const inlineHighlightEl = createPreviewJumpInlineHighlight(contentEl, blockEl, note, range);
         if (typeof blockEl.scrollIntoView === "function") {
           blockEl.scrollIntoView({ block: "center", inline: "nearest" });
@@ -5760,12 +7143,17 @@
         });
       }
 
-      function addReviewNoteFromPreviewSelection(blockEl) {
+      function getActivePreviewSelectionAnchorForBlock(blockEl) {
         if (!blockEl) return null;
         const blockKey = getPreviewCommentBlockKey(blockEl);
-        const anchor = activePreviewCommentSelection && activePreviewCommentSelection.blockKey === blockKey
+        return activePreviewCommentSelection && activePreviewCommentSelection.blockKey === blockKey
           ? activePreviewCommentSelection
           : null;
+      }
+
+      function addReviewNoteFromPreviewSelection(blockEl) {
+        if (!blockEl) return null;
+        const anchor = getActivePreviewSelectionAnchorForBlock(blockEl);
         if (!anchor) {
           setStatus("Select some preview text within a single block first.", "warning");
           return null;
@@ -5840,14 +7228,13 @@
         });
       }
 
-      function jumpToReviewNote(noteId) {
-        const note = reviewNotes.find((entry) => entry && entry.id === noteId);
-        if (!note) return;
+      function jumpToReviewAnchor(anchor, options) {
+        if (!anchor) return false;
         const current = String(sourceTextEl.value || "");
-        const range = resolveReviewNoteRange(note, current);
+        const range = resolveReviewNoteRange(anchor, current);
         if (!range) {
-          setStatus("Could not find the anchored location for this comment.", "warning");
-          return;
+          setStatus((options && options.notFoundStatusMessage) || "Could not find the anchored location.", "warning");
+          return false;
         }
         suppressEditorSelectionComment = true;
         suppressedEditorSelectionStart = range.start;
@@ -5862,9 +7249,47 @@
           : (cb) => window.setTimeout(cb, 16);
         schedule(() => {
           scrollEditorRangeIntoView(range);
-          revealReviewNoteInPreview(note);
+          if (options && typeof options.afterJump === "function") {
+            options.afterJump(range);
+          }
           updateEditorSelectionCommentUi();
         });
+        if (!options || options.status !== false) {
+          setStatus((options && options.statusMessage) || "Jumped to anchored location in the editor.", "success");
+        }
+        return true;
+      }
+
+      function jumpToPreviewSelection(blockEl) {
+        if (!blockEl) return false;
+        const anchor = getActivePreviewSelectionAnchorForBlock(blockEl);
+        if (!anchor) {
+          setStatus("Select some preview text within a single block first.", "warning");
+          return false;
+        }
+        const jumped = jumpToReviewAnchor(anchor, {
+          statusMessage: "Jumped to preview selection in the raw editor.",
+        });
+        if (jumped) {
+          const selection = typeof window.getSelection === "function" ? window.getSelection() : null;
+          if (selection && typeof selection.removeAllRanges === "function") {
+            selection.removeAllRanges();
+          }
+          clearPreviewCommentSelection();
+        }
+        return jumped;
+      }
+
+      function jumpToReviewNote(noteId) {
+        const note = reviewNotes.find((entry) => entry && entry.id === noteId);
+        if (!note) return;
+        jumpToReviewAnchor(note, {
+          status: false,
+          notFoundStatusMessage: "Could not find the anchored location for this comment.",
+          afterJump: () => {
+            revealReviewNoteInPreview(note);
+          },
+        });
       }
 
       function deleteReviewNote(noteId) {
@@ -7797,14 +9222,14 @@
 
       function handlePreviewCommentActionMouseDown(event) {
         const target = event.target;
-        const actionBtn = target instanceof Element ? target.closest(".preview-comment-add, .preview-comment-summary") : null;
+        const actionBtn = target instanceof Element ? target.closest(".preview-comment-add, .preview-comment-jump, .preview-comment-summary") : null;
         if (!actionBtn) return;
         event.preventDefault();
       }
 
       function handlePreviewCommentActionClick(event) {
         const target = event.target;
-        const actionBtn = target instanceof Element ? target.closest(".preview-comment-add, .preview-comment-summary") : null;
+        const actionBtn = target instanceof Element ? target.closest(".preview-comment-add, .preview-comment-jump, .preview-comment-summary") : null;
         if (!actionBtn) return;
         const blockEl = actionBtn.closest(".preview-comment-block");
         if (!blockEl) return;
@@ -7812,6 +9237,11 @@
         event.stopPropagation();
         const mode = String(actionBtn.dataset && actionBtn.dataset.previewCommentMode ? actionBtn.dataset.previewCommentMode : "");
         if (!mode || !mode.startsWith("selection")) return;
+        const action = String(actionBtn.dataset && actionBtn.dataset.previewCommentAction ? actionBtn.dataset.previewCommentAction : "comment");
+        if (action === "jump") {
+          jumpToPreviewSelection(blockEl);
+          return;
+        }
         addReviewNoteFromPreviewSelection(blockEl);
       }