pi-studio 0.5.49 → 0.5.51

package/client/studio-client.js

@@ -53,7 +53,9 @@
       const lineNumberGutterContentEl = document.getElementById("lineNumberGutterContent");
       const lineNumberMeasureEl = document.getElementById("lineNumberMeasure");
       const sourcePreviewEl = document.getElementById("sourcePreview");
+      const editorSelectionActionsEl = document.getElementById("editorSelectionActions");
       const editorSelectionCommentBtn = document.getElementById("editorSelectionCommentBtn");
+      const editorSelectionJumpBtn = document.getElementById("editorSelectionJumpBtn");
       const leftPaneEl = document.getElementById("leftPane");
       const rightPaneEl = document.getElementById("rightPane");
       const sourceBadgeEl = document.getElementById("sourceBadge");
@@ -1904,6 +1906,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\\]";
@@ -3858,10 +3861,6 @@
               + " data-review-note-line-end='" + String(lineNumber) + "'"
               + " data-preview-comment-kind='" + escapeHtml(kind) + "'"
               + ">"
-              + "<div class='preview-comment-controls'>"
-              + "<button type='button' class='preview-comment-summary' hidden></button>"
-              + "<button type='button' class='preview-comment-add'>Comment</button>"
-              + "</div>"
               + "<div class='preview-comment-block-content preview-code-line-content'>" + lineHtml + "</div>"
               + "</div>",
           );
@@ -3877,6 +3876,7 @@
         clearPreviewJumpHighlight(targetEl);
         finishPreviewRender(targetEl);
         targetEl.innerHTML = buildCodePreviewHtmlWithCommentBlocks(text, editorLanguage || "");
+        ensurePreviewSelectionActions(targetEl);
         updatePreviewCommentBlocksForElement(targetEl);
         if (pane === "response") {
           applyPendingResponseScrollReset();
@@ -4447,10 +4447,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 +4457,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 +4671,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 +5486,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 +5500,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;
       }
 
@@ -5179,8 +5573,23 @@
         return bestIndex;
       }
 
+      function buildLiteralPreviewDisplayMap(text, rawOffsets) {
+        const source = String(text || "");
+        const rawMap = Array.isArray(rawOffsets) ? rawOffsets : [];
+        const charStarts = [];
+        const charEnds = [];
+        for (let i = 0; i < source.length; i += 1) {
+          charStarts.push(rawMap[i]);
+          charEnds.push(rawMap[i] + 1);
+        }
+        return buildNormalizedPreviewDisplayMap(source, charStarts, charEnds);
+      }
+
       function buildPreviewSelectionDisplayMap(blockText, kind) {
         const body = buildPreviewSelectionSourceBody(blockText, kind);
+        if (kind === "code-line" || kind === "diff-line" || kind === "text-line") {
+          return buildLiteralPreviewDisplayMap(body.text, body.rawOffsets);
+        }
         const inlineMap = buildPreviewInlineDisplayMap(body.text, body.rawOffsets);
         return buildNormalizedPreviewDisplayMap(inlineMap.text, inlineMap.charStarts, inlineMap.charEnds);
       }
@@ -5197,6 +5606,7 @@
       function getPreviewCommentSelectionKey(selection) {
         if (!selection) return "";
         return [
+          String(selection.paneId || ""),
           String(selection.blockKey || ""),
           String(selection.selectionStart || 0),
           String(selection.selectionEnd || 0),
@@ -5224,6 +5634,96 @@
           : null;
       }
 
+      function getPreviewSelectionPaneIdForNode(node) {
+        if (!node) return "";
+        const element = node instanceof Element ? node : node.parentElement;
+        const paneEl = element && typeof element.closest === "function"
+          ? element.closest("#sourcePreview, #critiqueView")
+          : null;
+        return paneEl && paneEl.id ? String(paneEl.id) : "";
+      }
+
+      function getPreviewSelectionPaneElement(paneId) {
+        if (paneId === "sourcePreview") return sourcePreviewEl;
+        if (paneId === "critiqueView") return critiqueViewEl;
+        return null;
+      }
+
+      function getActivePreviewSelectionForPane(paneId) {
+        if (!paneId) return null;
+        return activePreviewCommentSelection && activePreviewCommentSelection.paneId === paneId
+          ? activePreviewCommentSelection
+          : null;
+      }
+
+      function ensurePreviewSelectionActions(targetEl) {
+        if (!targetEl || typeof document.createElement !== "function") return null;
+        const paneId = targetEl.id ? String(targetEl.id) : "";
+        if (!paneId) return null;
+        const existing = Array.from(targetEl.children || []).find((child) => child.classList && child.classList.contains("preview-selection-actions"));
+        if (existing) {
+          existing.dataset.previewPane = paneId;
+          return existing;
+        }
+
+        const actionsEl = document.createElement("div");
+        actionsEl.className = "preview-selection-actions";
+        actionsEl.dataset.previewPane = paneId;
+        actionsEl.hidden = true;
+
+        const commentBtn = document.createElement("button");
+        commentBtn.type = "button";
+        commentBtn.className = "preview-comment-add";
+        commentBtn.dataset.previewCommentAction = "comment";
+        commentBtn.textContent = "Comment";
+        commentBtn.hidden = true;
+        actionsEl.appendChild(commentBtn);
+
+        const jumpBtn = document.createElement("button");
+        jumpBtn.type = "button";
+        jumpBtn.className = "preview-comment-jump";
+        jumpBtn.dataset.previewCommentAction = "jump";
+        jumpBtn.textContent = "Jump";
+        jumpBtn.hidden = true;
+        actionsEl.appendChild(jumpBtn);
+
+        targetEl.insertBefore(actionsEl, targetEl.firstChild || null);
+        return actionsEl;
+      }
+
+      function updatePreviewSelectionActions(targetEl) {
+        if (!targetEl) return;
+        const actionsEl = ensurePreviewSelectionActions(targetEl);
+        if (!actionsEl) return;
+        const paneId = targetEl.id ? String(targetEl.id) : "";
+        const selection = getActivePreviewSelectionForPane(paneId);
+        const commentBtn = actionsEl.querySelector(".preview-comment-add");
+        const jumpBtn = actionsEl.querySelector(".preview-comment-jump");
+        if (!selection) {
+          actionsEl.hidden = true;
+          if (commentBtn) commentBtn.hidden = true;
+          if (jumpBtn) jumpBtn.hidden = true;
+          return;
+        }
+        const lineLabel = summarizeReviewNoteAnchor(selection).toLowerCase();
+        const blockKindLabel = getPreviewCommentBlockKindLabel(selection.previewCommentKind || "paragraph");
+        actionsEl.hidden = false;
+        if (commentBtn) {
+          commentBtn.hidden = false;
+          commentBtn.dataset.previewCommentMode = "selection";
+          commentBtn.dataset.previewPane = paneId;
+          commentBtn.title = "Add a local comment from the current preview selection on this " + blockKindLabel + " (" + lineLabel + ").";
+          commentBtn.setAttribute("aria-label", commentBtn.title || "Comment");
+        }
+        if (jumpBtn) {
+          jumpBtn.hidden = false;
+          jumpBtn.dataset.previewCommentMode = "selection";
+          jumpBtn.dataset.previewPane = paneId;
+          jumpBtn.title = "Jump to the current preview selection on this " + blockKindLabel + " in the raw editor (" + lineLabel + ").";
+          jumpBtn.setAttribute("aria-label", jumpBtn.title || "Jump");
+        }
+      }
+
       function unwrapPreviewJumpHighlightElement(element) {
         if (!element || !element.parentNode) return;
         const parent = element.parentNode;
@@ -5277,8 +5777,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 +5998,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 +6203,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 +6321,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 +6366,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 +6425,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 +6475,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 +6526,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;
       }
 
@@ -5709,41 +6553,26 @@
 
       function updatePreviewCommentBlockState(blockEl, sourceText, displayNotes) {
         if (!blockEl || !blockEl.dataset) return;
-        const lineStart = Math.max(1, Number(blockEl.dataset.reviewNoteLineStart) || 1);
-        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 lineLabel = summarizeReviewNoteAnchor({ lineStart: lineStart, lineEnd: lineEnd }).toLowerCase();
-        const blockKindLabel = getPreviewCommentBlockKindLabel(blockEl.dataset.previewCommentKind || "paragraph");
         const blockKey = getPreviewCommentBlockKey(blockEl);
-        const hasSelection = Boolean(activePreviewCommentSelection && activePreviewCommentSelection.blockKey === blockKey);
+        const paneId = getPreviewSelectionPaneIdForNode(blockEl);
+        const hasSelection = Boolean(
+          activePreviewCommentSelection
+          && activePreviewCommentSelection.paneId === paneId
+          && activePreviewCommentSelection.blockKey === blockKey
+        );
 
         blockEl.classList.remove("has-comments");
         blockEl.classList.toggle("has-selection", hasSelection);
-
-        if (summaryBtn) {
-          summaryBtn.hidden = true;
-          summaryBtn.textContent = "";
-          summaryBtn.dataset.reviewNoteId = "";
-        }
-
-        if (addBtn) {
-          addBtn.hidden = !hasSelection;
-          addBtn.textContent = "Comment";
-          addBtn.dataset.previewCommentMode = hasSelection ? "selection" : "";
-          addBtn.title = hasSelection
-            ? ("Add a local comment from the current preview selection on this " + blockKindLabel + " (" + lineLabel + ").")
-            : "";
-          addBtn.setAttribute("aria-label", addBtn.title || "Comment");
-        }
       }
 
       function updatePreviewCommentBlocksForElement(targetEl) {
         if (!targetEl || typeof targetEl.querySelectorAll !== "function") return;
+        ensurePreviewSelectionActions(targetEl);
         const sourceText = String(sourceTextEl && sourceTextEl.value ? sourceTextEl.value : "");
         Array.from(targetEl.querySelectorAll(".preview-comment-block")).forEach((blockEl) => {
           updatePreviewCommentBlockState(blockEl, sourceText);
         });
+        updatePreviewSelectionActions(targetEl);
       }
 
       function decorateRenderedEditorPreviewComments(targetEl, sourceText) {
@@ -5771,35 +6600,20 @@
           wrapper.dataset.reviewNoteLineEnd = String(sourceBlock.lineEnd);
           wrapper.dataset.previewCommentKind = sourceBlock.kind;
 
-          const controls = document.createElement("div");
-          controls.className = "preview-comment-controls";
-
-          const summaryBtn = document.createElement("button");
-          summaryBtn.type = "button";
-          summaryBtn.className = "preview-comment-summary";
-          summaryBtn.hidden = true;
-          controls.appendChild(summaryBtn);
-
-          const addBtn = document.createElement("button");
-          addBtn.type = "button";
-          addBtn.className = "preview-comment-add";
-          addBtn.textContent = "Comment";
-          controls.appendChild(addBtn);
-
           originalElement.replaceWith(wrapper);
-          wrapper.appendChild(controls);
           originalElement.classList.add("preview-comment-block-content");
           wrapper.appendChild(originalElement);
         }
 
+        ensurePreviewSelectionActions(targetEl);
         updatePreviewCommentBlocksForElement(targetEl);
       }
 
       function refreshRenderedEditorPreviewComments() {
-        if (sourcePreviewEl && !sourcePreviewEl.hidden) {
+        if (sourcePreviewEl) {
           updatePreviewCommentBlocksForElement(sourcePreviewEl);
         }
-        if (critiqueViewEl && rightView === "editor-preview") {
+        if (critiqueViewEl) {
           updatePreviewCommentBlocksForElement(critiqueViewEl);
         }
       }
@@ -5845,6 +6659,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 +6819,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") {
@@ -6011,10 +6847,11 @@
       }
 
       function revealReviewNoteInPreview(note) {
-        if (!supportsPreviewCommentsForCurrentEditor()) return;
+        if (!supportsPreviewCommentsForCurrentEditor()) return false;
         if (rightView === "editor-preview" && critiqueViewEl && critiqueViewEl.isConnected) {
-          revealReviewNoteInPreviewElement(critiqueViewEl, note);
+          return revealReviewNoteInPreviewElement(critiqueViewEl, note);
         }
+        return false;
       }
 
       function updateActivePreviewCommentSelectionFromDom() {
@@ -6046,7 +6883,9 @@
 
         setActivePreviewCommentSelection({
           ...anchor,
+          paneId: getPreviewSelectionPaneIdForNode(startBlock),
           blockKey: getPreviewCommentBlockKey(startBlock),
+          previewCommentKind: String(startBlock.dataset && startBlock.dataset.previewCommentKind || "paragraph"),
         });
       }
 
@@ -6141,11 +6980,27 @@
           && typeof sourceTextEl.selectionEnd === "number"
           && sourceTextEl.selectionEnd > sourceTextEl.selectionStart
         );
+        const canJumpToPreview = Boolean(
+          hasSelection
+          && rightView === "editor-preview"
+          && critiqueViewEl
+          && supportsPreviewCommentsForCurrentEditor()
+        );
         editorSelectionCommentBtn.hidden = !hasSelection;
+        if (editorSelectionJumpBtn) {
+          editorSelectionJumpBtn.hidden = !canJumpToPreview;
+        }
+        if (editorSelectionActionsEl) {
+          editorSelectionActionsEl.hidden = !hasSelection;
+        }
         if (hasSelection) {
           editorSelectionCommentBtn.title = "Create a new local comment from the current editor selection.";
           editorSelectionCommentBtn.setAttribute("aria-label", editorSelectionCommentBtn.title);
         }
+        if (editorSelectionJumpBtn && canJumpToPreview) {
+          editorSelectionJumpBtn.title = "Jump to the current editor selection in the preview.";
+          editorSelectionJumpBtn.setAttribute("aria-label", editorSelectionJumpBtn.title);
+        }
       }
 
       function clearSuppressedEditorSelectionComment() {
@@ -6362,12 +7217,12 @@
         });
       }
 
-      function addReviewNoteFromPreviewSelection(blockEl) {
-        if (!blockEl) return null;
-        const blockKey = getPreviewCommentBlockKey(blockEl);
-        const anchor = activePreviewCommentSelection && activePreviewCommentSelection.blockKey === blockKey
-          ? activePreviewCommentSelection
-          : null;
+      function getActivePreviewSelectionAnchorForPane(paneId) {
+        return getActivePreviewSelectionForPane(paneId);
+      }
+
+      function addReviewNoteFromPreviewSelection(paneId) {
+        const anchor = getActivePreviewSelectionAnchorForPane(paneId);
         if (!anchor) {
           setStatus("Select some preview text within a single block first.", "warning");
           return null;
@@ -6403,6 +7258,12 @@
         if (editorSelectionCommentBtn) {
           editorSelectionCommentBtn.hidden = true;
         }
+        if (editorSelectionJumpBtn) {
+          editorSelectionJumpBtn.hidden = true;
+        }
+        if (editorSelectionActionsEl) {
+          editorSelectionActionsEl.hidden = true;
+        }
         const shouldOpenReviewNotes = !isReviewNotesOpen();
         pendingReviewNoteFocusId = note.id;
         setReviewNotes(reviewNotes.concat([note]));
@@ -6432,6 +7293,30 @@
         });
       }
 
+      function jumpToEditorSelectionInPreview() {
+        if (editorView !== "markdown") {
+          setStatus("Switch to Editor (Raw) before jumping from an editor selection.", "warning");
+          return false;
+        }
+        if (rightView !== "editor-preview" || !critiqueViewEl || !supportsPreviewCommentsForCurrentEditor()) {
+          setStatus("Open Editor (Preview) on the right to jump the current editor selection there.", "warning");
+          return false;
+        }
+        const anchor = getEditorAnchorForReviewNote();
+        const jumped = revealReviewNoteInPreview(anchor);
+        if (!jumped) {
+          setStatus("Could not find the current editor selection in the preview.", "warning");
+          return false;
+        }
+        const current = String(sourceTextEl.value || "");
+        const range = resolveReviewNoteRange(anchor, current);
+        if (range) {
+          scrollEditorRangeIntoView(range);
+        }
+        setStatus("Jumped to the current editor selection in the preview.", "success");
+        return true;
+      }
+
       function addReviewNoteFromEditorLine() {
         if (editorView !== "markdown") {
           setStatus("Switch to Editor (Raw) before adding a line comment.", "warning");
@@ -6442,14 +7327,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 +7348,56 @@
           : (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(paneId) {
+        const anchor = getActivePreviewSelectionAnchorForPane(paneId);
+        if (!anchor) {
+          setStatus("Select some preview text within a single block first.", "warning");
+          return false;
+        }
+        const previewNote = normalizeReviewNote(anchor);
+        const jumped = jumpToReviewAnchor(previewNote, {
+          statusMessage: "Jumped to preview selection in the raw editor.",
+          afterJump: () => {
+            const paneEl = getPreviewSelectionPaneElement(paneId);
+            if (paneEl && previewNote) {
+              revealReviewNoteInPreviewElement(paneEl, previewNote);
+            }
+            const schedule = typeof window.requestAnimationFrame === "function"
+              ? window.requestAnimationFrame.bind(window)
+              : (cb) => window.setTimeout(cb, 16);
+            schedule(() => {
+              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) {
@@ -8380,6 +9311,15 @@
         });
       }
 
+      if (editorSelectionJumpBtn) {
+        editorSelectionJumpBtn.addEventListener("mousedown", (event) => {
+          event.preventDefault();
+        });
+        editorSelectionJumpBtn.addEventListener("click", () => {
+          jumpToEditorSelectionInPreview();
+        });
+      }
+
       if (reviewNotesInlineAllBtn) {
         reviewNotesInlineAllBtn.addEventListener("click", () => {
           toggleAllReviewNotesInlineAnnotations();
@@ -8399,22 +9339,26 @@
 
       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;
         event.preventDefault();
         event.stopPropagation();
         const mode = String(actionBtn.dataset && actionBtn.dataset.previewCommentMode ? actionBtn.dataset.previewCommentMode : "");
         if (!mode || !mode.startsWith("selection")) return;
-        addReviewNoteFromPreviewSelection(blockEl);
+        const paneId = String(actionBtn.dataset && actionBtn.dataset.previewPane ? actionBtn.dataset.previewPane : "");
+        const action = String(actionBtn.dataset && actionBtn.dataset.previewCommentAction ? actionBtn.dataset.previewCommentAction : "comment");
+        if (action === "jump") {
+          jumpToPreviewSelection(paneId);
+          return;
+        }
+        addReviewNoteFromPreviewSelection(paneId);
       }
 
       if (leftPaneEl) {