pi-studio 0.5.49 → 0.5.50

package/CHANGELOG.md

@@ -4,6 +4,16 @@ All notable changes to `pi-studio` are documented here.
 
 ## [Unreleased]
 
+## [0.5.50] — 2026-04-09
+
+### Added
+- Editor-preview comments now also work for minimal structured LaTeX preview content, including headings, prose paragraphs, references sections, and whole display equations.
+- Preview-side selection affordances now include a transient **Jump** action alongside **Comment**, so you can reveal the corresponding raw-editor span without creating a local comment first.
+
+### Fixed
+- LaTeX preview comment mapping now follows Studio's rendered structure more closely, including title-block abstracts, loose prose after decorated display equations, bibliography/reference sections, and paragraph alignment around figures and rendered citation/reference text.
+- Preview comment controls for display equations now anchor to the outer rendered equation frame, improving visibility and making preview jump targeting more reliable.
+
 ## [0.5.49] — 2026-04-09
 
 ### Fixed

package/README.md

@@ -18,7 +18,7 @@ Extension for [pi](https://pi.dev) that opens a local two-pane browser workspace
 - Supports one canonical full Studio view per Pi session, plus additional editor-only companion views when you just want extra editing/preview surfaces
 - Runs editor text directly, or asks for structured critique (auto/writing/code focus)
 - Includes a local persistent scratchpad for quick notes you want to keep out of the main editor until you're ready to copy or insert them
-- Includes local comments anchored to selections/lines, shown in a docked **Comments** rail, with **Comment** actions from raw-editor selections plus editor-preview selections for Markdown and code/text/diff previews, alongside optional inline `[an: ...]` toggles when you want comments reflected in the document text
+- Includes local comments anchored to selections/lines, shown in a docked **Comments** rail, with **Comment** actions from raw-editor selections plus editor-preview selections for Markdown, LaTeX, and code/text/diff previews, alongside a transient preview **Jump** action and optional inline `[an: ...]` toggles when you want comments reflected in the document text
 - Browses response history (`Prev/Next/Last`) and loads either:
   - response text
   - critique notes/full critique

package/client/studio-client.js

@@ -1904,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\\]";
@@ -3860,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>",
@@ -4447,10 +4449,9 @@
       }
 
       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) {
@@ -4458,6 +4459,8 @@
         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";
@@ -4670,6 +4673,389 @@
           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":
@@ -5102,12 +5488,12 @@
 
       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") {
-          const texSource = element.getAttribute("data-tex-source");
-          if (texSource && texSource.trim()) {
-            return texSource;
-          }
           return typeof element.textContent === "string" ? element.textContent : "";
         }
         if (element.classList && element.classList.contains("math") && (element.classList.contains("inline") || element.classList.contains("display"))) {
@@ -5116,6 +5502,16 @@
             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;
       }
 
@@ -5277,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) {
@@ -5497,8 +5894,199 @@
         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"));
+        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) {
@@ -5511,8 +6099,63 @@
         });
       }
 
+      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;
@@ -5574,6 +6217,20 @@
         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";
@@ -5605,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, math[display='block'], .studio-mathjax-fallback-display, .studio-page-break, .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;
@@ -5626,6 +6321,9 @@
       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";
@@ -5673,13 +6371,46 @@
         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;
@@ -5691,10 +6422,19 @@
             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;
       }
 
@@ -5713,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);
@@ -5736,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) {
@@ -5783,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");
@@ -5845,6 +6604,19 @@
           };
         }
 
+        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;
@@ -5992,7 +6764,16 @@
         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") {
@@ -6362,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;
@@ -6442,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;
@@ -6464,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) {
@@ -8399,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;
@@ -8414,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);
       }
 

package/client/studio.css

@@ -920,18 +920,19 @@
       position: absolute;
       top: 0;
       right: 0;
-      z-index: 4;
+      z-index: 6;
       display: inline-flex;
       align-items: center;
       gap: 8px;
-      transform: translateY(-0.38rem);
+      transform: translateY(-0.46rem);
     }
 
     .preview-comment-summary {
       display: none !important;
     }
 
-    .preview-comment-add {
+    .preview-comment-add,
+    .preview-comment-jump {
       display: inline-flex;
       align-items: center;
       justify-content: center;
@@ -950,14 +951,17 @@
       box-shadow: 0 1px 2px rgba(0, 0, 0, 0.08);
     }
 
-    .preview-comment-block.has-selection .preview-comment-add {
+    .preview-comment-block.has-selection .preview-comment-add,
+    .preview-comment-block.has-selection .preview-comment-jump {
       opacity: 1;
       pointer-events: auto;
       transform: translateY(0);
     }
 
     .preview-comment-add:hover,
-    .preview-comment-add:focus-visible {
+    .preview-comment-add:focus-visible,
+    .preview-comment-jump:hover,
+    .preview-comment-jump:focus-visible {
       background: var(--accent-soft-strong);
       color: var(--accent);
       border-color: var(--accent);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "pi-studio",
-  "version": "0.5.49",
+  "version": "0.5.50",
   "description": "Two-pane browser workspace for pi with prompt/response editing, annotations, critiques, prompt/response history, and live Markdown/LaTeX/code preview",
   "type": "module",
   "license": "MIT",